Reinicio de la actividad en la rotación de Android

En mi aplicación de Android, cuando giro el dispositivo (deslizo hacia afuera el teclado), entonces mi Activity se reiniciaonCreate se llama). Ahora, probablemente así es como se supone que debe ser, pero realizo una gran cantidad de configuración inicial en el onCreate método, así que necesito:

  1. Ponga toda la configuración inicial en otra función para que no se pierda todo en la rotación del dispositivo o
  2. Hazlo tan onCreate no se vuelve a llamar y el diseño simplemente se ajusta o
  3. Limite la aplicación a solo retrato para que onCreate no se llama.

preguntado el 18 de enero de 09 a las 22:01

Hay una explicación bastante completa sobre cómo retener las tareas asincrónicas de larga ejecución durante los cambios de configuración de la actividad en esta entrada del blog ¡también! -

Esta no es una respuesta directa como ya han respondido otros, pero te invito a que le eches un vistazo. LogLifeCycle para comprender qué sucede en sus aplicaciones de Android con respecto a los ciclos de vida. -

30 Respuestas

Usando la clase de aplicación

Dependiendo de lo que esté haciendo en su inicialización, podría considerar crear una nueva clase que se extienda Application y mover su código de inicialización a un anulado onCreate método dentro de esa clase.

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

La onCreate en la clase de aplicación solo se llama cuando se crea la aplicación completa, por lo que la actividad se reinicia en la orientación o los cambios de visibilidad del teclado no la activarán.

Es una buena práctica exponer la instancia de esta clase como un singleton y exponer las variables de la aplicación que está inicializando usando getters y setters.

NOTA: Deberá especificar el nombre de su nueva clase de aplicación en el manifiesto para que se registre y utilice:

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

Reacción a los cambios de configuración [ACTUALIZACIÓN: esto está obsoleto desde API 13; ver la alternativa recomendada]

Como alternativa adicional, puede hacer que su aplicación escuche eventos que causarían un reinicio, como cambios de orientación y visibilidad del teclado, y manejarlos dentro de su Actividad.

Comience agregando el android:configChanges nodo al nodo de manifiesto de su actividad

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

o para Android 3.2 (API nivel 13) y más reciente:

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

Luego, dentro de la Actividad, anule el onConfigurationChanged método y llamada setContentView para forzar que el diseño de la GUI se vuelva a hacer en la nueva orientación.

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

Respondido 26 Abr '19, 07:04

No creo que el segundo enfoque funcione. Lo intenté; una actividad con un EditText. Escribí algo de texto allí, cambié la orientación y el texto desapareció / reinicié. - Ted

Esperamos ver un método onRotate () en el futuro. Tener que preocuparse incluso por cosas como esta es, francamente, frustrante. - kelly sutton

Tenga en cuenta que la Guía para desarrolladores de Android advierte contra el uso de esto: Nota: Usando (android:configChanges) debe evitarse y utilizarse solo como último recurso. Lea Manejo de cambios en tiempo de ejecución para obtener más información sobre cómo manejar correctamente un reinicio debido a un cambio de configuración. En lugar de ello, para conservar los datos en los eventos de rotación, parece que prefieren utilizar la onSaveInstanceState Bundle; o como @ Jon-O menciona, onRetainNonConfigurationInstance. - jeffro

Esa es una mala solución, porque solo reacciona a actualmente conocido cambios de configuración. Con las versiones más recientes de Android, pueden ocurrir otros cambios de configuración que este código no captará (porque debe enumerar todos los cambios de configuración en el manifiesto). La solución de salvar al estado con onRetainNonConfigurationChanges es más tolerante a fallas y sencillo. - Bananeweizen

Creo que deberías agregar esta actualización en 3.2 a su respuesta, es bastante importante (acaba de enfrentar ese problema) y podría pasarlo por alto. - piedras grandes

Actualización para Android 3.2 y superior:

Precaución: A partir de Android 3.2 (nivel de API 13), el "tamaño de la pantalla" también cambia cuando el dispositivo cambia entre orientación vertical y horizontal. Por lo tanto, si desea evitar que el tiempo de ejecución se reinicie debido a un cambio de orientación al desarrollar para el nivel de API 13 o superior (como lo declaran los atributos minSdkVersion y targetSdkVersion), debe incluir el "screenSize" valor además del "orientation" valor. Es decir, debes declarar android:configChanges="orientation|screenSize". Sin embargo, si su aplicación apunta al nivel de API 12 o inferior, entonces su actividad siempre maneja este cambio de configuración por sí misma (este cambio de configuración no reinicia su actividad, incluso cuando se ejecuta en un dispositivo Android 3.2 o superior).

respondido 03 mar '12, 21:03

Gracias por esa aclaración, ya que un comentario anterior sobre esto casi me envía a investigarlo. Actualmente estoy apuntando a API 8 y mi código no tiene screenSize en configChanges y puedo confirmar que funciona bien (sin reorientar) en el dispositivo que tengo que está ejecutando ICS. - Carl

Gracias por señalar esto, solo tenía configurado android: configChanges = "Orientación | Tamaño de pantalla", y el cambio de orientación estaba recreando mi Actividad, ¡y por mi vida no podía entender por qué! - cristobal perry

Añadiendo android: configChanges solo debe usarse como último recurso. Considere usar Fragments y setRetainInstance en lugar de. - Simón Forsberg

El punto clave es screenSize para Android 3.2 y superior, eso resolvió mi problema, ¡Gracias! - toque de fan

En lugar de intentar detener el onCreate() de ser despedido por completo, tal vez intente verificar el Bundle savedInstanceState pasando al evento para ver si es nulo o no.

Por ejemplo, si tengo alguna lógica que deba ejecutarse cuando el Activity es realmente creado, no en cada cambio de orientación, solo ejecuto esa lógica en el onCreate() solo si el savedInstanceState es nulo.

De lo contrario, todavía quiero que el diseño se vuelva a dibujar correctamente para la orientación.

public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_game_list);

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

No estoy seguro de si esta es la respuesta definitiva, pero me funciona.

Respondido el 23 de junio de 15 a las 03:06

¿Y dónde estás realmente ahorrando el estado? - Ewoks

esto parece funcionar para mí y parece, con mucho, el método más simple. Me di cuenta de que solo tiene 4 ups para esto (5 incluido el mío) frente a 373 para la idea de subclasificar la aplicación, que me parece mucho más complicada. ¿Hay alguna desventaja de este método? - steveh

Esta solución funcionó muy bien para mí. fui capaz de Intent serverintent = new Intent(MainActivity.this, MessageListener.class); y startService(serverintent); para crear un serverSocket = new ServerSocket(0xcff2); y Socket client = serverSocket.accept(); con un BufferedReader(new InputStreamReader(client.getInputStream())); y podría rotar mi Android y mantener activa la conexión cliente / servidor, pero hacer que la GUI rote. Según el manual, SavedInstanceState se inicializa cuando se cierra la última actividad. - Fred F.

No entiendo, ¿cuál es el truco? Esto funciona muy bien y con mucha menos complejidad que cualquiera de las otras soluciones. - RTF

Esta es la forma correcta de hacerlo en Android. Las otras formas de capturar básicamente una rotación con configChanges y todo eso son voluminosas, complejas e innecesarias. - lucaswaggoner

lo que hice...

en el manifiesto, a la sección de actividad, se agregó:

android:configChanges="keyboardHidden|orientation"

en el código de la actividad, implementado:

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

Respondido el 04 de enero de 11 a las 01:01

para aclarar: con mi implementación, ahora puede tener la inicialización de variables en onCreate () y onConfigurationChanged () simplemente se llamará para la rotación de la pantalla. Sus variables ahora están aisladas de las rotaciones de pantalla ;-) nice y ez - Alguien en alguna parte

Hice todo tal como se describe aquí, pero obtengo NullPointerException cuando intento presionar un botón después del cambio de orientación. ¿Qué podría estar mal? - finnboy11

tenga en cuenta que mi respuesta es como 3 años y Android sigue evolucionando ... Simon, ¿tienes un enlace al código de muestra? Eso es lo que necesita la gente. - Alguien en alguna parte

Al advertir contra android: configChanges, @ SimonAndréForsberg en realidad solo está parafraseando el Documentos de Android. Manejo de cambios en tiempo de ejecución tiene información más detallada sobre las alternativas (incluido el código de muestra). - Leif Arne Storset

Lo que describe es el comportamiento predeterminado. Debe detectar y manejar estos eventos usted mismo agregando:

android:configChanges

a su manifiesto y luego los cambios que desea manejar. Entonces, para orientación, usaría:

android:configChanges="orientation"

y para que el teclado se abra o cierre, usaría:

android:configChanges="keyboardHidden"

Si desea manejar ambos, puede separarlos con el comando de tubería como:

android:configChanges="keyboardHidden|orientation"

Esto activará el método onConfigurationChanged en cualquier actividad que llame. Si anula el método, puede pasar los nuevos valores.

Espero que esto ayude.

Respondido el 19 de enero de 09 a las 02:01

@GregD Lo sé, por eso ahora es un buen momento para actualizarlo para reflejar la situación actual. Dado el número de votos a favor que tiene esta pregunta, todavía se hace referencia a ella desde otras preguntas sobre SO. - Simón Forsberg

Acabo de descubrir esta tradición:

Para mantener viva la Actividad a través de un cambio de orientación y manejarla a través de onConfigurationChanged, la documentación y el ejemplo de código anterior sugiera esto en el archivo de manifiesto:

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

que tiene el beneficio adicional de que siempre funciona.

La tradición extra es que omitir el keyboardHidden puede parecer lógico, pero provoca fallas en el emulador (al menos para Android 2.1): especificando solo orientation hará que el emulador llame a ambos OnCreate y onConfigurationChanged a veces, y solo OnCreate otros tiempos.

No he visto la falla en un dispositivo, pero he escuchado que el emulador falla en otros. Por eso vale la pena documentarlo.

contestado el 30 de mayo de 19 a las 21:05

Precaución: A partir de Android 3.2 (nivel de API 13), el "tamaño de la pantalla" también cambia cuando el dispositivo cambia entre la orientación vertical y horizontal. Por lo tanto, si desea evitar que el tiempo de ejecución se reinicie debido a un cambio de orientación al desarrollar para el nivel de API 13 o superior: android: configChanges = "orientación | keyboardHidden | screenSize" - Geltrude

También puede considerar usar la forma de la plataforma Android de conservar los datos en los cambios de orientación: onRetainNonConfigurationInstance() y getLastNonConfigurationInstance().

Esto le permite conservar los datos a través de los cambios de configuración, como la información que puede haber obtenido de una búsqueda del servidor o algo más que se haya calculado en onCreate o desde entonces, al mismo tiempo que permite que Android rediseñe su Activity usando el archivo xml para la orientación ahora en uso.

Vea aquí or aquí.

Cabe señalar que estos métodos ahora están en desuso (aunque aún son más flexibles que manejar el cambio de orientación usted mismo, como sugieren la mayoría de las soluciones anteriores) con la recomendación de que todos se cambien a Fragments y en su lugar usa setRetainInstance(true) en cada Fragment desea retener.

Respondido 10 ago 12, 21:08

Realmente creo que Fragments y setRetainInstance es la mejor manera (y la forma recomendada por Google) de hacer esto, +1 para ti y -1 para todos los demás. Añadiendo android: configChanges solo debe usarse como último recurso - Simón Forsberg

El enfoque es útil pero está incompleto cuando se utilizan Fragmentos.

Los fragmentos generalmente se vuelven a crear al cambiar la configuración. Si no desea que esto suceda, use

setRetainInstance(true); en el (los) constructor (es) del Fragmento

Esto hará que los fragmentos se retengan durante el cambio de configuración.

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

Respondido el 27 de Septiembre de 12 a las 08:09

Acordado. Con la última API de Android, parece que los fragmentos son la forma correcta de manejar esto. Todavía no lo he probado yo mismo, pero por lo que he recopilado leyendo esta página, básicamente mueves el 99% de lo que solías implementar en una Actividad a una subclase de un Fragmento, luego agregas ese Fragmento a la Actividad. La actividad seguirá siendo destruida y recreada en la rotación de la pantalla, pero puedes decirle específicamente a Android no para destruir el Fragmento usando el setRetainInstance() método que mencionó @Abdo. - Brianmearns

Simplemente agregué

     android:configChanges="keyboard|keyboardHidden|orientation"

en el archivo de manifiesto y no agregó cualquier onConfigurationChanged método en mi actividad.

Entonces, cada vez que el teclado se desliza hacia afuera o hacia adentro, no pasa nada.

Respondido el 19 de diciembre de 12 a las 10:12

La onCreate todavía se llama al método incluso cuando cambia el orientation de android. Así que mover toda la funcionalidad pesada a este método no te ayudará

Respondido el 27 de Septiembre de 16 a las 10:09

Ponga el código a continuación dentro de su <activity> etiqueta en Manifest.xml:

android:configChanges="screenLayout|screenSize|orientation"

Respondido el 10 de enero de 18 a las 05:01

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

¿Qué parte del manifiesto dice "no llamar onCreate()"?

Además, los documentos de Google dicen que evite usar android:configChanges (excepto como último recurso) .... Pero luego los métodos alternativos que sugieren todos DO utilizado android:configChanges.

Ha sido mi experiencia que el emulador SIEMPRE llama onCreate() en rotación.
Pero los 1-2 dispositivos en los que ejecuto el mismo código ... no. (No estoy seguro de por qué habría alguna diferencia).

Respondido 10 Jul 14, 11:07

Es muy simple, solo siga los siguientes pasos:

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

Esto funciona para mi:

Nota: la orientación depende de su retribución

respondido 31 mar '17, 16:03

Los cambios que se realizarán en el manifiesto de Android son:

android:configChanges="keyboardHidden|orientation" 

Las adiciones a realizar dentro de la actividad son:

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

Respondido 07 Feb 14, 07:02

Agregue esta línea a su manifiesto: -

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

y este fragmento de la actividad: -

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

Respondido 14 ago 14, 05:08

Hay varias maneras de hacer esto:

Guardar estado de actividad

Puede guardar el estado de la actividad en 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);
}

y luego usar el bundle para restaurar el estado.

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

Maneje los cambios de orientación usted mismo

Otra alternativa es manejar los cambios de orientación por su cuenta. Pero esto no se considera una buena práctica.

Agregue esto a su archivo de manifiesto.

android:configChanges="keyboardHidden|orientation"

para Android 3.2 y posterior:

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

Restringir la rotación

También puede limitar su actividad al modo vertical u horizontal para evitar la rotación.

Agregue esto a la etiqueta de actividad en su archivo de manifiesto:

        android:screenOrientation="portrait"

O impleméntelo programáticamente en su actividad:

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

Respondido 03 ago 16, 15:08

La forma que he encontrado para hacer esto es usar el onRestoreInstanceState y onSaveInstanceState eventos para guardar algo en el Bundle (incluso si no necesita guardar ninguna variable, simplemente coloque algo allí para que Bundle no está vacío). Entonces, en el onCreate método, compruebe si el Bundle está vacío, y si lo está, haga la inicialización, si no, hágalo.

Respondido 20 Abr '15, 16:04

Aunque no es "la forma de Android", he obtenido muy buenos resultados manejando los cambios de orientación yo mismo y simplemente reposicionando los widgets dentro de una vista para tener en cuenta la orientación alterada. Esto es más rápido que cualquier otro enfoque, porque sus vistas no tienen que guardarse ni restaurarse. También proporciona una experiencia más fluida para el usuario, porque los widgets reposicionados son exactamente los mismos widgets, recién movidos y / o redimensionados. No solo el estado del modelo, sino también el estado de la vista, se pueden conservar de esta manera.

RelativeLayout a veces puede ser una buena opción para una vista que tiene que reorientarse de vez en cuando. Simplemente proporcione un conjunto de parámetros de diseño vertical y un conjunto de parámetros de diseño ajardinado, con diferentes reglas de posicionamiento relativo en cada uno, para cada widget secundario. Entonces, en tu onConfigurationChanged() método, pasa el apropiado a un setLayoutParams() llame a cada niño. Si algún niño debe controlarse a sí mismo internamente reorientado, simplemente invoca un método en ese niño para realizar la reorientación. Ese niño también llama a métodos en cualquiera de su controles secundarios que necesitan reorientación interna, etc.

Respondido el 31 de diciembre de 16 a las 02:12

Me encantaría ver un código de muestra de esto, ¡parece genial! - Enrique de Sousa

Cada vez que se gira la pantalla, la actividad abierta finaliza y se llama de nuevo a onCreate ().

1. Puede hacer una cosa para guardar el estado de actividad cuando se gira la pantalla para que pueda recuperar todas las cosas antiguas cuando se vuelva a llamar a la actividad onCreate (). Referir este aquí

2. Si desea evitar el reinicio de la actividad, simplemente coloque las siguientes líneas en su archivo manifest.xml.

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

contestado el 23 de mayo de 17 a las 13:05

necesita usar el método onSavedInstanceState para almacenar todo el valor en su parámetro tiene que es paquete

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

y use

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

para recuperar y establecer el valor para ver los objetos, manejará las rotaciones de la pantalla

Respondido el 07 de diciembre de 16 a las 10:12

Nota: Publico esta respuesta si alguien en el futuro enfrenta el mismo problema que yo. Para mí, la siguiente línea no fue suficiente:

android:configChanges="orientation"

Cuando giré la pantalla, no se llamó al método `onConfigurationChanged (Configuration newConfig).

Solución: También tuve que agregar "screenSize" incluso si el problema tenía que ver con la orientación. Entonces, en el archivo AndroidManifest.xml, agregue esto:

android:configChanges="keyboardHidden|orientation|screenSize"

Luego implementa el método onConfigurationChanged(Configuration newConfig)

Respondido 24 Abr '14, 15:04

En la sección de actividades del manifest, agregue:

android:configChanges="keyboardHidden|orientation"

respondido 31 mar '17, 21:03

Agregue esta línea en el manifiesto: android:configChanges="orientation|screenSize"

respondido 27 nov., 18:10

La gente dice que debes usar

android:configChanges="keyboardHidden|orientation"

Pero la mejor y más profesional forma de manejar la rotación en Android es usar la clase Loader. No es una clase famosa (no sé por qué), pero es mucho mejor que AsyncTask. Para obtener más información, puede leer los tutoriales de Android que se encuentran en los cursos de Android de Udacity.

Por supuesto, de otra forma, puede almacenar los valores o las vistas con onSaveInstanceState y leerlos con onRestoreInstanceState. Depende de usted realmente.

Respondido 09 ago 18, 08:08

Sí, agreguemos trozos de código adicional para que parezca "profesional". O qué tal si nos atenemos a la forma rápida, fácil, verdadera y probada de hacerlo con el atributo configurationChanges. - desarrollador de Android

Después de un tiempo de prueba y error, encontré una solución que se adapta a mis necesidades en la mayoría de situaciones. Aquí está el código:

Configuración de manifiesto:

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

Actividad principal:

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

}

Y fragmento de muestra:

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

}

Se puede encontrar en gitHub.

Respondido 30 Oct 15, 03:10

Utiliza orientation oyente para realizar diferentes tareas en diferente orientación.

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

Respondido el 27 de Septiembre de 16 a las 10:09

Pon este código a continuación en tu Activity in Android Manifest.

android:configChanges="orientation"

Esto no reiniciará su actividad cuando cambie de orientación.

Respondido el 27 de Septiembre de 16 a las 10:09

@Mavamaarten Probablemente porque, como otros han señalado, es una mala práctica y otras diez respuestas ya lo han cubierto. - MikkoP

Fije la orientación de la pantalla (horizontal o vertical) en AndroidManifest.xml

android:screenOrientation="portrait" or android:screenOrientation="landscape"

para esto tu onResume() no se llama al método.

Respondido el 27 de Septiembre de 16 a las 10:09

¿Cómo diablos arreglar algo es una respuesta? ¿Por qué nuestros dispositivos pueden rotar si bloqueamos a los usuarios que lo usan? - Reinherd

Uno de los mejores componentes de la arquitectura de Android introducido por Google cumplirá con todos los requisitos que es ViewModel.

Eso está diseñado para almacenar y administrar datos relacionados con la interfaz de usuario en forma de ciclo de vida, además de que permitirá que los datos sobrevivan a medida que la pantalla gira

class MyViewModel : ViewModel() {

Por favor refiérase a esto:https://developer.android.com/topic/libraries/architecture/viewmodel

Respondido 24 Oct 18, 11:10

Puede utilizar el objeto ViewModel en su actividad.

Los objetos ViewModel se retienen automáticamente durante los cambios de configuración para que los datos que contienen estén disponibles inmediatamente para la siguiente actividad o instancia de fragmento. Lee mas:

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

Respondido el 19 de Septiembre de 18 a las 17:09

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.