Aktivität Neustart bei Rotation Android

Question

In meinem Android-Anwendung, wenn ich das Gerät (schieben Sie die Tastatur heraus) drehen dann meine Activity neu gestartet wird (onCreate genannt wird). Nun, dies ist wahrscheinlich, wie es sein sollte, aber ich habe eine Menge Ersteinrichtung im onCreate Methode, also muss ich entweder:

1. Legen Sie alle Anfangseinstellung in einer anderen Funktion auf, so dass es auf dem Gerät Rotation oder
verloren ist nicht alles
2. Machen Sie es so ist onCreate nicht wieder aufgerufen und das Layout gerade passt oder
3. Begrenzen Sie die App nur Porträt so dass onCreate wird nicht aufgerufen.

Answer 1

Verwenden der Anwendungsklasse

Je nachdem, was Sie in Ihrer Initialisierung tun Sie in Erwägung ziehen könnte, eine neue Klasse zu schaffen, die in dieser Klasse Application und bewegen Sie die Initialisierung Code in einer überschriebenen onCreate Methode erweitert.

public class MyApplicationClass extends Application {
  @Override
  public void onCreate() {
    super.onCreate();
    // TODO Put your application initialization code here.
  }
}

Die onCreate in der Anwendungsklasse wird nur aufgerufen, wenn die gesamte Anwendung erstellt wird, so dass die Aktivität startet auf Ausrichtung oder Tastatur Sichtbarkeit Änderungen wird es nicht auslösen.

Es ist eine gute Übung, die Instanz dieser Klasse als Singleton und das Aussetzen der Anwendungsvariablen Sie Initialisierung mit Getter und Setter.

aussetzen

Hinweis: Sie werden die Namen der neuen Anwendungsklasse im Manifest angeben müssen für sie registriert und verwendet werden:

<application
    android:name="com.you.yourapp.MyApplicationClass"

Als Reaktion auf Konfigurationsänderungen [UPDATE: die seit API ist veraltet 13; die empfohlene Alternative ]

Als eine weitere Alternative können Sie Ihre Anwendung für Ereignisse hören, die einen Neustart verursachen würden - wie Orientierung und Tastatur Sichtbarkeit Änderungen -. Und mit ihnen umgehen in Ihrer Aktivität

Starten Sie, indem Sie den android:configChanges Knoten zu Ihrer Aktivität Manifest node

 <activity android:name=".MyActivity"
      android:configChanges="orientation|keyboardHidden"
      android:label="@string/app_name">

oder für Android 3.2 (API-Ebene 13) und neuere :

<activity android:name=".MyActivity"
      android:configChanges="keyboardHidden|orientation|screenSize"
      android:label="@string/app_name">

Dann in der Aktivität die onConfigurationChanged Methode außer Kraft setzen und rufen setContentView das GUI-Layout zu zwingen, in der neuen Ausrichtung neu gemacht werden.

@Override
public void onConfigurationChanged(Configuration newConfig) {
  super.onConfigurationChanged(newConfig);
  setContentView(R.layout.myLayout);
}

Answer 2

Update für Android 3.2 und höher:

  

Caution : Beginnend mit Android 3.2 (API-Ebene 13), "Bildgröße" ändert sich auch , wenn das Gerät schaltet zwischen Hochformat und Querformat. Wenn Sie also Laufzeit neu gestartet wird aufgrund Orientierungsänderung verhindern sollen, wenn für die API-Level 13 oder höher zu entwickeln (wie von der minSdkVersion und targetSdkVersion erklären Attribute), müssen Sie den Wert "screenSize" neben dem "orientation" Wert enthalten. Das heißt, Sie müssen android:configChanges="orientation|screenSize" erklären. Allerdings, wenn Ihre Anwendung API-Level 12 oder niedriger zielt, dann Ihre Aktivität immer behandelt diese Konfigurationsänderung selbst (diese Konfigurationsänderung nicht Ihre Aktivität nicht neu starten, selbst wenn sie auf einem Android 3.2 oder höher Gerät ausgeführt wird).

Answer 3

Anstatt zu versuchen, die onCreate() davor insgesamt gefeuert zu stoppen, vielleicht versuchen, die Bundle savedInstanceState Überprüfung in das Ereignis übergeben wird, um zu sehen, ob es null ist oder nicht.

Zum Beispiel, wenn ich eine gewisse Logik haben, die ausgeführt werden soll, wenn die Activity wirklich erstellt wird, nicht auf jeder Orientierungsänderung, ich laufe nur, dass die Logik in der onCreate() nur, wenn die savedInstanceState null ist.

Ansonsten will ich noch das Layout richtig für die Ausrichtung neu zu zeichnen.

public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_game_list);

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

nicht sicher, ob dies die ultimative Antwort ist, aber es funktioniert für mich.

Answer 4

was ich getan habe ...

im Manifest, auf die Aktivität Abschnitt hinzugefügt:

android:configChanges="keyboardHidden|orientation"

in dem Code für die Aktivität implementiert:

//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();
}

Answer 5

Was Sie beschreiben, ist das Standardverhalten. Sie müssen erkennen und behandeln diese Ereignisse selbst durch Hinzufügen:

android:configChanges

Ihre manifestiert und dann die Änderungen, die Sie wollen, zu behandeln. Also für Orientierung, verwenden Sie:

android:configChanges="orientation"

und für die Tastatur geöffnet oder geschlossen würden Sie verwenden:

android:configChanges="keyboardHidden"

Wenn Sie behandeln sowohl Sie können sie nur mit dem Pipe-Befehl trennen wie:

android:configChanges="keyboardHidden|orientation"

Dies löst die onConfigurationChanged Methode in welcher Aktivität rufen Sie an. Wenn Sie die Methode außer Kraft setzen Sie in den neuen Werten passieren kann.

Hope, das hilft.

Answer 6

Ich habe gerade entdeckt diese Überlieferung:

Für die Aktivität am Leben durch eine Orientierungsänderung zu halten und es durch onConfigurationChanged Handhabung die Dokumentation und das Codebeispiel oben vorschlägt, dies in der Manifest-Datei:

<activity android:name=".MyActivity"
      android:configChanges="orientation|keyboardHidden"
      android:label="@string/app_name">

was den zusätzlichen Vorteil hat, dass es immer funktioniert.

Der Bonus Lore ist, dass die keyboardHidden Weglassen logisch erscheinen mag, aber es verursacht Fehler im Emulator (für Android 2.1 mindestens): Angabe nur orientation wird den Emulator Aufruf sowohl OnCreate und onConfigurationChanged macht manchmal, und OnCreate nur zu anderen Zeiten.

Ich habe nicht den Fehler auf einem Gerät gesehen, aber ich habe über den Emulator andernfalls für andere gehört. Es lohnt sich also Dokumentieren.

Answer 7

Sie könnten auch erwägen mit der Art und Weise der Android-Plattform von Daten über Orientierungsänderungen persistierenden. onRetainNonConfigurationInstance() und getLastNonConfigurationInstance()

Auf diese Weise können Sie Daten über Konfigurationsänderungen bestehen bleiben, wie Informationen, die Sie von einem Server holen oder etwas anderes auch Datei mit dem xml Ihre onCreate erneut Layout Android berechnet, dass ist schon bekommen haben kann in Activity oder da, während es für die Orientierung im Einsatz.

Siehe hier oder hier .

Es ist zu beachten, dass diese Methoden jetzt veraltet sind (obwohl noch flexibler als Orientierung Umgang mit sich selbst ändern, da die meisten der oben genannten Lösungen vorschlagen) mit der Empfehlung, dass jeder Fragments auf jeweils setRetainInstance(true) und stattdessen wechseln Fragment Sie behalten möchten .

Answer 8

Der Ansatz ist nützlich, aber unvollständig, wenn Fragmente verwendet wird.

Fragmente in der Regel auf Konfigurationsänderung neu erstellt bekommen. Wenn Sie dies nicht geschehen soll, verwenden Sie

setRetainInstance(true); im Fragmente Konstruktor (n)

Dies führt dazu, Fragmente während Konfigurationsänderung beibehalten werden.

http://developer.android.com/ Referenz / android / app / Fragment.html # setRetainInstance (boolean)

Answer 9

Ich habe gerade einfach hinzugefügt

     android:configChanges="keyboard|keyboardHidden|orientation"

in der Manifest-Datei und hinzufügen, nicht jede onConfigurationChanged Methode in meiner Tätigkeit.

Also jedes Mal, wenn die Tastatur gleitet oder in nichts passiert .

Answer 10

Die onCreate Methode noch einmal aufgerufen wird, wenn Sie die orientation von Android ändern. So bewegt die ganze schwere Funktionalität diese Methode wird nicht, Ihnen zu helfen

Answer 11

Es ist sehr einfach tun, nur die folgenden Schritte:

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

Dies funktioniert für mich:

Hinweis: Ausrichtung hängt von Ihrer requitement

Answer 12

Setzen Sie den Code unten in Ihrem <activity> Tag in Manifest.xml:

android:configChanges="screenLayout|screenSize|orientation"

Answer 13

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

Welcher Teil des Manifests sagt es „nicht nennen onCreate()“?

Auch Google docs sagen mit android:configChanges zu vermeiden (außer als letztes Mittel) .... Aber dann die alternativen Methoden, die sie vorschlagen, alle DO Verwendung android:configChanges.

Es ist meine Erfahrung, dass der Emulator IMMER onCreate() bei Rotation nennt.
Aber die 1-2-Geräte, die ich den gleichen Code laufen auf ... nicht. (Nicht sicher, warum es würde kein Unterschied.)

Answer 14

Fügen Sie diese Zeile zu manifestieren: -

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

und diese Schnipsel zur Aktivität: -

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

Answer 15

Änderungen im Android offenbar werden sollen:

android:configChanges="keyboardHidden|orientation" 

Die Zugänge innerhalb Aktivität gemacht werden sollen:

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();
    }
}

Answer 16

Es gibt mehrere Möglichkeiten, dies zu tun:

Speichern Aktivitätszustand

Sie können den Aktivitätszustand in onSaveInstanceState speichern.

@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);
}

und anschließend die bundle verwenden den Zustand wiederhergestellt werden.

@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
    }
}

Griff Orientierungsänderungen selbst

Eine weitere Alternative ist die Orientierungsänderungen selbst zu behandeln. Aber dies ist keine gute Praxis betrachtet.

Fügen Sie diese auf Ihre Manifest-Datei.

android:configChanges="keyboardHidden|orientation"

für Android 3.2 und höher:

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
    }
}

Beschränken Rotation

Sie können auch Ihre Aktivität auf Hoch- oder Querformat beschränken Rotation zu vermeiden.

Fügen Sie diese auf den Aktivitäts-Tag in Ihrer Manifest-Datei:

        android:screenOrientation="portrait"

oder implementieren diese programmatisch in Ihrer Tätigkeit:

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

Answer 17

Die Art und Weise habe ich gefunden, dies zu tun ist, um die onRestoreInstanceState zu nutzen und die onSaveInstanceState Ereignisse etwas in der Bundle zu speichern (auch wenn Sie alle Variablen brauchen nicht gespeichert, nur dort geben Sie etwas so die Bundle nicht leer ist). Dann wird auf der onCreate Methode überprüfen, um zu sehen, ob die Bundle leer ist, und wenn ja, dann die Initialisierung tun, wenn nicht, dann tut es.

Answer 18

Auch wenn es nicht „die Android way“ ist Ich habe Orientierung sehr gute Ergebnisse erhalten durch die Handhabung ändert sich selbst und einfach die Widgets Neupositionierung innerhalb Hinblick auf die veränderte Ausrichtung zu berücksichtigen. Dies ist schneller als jeder andere Ansatz, weil Ihre Ansichten müssen nicht gespeichert und wiederhergestellt. Es bietet auch eine nahtlose Erfahrung für den Benutzer, da die respositioned Widgets genau die gleichen Widgets sind, gerade bewegt und / oder die Größe verändert. Nicht nur Modellzustand, sondern auch Zustand anzeigen, kann auf diese Weise erhalten werden.

RelativeLayout kann manchmal eine gute Wahl für eine Ansicht, die sich von Zeit zu Zeit neu zu orientieren hat. Sie bieten nur eine Reihe von Porträt Layout params und eine Reihe von Landschafts Layout params, mit unterschiedlichen relativen Positionierung Regeln für die jeweils für jedes Kind-Widget. Dann in Ihrer onConfigurationChanged() Methode, übergeben Sie den entsprechend man zu einem setLayoutParams() Anruf auf jedem Kind. Wenn irgendein Steuer Kind selbst sein muss intern umorientiert, rufen Sie nur eine Methode für das Kind die Neuausrichtung durchzuführen. Das Kind in ähnlicher Weise ruft Methoden auf all sein Kind-Steuerelemente, die interne Neuausrichtung benötigen, und so weiter.

Answer 19

Jedes Mal, wenn der Bildschirm gedreht wird, geöffnet Aktivität beendet ist und onCreate () erneut aufgerufen.

1. Sie können eine Sache, die den Zustand der Aktivität speichern, wenn der Bildschirm gedreht wird, so dass können Sie alle alten Sachen erholen, wenn die Aktivität des onCreate () erneut aufgerufen wird.     Siehe dieser Link

2. Wenn Sie Neustarten der Aktivität verhindern wollen nur Platz Zeilen in Ihrer Datei manifest.xml folgen.

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

Answer 20

Hinweis: Ich poste diese Antwort, wenn jemand in der Zukunft das gleiche Problem wie mir gegenüber. Für mich war die folgende Zeile nicht genug:

android:configChanges="orientation"

Wenn ich den Bildschirm gedreht, wobei das Verfahren `onConfigurationChanged (Configuration newconfig) did't aufgerufen.

Lösung: Ich musste auch „Screen“ hinzufügen, auch wenn das Problem mit der Ausrichtung zu tun hatte. So in der AndroidManifest.xml - Datei, fügen Sie diese:

android:configChanges="keyboardHidden|orientation|screenSize"

Dann implementieren die Methode onConfigurationChanged(Configuration newConfig)

Answer 21

Sie die onSavedInstanceState Methode verwenden, müssen alle den Wert auf dessen Parameter zu speichern, hat das heißt Bündel

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

und verwenden

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

retrive und setzen Sie den Wert Objekte anzuzeigen es wird behandelt die Bildschirmdrehungen

Answer 22

In der Aktivität Abschnitt der manifest hinzufügen:

android:configChanges="keyboardHidden|orientation"

Answer 23

Fügen Sie diese Zeile in manifest: android:configChanges="orientation|screenSize"

Answer 24

Die Leute sagen, dass Sie verwenden sollten,

android:configChanges="keyboardHidden|orientation"

Aber die beste und professionellste Art Rotation in Android zu handhaben ist die Loader-Klasse zu verwenden. Es ist nicht eine berühmte Klasse (ich weiß nicht, warum), aber es ist viel besser als die AsyncTask. Für weitere Informationen können Sie die Android-Tutorials in Udacity Android Kurse gefunden lesen.

Natürlich, wie eine andere Art und Weise, können Sie die Werte speichern oder die Ansichten mit onSaveInstanceState und las sie mit onRestoreInstanceState. Es ist wirklich an Ihnen.

Answer 25

Nach einer gewissen Zeit von Versuch und Irrtum, fand ich eine Lösung, die meine Bedürfnisse in den meisten Situationen paßt. Hier ist der Code:

Manifest-Konfiguration:

<?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>

MainActivity:

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();
    }

}

Und Probe 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);
    }

}

Kann auf Github .

Answer 26

Verwenden orientation Zuhörer verschiedene Aufgaben auf unterschiedliche Orientierung auszuführen.

@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);
    }
}

Answer 27

Setzen Sie diesen Code unten in Ihrem Activity in Android Manifest.

android:configChanges="orientation"

Dies wird nicht Ihre Aktivität neu, wenn Sie Ausrichtung ändern würde.

Answer 28

Befestigen Sie die Bildschirmausrichtung (Hoch- oder Querformat) in AndroidManifest.xml

android:screenOrientation="portrait" oder android:screenOrientation="landscape"

für das Ihre onResume() Methode wird nicht aufgerufen.

Answer 29

Eines der besten Komponente von Android architechure von Google vorstellen wird Ihre ganze Anforderung erfüllen, das Ansichtsmodell ist.

Das ist so konzipiert, UI bezogenen Daten in Lifecycle Art und Weise zu speichern und zu verwalten und dass können Daten als Bildschirm dreht, um zu überleben

class MyViewModel : ViewModel() {

Bitte beachten Sie folgendes: https://developer.android.com/topic/libraries / Architektur / Ansichtsmodell

Answer 30

Sie können auf die aktuelle Ausrichtung des Bildschirms sperren diesen Code ...

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);
        }