Aktivität Neustart auf Rotation Android

In meiner Android-Anwendung, wenn ich das Gerät onCreate ( onCreate die Tastatur), dann wird meine Activity neu gestartet ( onCreate wird aufgerufen). Nun, das ist wahrscheinlich, wie es sein soll, aber ich mache viel anfängliches onCreate in der onCreate Methode, also brauche ich entweder:

  1. Setzen Sie alle anfänglichen Einrichten in eine andere Funktion, so dass es nicht alle verloren auf Gerät Rotation oder
  2. Machen Sie es so onCreate wird nicht wieder aufgerufen und das Layout passt sich einfach an oder
  3. onCreate die App auf nur Porträt, so dass onCreate nicht aufgerufen wird.

  • Neustart der Android-Anwendung nach dem Prozess wird getötet
  • Card Flip Animation zwischen Aktivitäten
  • Was ist die Vorzugsaktivität in Android?
  • Android Studio kann das Symbol nicht beheben, aber der Code wird ordnungsgemäß ausgeführt
  • OnCreate nicht angerufen
  • Senden von Aktivitäten auf den Hintergrund ohne Abschluss
  • Wie man Aktivität schließt und zur vorherigen Tätigkeit in android zurückkehrt
  • Dilemma: wann man Fragments vs nutzt Aktivitäten:
  • Wie kann ich feststellen, ob Android App im Vordergrund läuft?
  • Card Flip Animation zwischen Aktivitäten
  • Die Übergangsanimation kann nicht deaktiviert werden, wenn die Schaltfläche "Zurück" geklickt wird
  • Wie startet man Android Apps in meiner Anwendung in Android?
  • 27 Solutions collect form web for “Aktivität Neustart auf Rotation Android”

    Verwenden der Anwendungsklasse

    Je nachdem, was du in deiner Initialisierung machst, kannst du erwägen, eine neue Klasse zu erstellen, die die Application und deinen Initialisierungscode in eine überschriebene onCreate Methode innerhalb dieser Klasse verschiebt.

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

    Das onCreate in der Anwendungsklasse wird nur dann aufgerufen, wenn die gesamte Applikation erstellt wird, so dass die Aktivität bei Orientierungs- oder Tastatur-Sichtveränderungen neu onCreate wird.

    Es ist eine gute Praxis, die Instanz dieser Klasse als Singleton auszusetzen und die Anwendungsvariablen, die du mit Getter und Setter initialisierst, auszusetzen.

    HINWEIS: Sie müssen den Namen Ihrer neuen Anwendungsklasse im Manifest angeben, damit sie registriert und verwendet werden können:

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

    Reagieren auf Konfigurationsänderungen [UPDATE: das ist seit API 13 veraltet; Siehe die empfohlene Alternative ]

    Als weitere Alternative können Sie Ihre Anwendung auf Ereignisse hören, die eine Neustart – wie Orientierung und Tastatur Sichtbarkeit Änderungen verursachen würden – und behandeln sie in Ihrer Aktivität.

    Beginnen Sie mit dem Hinzufügen des android:configChanges Knotens zum Manifest-Knoten Ihrer Aktivität

     android:configChanges="keyboardHidden|orientation" 

    Oder für Android 3.2 (API Level 13) und neuer :

     android:configChanges="keyboardHidden|orientation|screenSize" 

    Dann überschreiben onConfigurationChanged innerhalb der Aktivität die Methode onConfigurationChanged und rufen setContentView auf, um das GUI-Layout in der neuen Ausrichtung setContentView zu erzwingen.

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

    Update für Android 3.2 und höher:

    Achtung : Beginnend mit Android 3.2 (API Level 13) ändert sich auch die "Bildschirmgröße", wenn das Gerät zwischen Hoch- und Querformat umschaltet. Wenn Sie also die Laufzeit-Neustarts aufgrund der Orientierungsänderung bei der Entwicklung für API Level 13 oder höher verhindern möchten (wie von den Attributen minSdkVersion und targetSdkVersion deklariert), müssen Sie zusätzlich zum "orientation" -Wert den "screenSize" -Wert "screenSize" . Das heißt, du musst android:configChanges="orientation|screenSize" erklären android:configChanges="orientation|screenSize" . Allerdings, wenn Ihre Anwendung zielt API Level 12 oder niedriger, dann Ihre Aktivität behandelt immer diese Konfiguration ändern sich selbst (diese Konfiguration ändern startet nicht Ihre Aktivität, auch wenn auf einem Android 3.2 oder höher Gerät).

    Anstatt zu versuchen, die onCreate() aus dem Abfeuern zu stoppen, vielleicht versuchen Sie, das Bundle savedInstanceState , das savedInstanceState ist. savedInstanceState wird in das Ereignis übergeben, um zu sehen, ob es null ist oder nicht.

    Zum Beispiel, wenn ich eine Logik habe, die ausgeführt werden sollte, wenn die Activity wirklich erstellt wird, nicht bei jeder Orientierungsänderung, laufe ich nur diese Logik im onCreate() nur, wenn die savedInstanceState null ist.

    Ansonsten möchte ich noch das Layout für die Orientierung richtig neu 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.

    Was ich getan habe…

    In der manifest, um die Tätigkeit Abschnitt, fügte hinzu:

     android:configChanges="keyboardHidden|orientation" 

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

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

     android:configChanges 

    Zu deinem Manifest und dann die Änderungen, die du behandeln möchtest. Also für die Orientierung, würden Sie verwenden:

     android:configChanges="orientation" 

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

     android:configChanges="keyboardHidden" 

    Wenn du beide behandeln möchtest, kannst du sie einfach mit dem Pipe-Befehl trennen wie:

     android:configChanges="keyboardHidden|orientation" 

    Dies wird die Methode onConfigurationChanged in der von Ihnen aufgerufenen Aktivität auslösen. Wenn Sie die Methode überschreiben, können Sie die neuen Werte übergeben.

    Hoffe das hilft.

    Ich habe gerade diese Überlieferung entdeckt:

    Um die Aktivität durch eine Orientierungsänderung lebendig zu halten und sie durch onConfigurationChanged , onConfigurationChanged die Dokumentation und der Codebeispiel oben in der Manifest-Datei vor:

     android:configChanges="keyboardHidden|orientation" 

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

    Die Bonus-Lore ist, dass das Auslassen der keyboardHidden kann logisch erscheinen, aber es verursacht Fehler im Emulator (für Android 2.1 mindestens): Spezifizieren nur orientation wird der Emulator rufen sowohl OnCreate und onConfigurationChanged manchmal und nur OnCreate andere Zeiten.

    Ich habe das Versagen auf einem Gerät nicht gesehen, aber ich habe gehört, dass der Emulator für andere versagt. Also lohnt es sich zu dokumentieren.

    Sie könnten auch die Verwendung der Android-Plattform für die persistente Daten über die Orientierungsänderungen in onRetainNonConfigurationInstance() : onRetainNonConfigurationInstance() und getLastNonConfigurationInstance() .

    Dies ermöglicht es Ihnen, Daten über Konfigurationsänderungen zu bestehen, z. B. Informationen, die Sie von einem Server onCreate haben können oder etwas anderes, das in onCreate oder seither berechnet wurde, während es auch ermöglicht, dass Android Ihre Activity mit der XML-Datei für die Ausrichtung jetzt neu onCreate in Benutzung.

    Sehen Sie hier oder hier .

    Es ist anzumerken, dass diese Methoden jetzt veraltet sind (obwohl noch flexibler als die Handhabungsorientierung sich selbst ändern, wie die meisten der oben genannten Lösungen vorschlagen) mit der Empfehlung, dass jeder auf Fragments umschaltet und stattdessen setRetainInstance(true) auf jedem Fragment Sie behalten möchten .

    Der Ansatz ist nützlich, ist aber bei der Verwendung von Fragmenten unvollständig.

    Fragmente werden bei der Konfigurationsänderung normalerweise neu erstellt. Wenn Sie dies nicht wünschen, verwenden Sie es

    setRetainInstance(true); Im Fragment-Konstruktor (s)

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

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

    Ich habe einfach nur hinzugefügt

      android:configChanges="keyboard|keyboardHidden|orientation" 

    In der Manifest-Datei und fügte keine onConfigurationChanged Methode in meiner Aktivität hinzu.

    Also jedes Mal, wenn die Tastatur ausläuft oder in nichts passiert .

      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: "ruf nicht auf onCreate() ")?

    Auch die Google Docs sagen, um zu vermeiden, android:configChanges (außer als letztes Resort) …. Aber dann die alternativen Methoden, die sie vorschlagen, alle DO verwenden android:configChanges .

    Es ist meine Erfahrung gewesen, dass der Emulator onCreate() nach der Drehung anruft.
    Aber die 1-2 Geräte, die ich laufe den gleichen Code auf … nicht. (Nicht sicher, warum es keinen Unterschied geben würde.)

    Änderungen im Android-Manifest sind:

     android:configChanges="keyboardHidden|orientation" 

    Ergänzungen innerhalb der Aktivität sind:

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

    Füge diese Zeile deinem Manifest hinzu: –

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

    Und dieses Snippet zur Aktivität: –

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

    Die Art, wie ich das gefunden habe, ist die Verwendung von onRestoreInstanceState und den onSaveInstanceState Ereignissen, um etwas im Bundle zu speichern (auch wenn du keine Variablen benötigt hast, einfach etwas da onSaveInstanceState , damit das Bundle nicht leer ist). Dann, auf der onCreate Methode, überprüfen Sie, ob das Bundle leer ist, und wenn es ist, dann tun Sie die Initialisierung, wenn nicht, dann tun Sie es.

    Die onCreate Methode wird immer noch aufgerufen, auch wenn du die orientation von Android veränderst. So bewegt alle schweren Funktionalität auf diese Methode wird Ihnen nicht helfen

    Auch wenn es nicht "der Android-Weg" ist, habe ich sehr gute Ergebnisse bekommen, indem ich die Orientierungsänderungen selbst ändere und einfach die Widgets in einer Ansicht neu positioniere, um die veränderte Orientierung zu berücksichtigen. Das ist schneller als jeder andere Ansatz, denn deine Ansichten müssen nicht gespeichert und wiederhergestellt werden. Es bietet auch eine mehr nahtlose Erfahrung für den Benutzer, weil die respositionierten Widgets sind genau die gleichen Widgets, nur bewegt und / oder verkleinert. Nicht nur Modellzustand, sondern auch Sichtzustand kann auf diese Weise bewahrt werden.

    RelativeLayout kann manchmal eine gute Wahl für eine Ansicht sein, die sich von Zeit zu Zeit neu orientieren muss. Sie bieten einfach einen Satz von Portrait-Layout-Params und eine Reihe von Landschafts-Layout-Params, mit verschiedenen relativen Positionsregeln für jeden, für jedes Kind Widget. Dann, in Ihrer onConfigurationChanged() -Methode, übergeben Sie die entsprechende an einen setLayoutParams() Aufruf bei jedem Kind. Wenn irgendeine Kinderkontrolle selbst intern neu ausgerichtet werden muss, rufst du einfach eine Methode auf dieses Kind, um die Neuorientierung durchzuführen. Dieses Kind ruft ähnlich Methoden auf irgendwelche seiner Kinderkontrollen, die eine interne Neuorientierung benötigen, und so weiter.

    Es ist ganz einfach, einfach die folgenden Schritte durchzuführen:

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

    Das funktioniert für mich:

    Hinweis: Die Orientierung hängt von Ihrer Anforderung ab

    Es gibt mehrere Möglichkeiten, dies zu tun:

    Aktivitätsstatus speichern

    Sie können den Aktivitätsstatus in 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); } 

    Und dann das bundle , um den Zustand wiederherzustellen.

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

    Behandle die Orientierungsänderungen selbst

    Eine weitere Alternative ist es, die Orientierungsänderungen selbst zu bewältigen. Aber das gilt nicht als gute Praxis.

    Fügen Sie diese zu Ihrer Manifestdatei hinzu.

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

    Rotation einschränken

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

    Fügen Sie dies dem Aktivitäts-Tag in Ihrer Manifest-Datei hinzu:

      android:screenOrientation="portrait" 

    Oder implementiere dies programmatisch in deiner Tätigkeit:

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

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

    Android: configChanges = "screenLayout | screenSize | Orientierung"

    Anmerkung: Ich sende diese Antwort, wenn jemand in der Zukunft das gleiche Problem wie ich aussieht. Für mich war die folgende Zeile nicht enought:

     android:configChanges="orientation" 

    Als ich den Bildschirm gedreht habe, wurde die Methode `onConfigurationChanged (Konfiguration newConfig) nicht aufgerufen.

    Lösung: Ich musste auch "screenSize" hinzufügen, auch wenn das Problem mit der Orientierung zu tun hatte. Also in der AndroidManifest.xml – Datei füge dies hinzu:

     android:configChanges="keyboardHidden|orientation|screenSize" 

    Dann implementiere die Methode onConfigurationChanged(Configuration newConfig)

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

    1 Sie können eine Sache tun, um den Zustand der Aktivität zu speichern, wenn der Bildschirm gedreht wird, so dass Sie alle alten Sachen wiederherstellen können, wenn die Aktivität onCreate () wieder aufgerufen wird. Verweisen Sie diesen Link

    2 Wenn Sie den Neustart der Aktivität verhindern möchten, legen Sie einfach folgende Zeilen in die Datei manifest.xml ein.

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

    Fixieren Sie die Bildschirmausrichtung (Landschaft oder Porträt) in AndroidManifest.xml

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

    Dafür wird deine onResume() Methode nicht aufgerufen.

    Sie müssen die onSavedInstanceState-Methode verwenden, um den gesamten Wert auf seinen Parameter zu speichern, ist das 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"); } 

    Um zu retten und den Wert einzustellen, um Objekte anzuzeigen, wird er die Bildschirmdrehungen behandeln

    In der Aktivität Abschnitt des manifest , fügen Sie hinzu:

     android:configChanges="keyboardHidden|orientation" 

    Nach einer Weile von Versuch und Irrtum fand ich eine Lösung, die in den meisten Situationen zu meinen Bedürfnissen passt. 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> 

    Hauptaktivität:

     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 bei github gefunden werden

    Verwenden Sie den orientation Listener, um verschiedene Aufgaben in unterschiedlicher Ausrichtung durchzufü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); } } 

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

     android:configChanges="orientation" 

    Dies wird Ihre Aktivität nicht neu starten, wenn Sie die Orientierung ändern würden.

    Sie können die aktuelle Ausrichtung des Bildschirms mit diesem Code sperren …

     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); } 
    Das Android ist ein Google Android Fan-Website, Alles ├╝ber Android Phones, Android Wear, Android Dev und Android Spiele Apps und so weiter.