it-swarm.com.de

Aktivitätsneustart bei Rotation Android

Wenn ich in meiner Android-Anwendung das Gerät drehe (die Tastatur herausschieben), wird meine Activity neu gestartet (onCreate wird aufgerufen). Nun, das ist wahrscheinlich so, wie es sein soll, aber ich muss viel in der onCreate-Methode einrichten, also brauche ich entweder:

  1. Setzen Sie alle anfänglichen Einstellungen in eine andere Funktion, damit bei der Gerätedrehung oder bei einem Gerät alles verloren geht
  2. Stellen Sie es so ein, dass onCreate nicht noch einmal aufgerufen wird und das Layout nur oder ändert
  3. Begrenzen Sie die App nur auf Hochformat, so dass onCreate nicht aufgerufen wird.
1279
Isaac Waller

Verwenden der Anwendungsklasse

Je nachdem, was Sie bei der Initialisierung tun, können Sie eine neue Klasse erstellen, die Application erweitert und Ihren Initialisierungscode in eine überschriebene onCreate-Methode innerhalb dieser Klasse verschieben.

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

Die Variable onCreate in der Anwendungsklasse wird nur aufgerufen, wenn die gesamte Anwendung erstellt wird. Die Aktivität wird bei Ausrichtung neu gestartet, oder die Sichtbarkeit der Tastatur wird nicht ausgelöst.

Es ist empfehlenswert, die Instanz dieser Klasse als Singleton und die Anwendungsvariablen, die Sie initialisieren, mithilfe von Getter und Setter verfügbar zu machen.

HINWEIS: Sie müssen den Namen Ihrer neuen Application-Klasse im Manifest angeben, damit sie registriert und verwendet werden kann.

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

Reagieren auf Konfigurationsänderungen _ ​​[UPDATE: Dies ist seit API 13 veraltet; siehe empfohlene Alternative ]

Als weitere Alternative können Sie Ihre Anwendung auf Ereignisse überwachen lassen, die zu einem Neustart führen würden, z. B. Änderungen der Ausrichtung und der Sichtbarkeit der Tastatur, und diese Ereignisse in Ihrer Aktivität behandeln.

Beginnen Sie mit dem Hinzufügen des Knotens Android:configChanges 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 Sie in der Activity die onConfigurationChanged-Methode, und rufen Sie setContentView auf, um zu erzwingen, dass das GUI-Layout in der neuen Ausrichtung erneut erstellt wird.

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

Update für Android 3.2 und höher:

Achtung: Ab Android 3.2 (API-Ebene 13) ändert sich die "Bildschirmgröße" ändert sich auch, wenn das Gerät zwischen Hoch- und Querformat wechselt. Wenn Sie bei der Entwicklung für API-Level 13 oder höher (wie durch die Attribute minSdkVersion und targetSdkVersion deklariert) Laufzeitneustarts aufgrund von Ausrichtungsänderungen verhindern möchten, müssen Sie den Wert "screenSize" zusätzlich zum Wert "orientation" angeben. Das heißt, Sie müssen Android:configChanges="orientation|screenSize" angeben. Wenn Ihre Anwendung jedoch auf API-Level 12 oder niedriger abzielt, behandelt Ihre Aktivität diese Konfigurationsänderung immer selbst (diese Konfigurationsänderung startet Ihre Aktivität nicht neu, auch wenn sie auf einem Android-Gerät der Version 3.2 oder höher ausgeführt wird).

180
Gorm

Anstatt zu versuchen, die onCreate()-Funktion nicht vollständig auszulösen, prüfen Sie vielleicht die BundlesavedInstanceState, die an das Ereignis übergeben wird, um festzustellen, ob es null ist oder nicht. 

Wenn ich zum Beispiel eine Logik habe, die ausgeführt werden sollte, wenn die Activity wirklich erstellt wurde, und nicht bei jeder Orientierungsänderung, dann führe ich diese Logik in der onCreate() nur aus, wenn die savedInstanceState null ist. 

Ansonsten möchte ich, dass das Layout für die Ausrichtung ordnungsgemäß neu gezeichnet wird.

public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_game_list);

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

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

116
nebulae

was ich getan habe...

im Manifest wurde dem Aktivitätsabschnitt Folgendes hinzugefügt:

Android:configChanges="keyboardHidden|orientation"

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

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

Android:configChanges

in Ihr Manifest und dann die Änderungen, die Sie bearbeiten möchten. Zur Orientierung würden Sie also Folgendes verwenden:

Android:configChanges="orientation"

und für das Öffnen oder Schließen der Tastatur würden Sie Folgendes verwenden:

Android:configChanges="keyboardHidden"

Wenn Sie mit beiden umgehen möchten, können Sie sie einfach mit dem Pipe-Befehl wie folgt trennen:

Android:configChanges="keyboardHidden|orientation"

Dadurch wird die onConfigurationChanged-Methode in der von Ihnen aufgerufenen Aktivität ausgelöst. Wenn Sie die Methode überschreiben, können Sie die neuen Werte übergeben.

Hoffe das hilft.

61
GregD

Ich habe gerade diese Überlieferung entdeckt:

Um die Aktivität durch eine Orientierungsänderung am Leben zu erhalten und sie durch onConfigurationChanged, die Dokumentation und das obige Codebeispiel zu handhaben, schlagen Sie dies in der Manifest-Datei vor:

Android:configChanges="keyboardHidden|orientation"

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

Die Bonus-Überlegung ist, dass das Weglassen von keyboardHidden logisch erscheinen mag, jedoch zu Fehlern im Emulator führt (mindestens für Android 2.1): Wenn nur orientation angegeben wird, ruft der Emulator sowohl OnCreate als auch onConfigurationChanged und nur OnCreate zu anderen Zeiten auf.

Ich habe den Fehler auf einem Gerät nicht gesehen, aber ich habe gehört, dass der Emulator für andere fehlgeschlagen ist. Es lohnt sich also zu dokumentieren.

40
Liudvikas Bukys

Sie können auch die Möglichkeit der Android-Plattform nutzen, Daten bei Orientierungsänderungen zu speichern: onRetainNonConfigurationInstance() und getLastNonConfigurationInstance().

Auf diese Weise können Sie Daten über Konfigurationsänderungen hinweg beibehalten, z. B. Informationen, die Sie möglicherweise von einem Serverabruf erhalten haben, oder etwas anderes, das in onCreate oder seitdem berechnet wurde. Außerdem kann Android jetzt Ihre Activity mithilfe der XML-Datei für die Ausrichtung neu anordnen in Benutzung.

hier oder hier .

Es sollte beachtet werden, dass diese Methoden jetzt veraltet sind (obwohl sie immer noch flexibler sind als das Ändern der Orientierung, wie in den meisten der oben genannten Lösungen vorgeschlagen wird). Es wird empfohlen, dass alle zu Fragments wechseln und stattdessen setRetainInstance(true) für jede Fragment verwenden, die Sie beibehalten möchten.

34
Jon O

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

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

setRetainInstance(true); in den Konstruktoren des Fragments

Dadurch werden Fragmente während der Konfigurationsänderung beibehalten.

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

29
Abdo

Ich habe einfach nur hinzugefügt 

     Android:configChanges="keyboard|keyboardHidden|orientation"

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

Also jedes Mal, wenn die Tastatur herausgleitet oder nichts passiert .

22
bass.t

Geben Sie den Code unten in Ihr <activity>-Tag in Manifest.xml ein:

Android:configChanges="screenLayout|screenSize|orientation"
15

Die onCreate-Methode wird auch dann aufgerufen, wenn Sie die orientation von Android ändern. Das Verschieben der umfangreichen Funktionalität auf diese Methode wird Ihnen also nicht helfen

15
ganesh krishnan

Es ist sehr einfach, einfach die folgenden Schritte auszuführen:

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

Das funktioniert für mich:

Hinweis: Orientierung hängt von Ihrer Anforderung ab

14
ManiTeja
 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, dass es nicht "onCreate()" heißt?

Außerdem sagen die Dokumente von Google, Android:configChanges zu vermeiden (außer als letzter Ausweg) .... Aber dann schlagen die alternativen Methoden alleDOuse Android:configChanges.

Ich habe die Erfahrung gemacht, dass der Emulator IMMER bei der Drehung onCreate() aufruft.
Aber die 1-2 Geräte, auf denen ich den gleichen Code ausführt, tun nicht . (Nicht sicher, warum es einen Unterschied geben würde.)

14
Carol

Fügen Sie diese Zeile Ihrem Manifest hinzu: - 

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

und dieser Ausschnitt aus der Aktivität: -

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

Folgende Änderungen müssen im Android-Manifest vorgenommen werden:

Android:configChanges="keyboardHidden|orientation" 

Ergänzungen, die in der Aktivität vorgenommen werden müssen, 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();
    }
}
13
sumit pandey

Dafür gibt es mehrere Möglichkeiten:

Aktivitätsstatus speichern

Sie können den Aktivitätsstatus 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 dann die bundle verwenden, 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
    }
}

Behandeln Sie die Orientierungsänderungen selbst

Eine andere Alternative besteht darin, die Orientierungsänderungen selbst zu behandeln. Dies ist jedoch keine gute Praxis.

Fügen Sie dies 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
    }
}

Drehung einschränken

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

Fügen Sie dies dem Activity-Tag in Ihrer Manifestdatei hinzu:

        Android:screenOrientation="portrait"

Oder implementieren Sie dies programmgesteuert in Ihrer Aktivität:

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

Obwohl es nicht "der Android-Weg" ist, habe ich sehr gute Ergebnisse erzielt, indem ich Orientierungsänderungen selbst handhabte und die Widgets einfach innerhalb einer Ansicht neu positionierte, um die geänderte Orientierung zu berücksichtigen. Dies ist schneller als jeder andere Ansatz, da Ihre Ansichten nicht gespeichert und wiederhergestellt werden müssen. Außerdem bietet es dem Benutzer ein nahtloseres Erlebnis, da die respektierten Widgets genau dieselben Widgets sind, die gerade verschoben und/oder ihre Größe geändert wurden. Auf diese Weise können nicht nur der Modellstatus, sondern auch der Ansichtsstatus beibehalten werden.

RelativeLayout kann manchmal eine gute Wahl für eine Ansicht sein, die sich von Zeit zu Zeit neu ausrichten muss. Sie stellen lediglich einen Satz von Hochformat-Layoutparametern und einen Satz von Landschafts-Layoutparametern mit jeweils unterschiedlichen relativen Positionierungsregeln für jedes untergeordnete Widget bereit. Dann übergeben Sie in Ihrer onConfigurationChanged()-Methode die entsprechende Methode an einen setLayoutParams()-Aufruf für jedes Kind. Wenn eine untergeordnete Steuerung selbst intern umorientiert werden muss, rufen Sie einfach eine Methode für dieses Kind auf, um die Neuausrichtung durchzuführen. Dieses Kind ruft auf ähnliche Weise Methoden für seine Kindsteuerelemente auf, die eine interne Neuorientierung benötigen, und so weiter.

10
Carl

Ich habe herausgefunden, dass ich dies mithilfe der Ereignisse onRestoreInstanceState und onSaveInstanceState in Bundle speichern kann (selbst wenn Sie keine Variablen benötigen, geben Sie einfach etwas ein, sodass Bundle nicht leer ist). Überprüfen Sie dann bei der onCreate-Methode, ob Bundle leer ist. Wenn dies der Fall ist, führen Sie die Initialisierung durch. Wenn nicht, dann tun Sie es.

10
Shaun

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

1 Sie können den Status der Aktivität speichern, wenn der Bildschirm gedreht wird, sodass Sie alle alten Daten wiederherstellen können, wenn onCreate () der Aktivität erneut aufgerufen wird. Siehe diesen Link

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

  <activity Android:name=".Youractivity"
  Android:configChanges="orientation|screenSize"/>
6
Mansuu....

sie müssen die onSavedInstanceState-Methode verwenden, um den gesamten Wert des Parameters 'has is that bündel' zu speichern 

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

zum Abrufen und Festlegen des Werts zum Anzeigen von Objektenit übernimmt die Bildschirmdrehungen 

6
koteswara D K

Hinweis: Ich poste diese Antwort, wenn jemand in der Zukunft das gleiche Problem wie ich hat. Für mich war die folgende Zeile nicht ausreichend:

Android:configChanges="orientation"

Beim Drehen des Bildschirms wurde die Methode onConfigurationChanged (Configuration newConfig) nicht aufgerufen.

Lösung: Ich musste auch "screenSize" hinzufügen, auch wenn das Problem mit der Orientierung zu tun hatte. Fügen Sie in der AndroidManifest.xml-Datei Folgendes hinzu:

Android:configChanges="keyboardHidden|orientation|screenSize"

Dann implementieren Sie die Methode onConfigurationChanged(Configuration newConfig) 

6
iHank

Fügen Sie im Aktivitätsabschnitt der manifest hinzu:

Android:configChanges="keyboardHidden|orientation"
5

Die Leute sagen, dass Sie verwenden sollten 

Android:configChanges="keyboardHidden|orientation"

Die beste und professionellste Art, mit der Rotation in Android umzugehen, ist die Verwendung der Loader-Klasse. Es ist keine berühmte Klasse (ich weiß nicht warum), aber es ist viel besser als die AsyncTask. Weitere Informationen finden Sie in den Android-Tutorials der Android-Kurse von Udacity. 

Natürlich können Sie die Werte oder Ansichten auch mit onSaveInstanceState speichern und mit onRestoreInstanceState lesen. Es liegt wirklich an dir. 

4
Theo

Füge diese Zeile im Manifest hinzu: Android:configChanges="orientation|screenSize"

4

Fügen Sie diesen Code in Ihre Activity in Android Manifest ein.

Android:configChanges="orientation"

Dadurch wird Ihre Aktivität nicht erneut gestartet, wenn Sie die Ausrichtung ändern würden.

3
Pratik Dasa

Verwenden Sie orientation Listener, um verschiedene Aufgaben mit unterschiedlicher Ausrichtung 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);
    }
}
3
Akshay Paliwal

Festlegen der Bildschirmausrichtung (Querformat oder Hochformat) in AndroidManifest.xml

Android:screenOrientation="portrait" oder Android:screenOrientation="landscape"

ihre onResume()-Methode wird dazu nicht aufgerufen.

3

Nach einigem Ausprobieren 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 Beispielfragment:

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 gefunden werden.

3
Martin Pfeffer

Eine der besten Komponenten der Android-Architektur, die von Google eingeführt wird, erfüllt alle Ihre Anforderungen, die ViewModel darstellt.

Dies dient zum Speichern und Verwalten von UI-bezogenen Daten im Lebenszyklus sowie zum Überleben der Daten, wenn sich der Bildschirm dreht

class MyViewModel : ViewModel() {

Bitte beachten Sie diese: https://developer.Android.com/topic/libraries/architecture/viewmodel

1
Android Geek

Mit diesem Code können Sie die aktuelle Ausrichtung des Bildschirms festlegen ...

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

Sie können das ViewModel-Objekt in Ihrer Aktivität verwenden.

ViewModel-Objekte werden bei Konfigurationsänderungen automatisch beibehalten, sodass die darin enthaltenen Daten sofort für die nächste Aktivitäts- oder Fragmentinstanz verfügbar sind.

https://developer.Android.com/topic/libraries/architecture/viewmodel

0
Gregory Buiko