Aktywność uruchom ponownie przy rotacji Androida

Aktualizacja dla Androida 3.2 i nowszych:

Uwaga : począwszy od systemu Android 3.2 (poziom API 13), "Rozmiar ekranu" zmienia się również, gdy urządzenie przełącza się między orientacją pionową i poziomą. Tak więc, jeśli chcesz zapobiec ponownemu uruchomieniu runtime z powodu zmiany orientacji podczas tworzenia dla poziomu API 13 lub wyższego (zadeklarowanego przez atrybuty minSdkVersion i targetSdkVersion), musisz dodać wartość "screenSize" oprócz wartości "orientation". Oznacza to, że musisz declare android:configChanges="orientation|screenSize". Jeśli jednak Twoja aplikacja ma poziom API 12 lub niższy, Twoja aktywność zawsze obsługuje tę zmianę konfiguracji samodzielnie(ta zmiana konfiguracji nie uruchamia ponownie Twojej aktywności, nawet jeśli jest uruchomiona na urządzeniu z systemem Android 3.2 lub wyższym).

Zamiast próbować powstrzymać onCreate() przed całkowitym zwolnieniem, może spróbuj sprawdzić Bundle savedInstanceState jest przekazywane do zdarzenia, aby sprawdzić, czy jest null, czy nie.

Na przykład, jeśli mam jakąś logikę, która powinna być uruchomiona, gdy Activity jest naprawdę utworzona, a nie przy każdej zmianie orientacji, uruchamiam tę logikę w onCreate() tylko wtedy, gdy savedInstanceState jest null.

W przeciwnym razie nadal chcę, aby układ został odpowiednio wyrysowany dla orientacji.

public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_game_list);

        if(savedInstanceState == null){
            setupCloudMessaging();
        }
}

Nie wiem, czy jest to ostateczny odpowiedz, ale mi to odpowiada.

Co zrobiłem...

W manifeście, do sekcji Aktywność, Dodano:

android:configChanges="keyboardHidden|orientation"

W kodzie działania, zaimplementowany:

//used in onCreate() and onConfigurationChanged() to set up the UI elements
public void InitializeUI()
{
    //get views from ID's
    this.textViewHeaderMainMessage = (TextView) this.findViewById(R.id.TextViewHeaderMainMessage);

    //etc... hook up click listeners, whatever you need from the Views
}

//Called when the activity is first created.
@Override
public void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    InitializeUI();
}

//this is called when the screen rotates.
// (onCreate is no longer called when screen rotates due to manifest, see: android:configChanges)
@Override
public void onConfigurationChanged(Configuration newConfig)
{
    super.onConfigurationChanged(newConfig);
    setContentView(R.layout.main);

    InitializeUI();
}

To, co opisujesz, jest domyślnym zachowaniem. Musisz wykryć i obsłużyć te zdarzenia samodzielnie, dodając:

android:configChanges

Do manifestu, a następnie zmian, które chcesz obsłużyć. Więc dla orientacji użyłbyś:

android:configChanges="orientation"

A do otwierania lub zamykania klawiatury używasz:

android:configChanges="keyboardHidden"

JeĹ "li chcesz obsĹ' ugiwaÄ ‡ oba moĹźesz po prostu oddzieliÄ ‡ je poleceniem pipe np:

android:configChanges="keyboardHidden|orientation"

Spowoduje to uruchomienie metody onConfigurationChanged w dowolnej aktywności ty zadzwoń. Jeśli nadpisujesz metodę, możesz przekazać nowe wartości.

Właśnie odkryłem tę wiedzę:

Za podtrzymywanie aktywności poprzez zmianę orientacji, a prowadzenie jej przez onConfigurationChanged, Dokumentacja i przykład kodu powyżej sugerują to w pliku manifestu:

android:configChanges="keyboardHidden|orientation"

Bonus polega na tym, że pominięcie keyboardHidden może wydawać się logiczne, ale powoduje błędy w emulatorze (przynajmniej dla Androida 2.1): podanie tylko orientation spowoduje wywołanie emulatora zarówno OnCreate i onConfigurationChanged Czasami, a tylko OnCreate innym razem.

Nie widziałem awarii na urządzeniu, ale słyszałem o awarii emulatora dla innych. Więc warto to udokumentować.

Możesz również rozważyć użycie sposobu przechowywania danych przez platformę Android w przypadku zmian orientacji: onRetainNonConfigurationInstance() i getLastNonConfigurationInstance().

Pozwala to na utrwalanie danych w trakcie zmian konfiguracji, takich jak informacje uzyskane z serwera lub coś innego, co zostało obliczone w onCreate lub od tego czasu, jednocześnie pozwalając Androidowi Na ponowne ułożenie Activity przy użyciu pliku xml do orientacji, która jest obecnie używana.

Zobacztutaj lubtutaj .

Powinno należy zauważyć, że metody te są obecnie przestarzałe (chociaż nadal bardziej elastyczne niż obsługa zmiany orientacji samodzielnie, jak sugeruje większość powyższych rozwiązań) z zaleceniem, aby wszyscy przełączyli się na Fragments i zamiast tego używali setRetainInstance(true) na każdym Fragment, który chcesz zachować.

Podejście jest użyteczne, ale jest niekompletne przy użyciu fragmentów.

Fragmenty są zwykle odtwarzane po zmianie konfiguracji. Jeśli nie chcesz, aby tak się stało, użyj

setRetainInstance(true); w konstruktorze (- ach) fragmentu

Spowoduje to zachowanie fragmentów podczas zmiany konfiguracji.

Http://developer.android.com/reference/android/app/Fragment.html#setRetainInstance(boolean)

Po prostu dodałem

     android:configChanges="keyboard|keyboardHidden|orientation"

W pliku manifestu i nie dodałem żadnej metody onConfigurationChanged w mojej aktywności.

Więc za każdym razem, gdy klawiatura wysuwa się lub nic się nie dzieje.

 onConfigurationChanged is called when the screen rotates. 
 (onCreate is no longer called when screen rotates due to manifest, see:  
 android:configChanges)

Także, Dokumenty Google mówią, aby unikać używania android:configChanges (z wyjątkiem ostateczności).... Ale wtedy alternatywne metody sugerują wszystkie czy używać android:configChanges.

Z mojego doświadczenia wynika, że emulator zawsze wywołuje onCreate() po rotacji.
Ale urządzenia 1-2, na których uruchamiam ten sam kod... nie. (Nie wiem, dlaczego miałaby być jakaś różnica.)

Dodaj ten wiersz do manifestu: -

android:configChanges="orientation|keyboard|keyboardHidden|screenSize|screenLayout|uiMode"

I ten fragment do aktywności:-

@Override
    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                WindowManager.LayoutParams.FLAG_FULLSCREEN);
    }

Zmiany, które należy wprowadzić w manifeście Androida to:

android:configChanges="keyboardHidden|orientation" 

Dodatki do wykonania wewnątrz aktywności to:

public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);

    // Checks the orientation of the screen
    if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) {
        Toast.makeText(this, "landscape", Toast.LENGTH_SHORT).show();
    } else if (newConfig.orientation == Configuration.ORIENTATION_PORTRAIT) {
        Toast.makeText(this, "portrait", Toast.LENGTH_SHORT).show();
    }
}

Metoda onCreate jest nadal wywoływana nawet po zmianie orientation Androida. Więc przeniesienie wszystkich ciężkich funkcji do tej metody nie pomoże ci

Umieść poniższy kod wewnątrz twojego znacznika <activity> w Manifest.xml:

android:configChanges="screenLayout|screenSize|orientation"

Istnieje kilka sposobów, aby to zrobić:

Zapisz Stan Aktywności

Możesz zapisać stan aktywności w onSaveInstanceState.

@Override
public void onSaveInstanceState(Bundle outState) {
    /*Save your data to be restored here
    Example : outState.putLong("time_state", time); , time is a long variable*/
    super.onSaveInstanceState(outState);
}

A następnie użyj bundle, aby przywrócić stan.

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

    if(savedInstanceState!= null){
       /*When rotation occurs
        Example : time = savedInstanceState.getLong("time_state", 0); */
    } else {
      //When onCreate is called for the first time
    }
}

Samodzielnie obsługuj zmiany orientacji

Inną alternatywą jest samodzielna obsługa zmian orientacji. Nie jest to jednak uważane za dobrą praktykę.

Dodaj to do swojego pliku manifestu.

android:configChanges="keyboardHidden|orientation"

Dla Androida 3.2 i później:

android:configChanges="keyboardHidden|orientation|screenSize"

@Override
public void onConfigurationChanged(Configuration config) {
    super.onConfigurationChanged(config);

if (newConfig.orientation == Configuration.ORIENTATION_PORTRAIT) {
        //Handle rotation from landscape to portarit mode here
    } else if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE){
        //Handle rotation from portrait to landscape mode here
    }
}

Ogranicz rotację

Możesz także ograniczyć aktywność do trybu pionowego lub poziomego, aby uniknąć rotacji.

Dodaj to do tagu aktywności w pliku manifestu:

        android:screenOrientation="portrait"

Lub zaimplementuj to programowo w swojej aktywności:

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}

Jest to bardzo proste, wystarczy wykonać następujące kroki:

<activity
    android:name=".Test"
    android:configChanges="orientation|screenSize"
    android:screenOrientation="landscape" >
</activity>

To działa dla mnie:

Uwaga: orientacja zależy od Twojego zapotrzebowania

Sposób, w jaki znalazłem, to użycie onRestoreInstanceState i onSaveInstanceState zdarzeń, aby zapisać coś w Bundle (nawet jeśli nie potrzebujesz zapisywania żadnych zmiennych, po prostu włóż coś tam, aby Bundle nie było puste). Następnie w metodzie onCreate sprawdź, czy Bundle jest pusta, a jeśli tak, to zrób inicjalizację, jeśli nie, to zrób to.

Mimo, że nie jest to "sposób na Androida", uzyskałem bardzo dobre wyniki, sam obsługując zmiany orientacji i po prostu zmieniając pozycję widżetów w widoku, aby wziąć pod uwagę zmienioną orientację. Jest to szybsze niż jakiekolwiek inne podejście, ponieważ twoje poglądy nie muszą być zapisywane i przywracane. Zapewnia również bardziej bezproblemową obsługę dla użytkownika, ponieważ respositioned widgets są dokładnie takie same widgety, po prostu przeniesione i / lub zmienić rozmiar. Nie tylko stan modelu, ale także widok Stan, mogą być zachowane w ten sposób.

RelativeLayout czasami może być dobrym wyborem dla widoku, który musi się zmieniać od czasu do czasu. Wystarczy podać zestaw param układu pionowego i zestaw param układu krajobrazu, z różnymi względnymi regułami pozycjonowania dla każdego widżetu potomnego. Następnie, w swojej metodzie onConfigurationChanged(), przekazujesz odpowiednią do wywołania setLayoutParams() każdego dziecka. Jeśli Dowolna kontrola nad dzieckiem musi być wewnętrznie przeorientowana, wystarczy wywołać metodę na to dziecko do przeprowadzenia reorientacji. To dziecko w podobny sposób wywołuje metody na dowolnym z jego kontrolek potomnych, które wymagają wewnętrznej reorientacji i tak dalej.

Uwaga: zamieszczam tę odpowiedź, jeśli ktoś w przyszłości spotka się z tym samym problemem co ja. Dla mnie nie wystarczyła następująca linijka:

android:configChanges="orientation"

Kiedy obróciłem ekran, metoda ' onConfigurationChanged (Konfiguracja newConfig) nie została wywołana.

Rozwiązanie: musiałem również dodać "screenSize", nawet jeśli problem miał związek z orientacją. Więc w AndroidManifest.XML-file, add this:

android:configChanges="keyboardHidden|orientation|screenSize"

Następnie zaimplementuj metodę onConfigurationChanged(Configuration newConfig)

Musisz użyć metody onSavedInstanceState, aby zapisać całą wartość do jej parametru is has that is bundle

@Override
    public void onSaveInstanceState(Bundle outState, PersistableBundle outPersistentState) {
        super.onSaveInstanceState(outState, outPersistentState);
        outPersistentState.putBoolean("key",value);
    }

I używać

@Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
        savedInstanceState.getBoolean("key");
    } 

Aby pobrać i ustawić wartość view objects będzie obsługiwał obroty ekranu

Za każdym razem, gdy ekran jest obrócony, Otwarta aktywność jest zakończona, a onCreate() jest wywoływana ponownie.

1 . Możesz zrobić jedną rzecz, zapisać stan aktywności, gdy ekran jest obrócony, tak, że można odzyskać wszystkie stare rzeczy, gdy activity ' s OnCreate () jest wywoływana ponownie. Refer this link

2 . Jeśli chcesz zapobiec ponownemu uruchomieniu aktywności, po prostu umieść następujące linie w manifeście.plik xml.

  <activity android:name=".Youractivity"
  android:configChanges="orientation|screenSize"/>

W sekcji aktywności manifest dodaj:

android:configChanges="keyboardHidden|orientation"

Dodaj tę linię android: configChanges= " orientation|screenSize" in manifest

Po chwili prób i błędów znalazłem rozwiązanie, które pasuje do moich potrzeb w większości sytuacji. Oto kod:

Konfiguracja manifestu:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="com.pepperonas.myapplication">

    <application
        android:name=".App"
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity
            android:name=".MainActivity"
            android:configChanges="orientation|keyboardHidden|screenSize">
            <intent-filter>
                <action android:name="android.intent.action.MAIN"/>

                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>
        </activity>
    </application>

</manifest>

Główna aktywność:

import android.content.res.Configuration;
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentTransaction;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.Button;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private static final String TAG = "MainActivity";

    private Fragment mFragment;

    private int mSelected = -1;


    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d(TAG, "onCreate  " + "");

        // null check not realy needed - but just in case...
        if (savedInstanceState == null) {

            initUi();

            // get an instance of FragmentTransaction from your Activity
            FragmentManager fragmentManager = getSupportFragmentManager();
            FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();

            /*IMPORTANT: Do the INITIAL(!) transaction only once!
            * If we call this everytime the layout changes orientation,
            * we will end with a messy, half-working UI.
            * */
            mFragment = FragmentOne.newInstance(mSelected = 0);
            fragmentTransaction.add(R.id.frame, mFragment);
            fragmentTransaction.commit();
        }
    }


    @Override
    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);
        Log.d(TAG, "onConfigurationChanged  " +
                   (newConfig.orientation
                    == Configuration.ORIENTATION_LANDSCAPE
                    ? "landscape" : "portrait"));

        initUi();

        Log.i(TAG, "onConfigurationChanged - last selected: " + mSelected);
        makeFragmentTransaction(mSelected);
    }


    /**
     * Called from {@link #onCreate} and {@link #onConfigurationChanged}
     */
    private void initUi() {
        setContentView(R.layout.activity_main);
        Log.d(TAG, "onCreate  instanceState == null / reinitializing..." + "");
        Button btnFragmentOne = (Button) findViewById(R.id.btn_fragment_one);
        Button btnFragmentTwo = (Button) findViewById(R.id.btn_fragment_two);
        btnFragmentOne.setOnClickListener(this);
        btnFragmentTwo.setOnClickListener(this);
    }


    /**
     * Not invoked (just for testing)...
     */
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        Log.d(TAG, "onSaveInstanceState  " + "YOU WON'T SEE ME!!!");
    }


    /**
     * Not invoked (just for testing)...
     */
    @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
        Log.d(TAG, "onSaveInstanceState  " + "YOU WON'T SEE ME, AS WELL!!!");
    }


    @Override
    protected void onResume() {
        super.onResume();
        Log.d(TAG, "onResume  " + "");
    }


    @Override
    protected void onPause() {
        super.onPause();
        Log.d(TAG, "onPause  " + "");
    }


    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "onDestroy  " + "");
    }


    @Override
    public void onClick(View v) {

        switch (v.getId()) {
            case R.id.btn_fragment_one:
                Log.d(TAG, "onClick btn_fragment_one " + "");
                makeFragmentTransaction(0);
                break;

            case R.id.btn_fragment_two:
                Log.d(TAG, "onClick btn_fragment_two " + "");
                makeFragmentTransaction(1);
                break;

            default:
                Log.d(TAG, "onClick  null - wtf?!" + "");
        }
    }


    /**
     * We replace the current Fragment with the selected one.
     * Note: It's called from {@link #onConfigurationChanged} as well.
     */
    private void makeFragmentTransaction(int selection) {

        switch (selection) {
            case 0:
                mFragment = FragmentOne.newInstance(mSelected = 0);
                break;
            case 1:
                mFragment = FragmentTwo.newInstance(mSelected = 1);
                break;
        }

        // Create new transaction
        FragmentTransaction transaction = getSupportFragmentManager().beginTransaction();

        // Replace whatever is in the fragment_container view with this fragment,
        // and add the transaction to the back stack
        transaction.replace(R.id.frame, mFragment);

        /*This would add the Fragment to the backstack...
        * But right now we comment it out.*/
        //        transaction.addToBackStack(null);

        // Commit the transaction
        transaction.commit();
    }

}

I przykładowy Fragment:

import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

/**
 * @author Martin Pfeffer (pepperonas)
 */
public class FragmentOne extends Fragment {

    private static final String TAG = "FragmentOne";


    public static Fragment newInstance(int i) {
        Fragment fragment = new FragmentOne();
        Bundle args = new Bundle();
        args.putInt("the_id", i);
        fragment.setArguments(args);
        return fragment;
    }


    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        Log.d(TAG, "onCreateView  " + "");
        return inflater.inflate(R.layout.fragment_one, container, false);
    }

}

Można znaleźć na github.

Użyj słuchacza orientation do wykonywania różnych zadań na różnych orientacjach.

@Override
public void onConfigurationChanged(Configuration myConfig) 
{
    super.onConfigurationChanged(myConfig);
    int orient = getResources().getConfiguration().orientation; 
    switch(orient) 
    {
       case Configuration.ORIENTATION_LANDSCAPE:
          setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
                    break;
       case Configuration.ORIENTATION_PORTRAIT:
          setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
                    break;
       default:
          setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
    }
}

Umieść poniższy kod w swoim Activity w Android Manifest.

android:configChanges="orientation"

To nie uruchomi ponownie Twojej aktywności, gdy zmienisz orientację.

Napraw orientację ekranu (poziomą lub pionową) w AndroidManifest.xml

android:screenOrientation="portrait" lub android:screenOrientation="landscape"

W tym celu twoja metoda onResume() nie jest wywoływana.

Ludzie mówią, że powinieneś używać

android:configChanges="keyboardHidden|orientation"

Ale najlepszym i najbardziej profesjonalnym sposobem obsługi rotacji w Androidzie jest użycie klasy Loader. To nie jest słynna Klasa( Nie wiem dlaczego), ale jest o wiele lepsza niż AsyncTask. Aby uzyskać więcej informacji, zapoznaj się z samouczkami na Androida znajdującymi się w kursach Udacity na Androida.

Oczywiście w inny sposób można zapisać wartości lub widoki za pomocą onSaveInstanceState i odczytać je za pomocą onRestoreInstanceState. To zależy od naprawdę.

Możesz zablokować bieżącą orientację ekranu za pomocą tego kodu...

int currentOrientation =context.getResources().getConfiguration().orientation;
        if (currentOrientation == Configuration.ORIENTATION_PORTRAIT) {
            ((Activity) context).setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        } else {
            ((Activity) context). setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
        }

Możesz użyć obiektu ViewModel w swojej aktywności.

Obiekty ViewModel są automatycznie zatrzymywane podczas zmian konfiguracji, dzięki czemu przechowywane w nich dane są natychmiast dostępne dla następnej aktywności lub wystąpienia fragmentu. Czytaj więcej:

Https://developer.android.com/topic/libraries/architecture/viewmodel