programacion - poner titulo android studio

¿Es posible verificar que se haya llamado onCreate debido a un cambio de orientación?

Question

Necesito actuar de manera diferente en el método onStart() dependiendo de cómo se llamó a onCreate() como resultado del orientation change de orientation change o no. ¿Es eso posible comprobarlo?

En realidad, lo que necesito es hacer something cuando comienza la actividad, excepto en el caso de que el usuario cambie de orientación .

Necesito distinguir claramente los casos cuando el usuario simplemente cambió a otra aplicación y regresó O cambió la orientación del dispositivo.

Answer 1

Como han dicho otros, salva el estado:

public class MyActivity extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        if(savedInstanceState == null) {
            // app started afresh, don''t check orientation
            /* do application first-run stuff */
        } else {
            // re-started, so check for orientation change
            boolean orientationChanged = false;
            if(savedInstanceState != null) {
                int lastOrientation = savedInstanceState.getInt("last_orientation");
                orientationChanged = (getOrientation() != lastOrientation);
            }

            if(orientationChanged) {
                // orientation changed
                /* do stuff */
            } else {
                // orientation has not changed
                /* do stuff */
            }
        }
    }

    @Override
    public void onSaveInstanceState(Bundle savedInstanceState) {
        super.onSaveInstanceState(savedInstanceState);
        savedInstanceState.putInt("last_orientation", getOrientation());
    }

    private int getOrientation() {
        // ...
    }
}

Answer 2

En ese caso, ¿por qué no maneja usted mismo los cambios de configuración (orientación)? Dile a Android que no maneje la orientación de la pantalla.

android:configChanges="keyboardHidden|orientation"

Luego, simplemente anula el método onConfigurationChanged para obtener la reorganización de la vista o cualquier otra cosa que deba hacerse. Deja las cosas que no quieres que te ejecuten.

@Override
public void onConfigurationChanged(Configuration newConfig) {
  super.onConfigurationChanged(newConfig);
  //do your jobs 
}

Answer 3

Prueba getChangingConfigurations . Use esto para descubrir cuándo se está destruyendo la actividad debido a un cambio de orientación, establecer una bandera y verificar esa bandera cuando se llama a onCreate.

Esto tiene la ventaja de hacerle saber por qué la actividad se está reiniciando sin anular la configuración de orientación en el manifiesto.

Answer 4

Puedes probar lo siguiente. En cada inicio, puedes guardar la orientación actual (mira here ). Si es la primera llamada de inicio, no haga nada, en otras llamadas, verifique si la orientación ha cambiado y haga lo que necesita.

private int m_currentOrientation = -1;

public void onStart()
{
   int oldOrientation = m_currentOrientation; // 
   m_currentOrientation = getCurrentOrientation(); // As in the link above
   if ((oldOrientation != -1) && (oldOrientation != m_currentOrientation))
   {
       // Do what you need
   }
}

Answer 5

Siguiendo la idea de Nahtan, escribí esto:

en onCreate ():

if ( (oldConfigInt & ActivityInfo.CONFIG_ORIENTATION)==ActivityInfo.CONFIG_ORIENTATION ) {
    // ... was rotated
} else {
    // ... was not rotated
}

en onDestroy ():

super.onDestroy();
oldConfigInt = getChangingConfigurations();

Answer 6

Simplemente revise el paquete: cuando la actividad se inicia por primera vez, el paquete será nulo. Si hay un cambio de orientación, debe ser no nulo.

De los documentos de Android :

Si la actividad se está reinicializando después de apagarse previamente, este paquete contiene los datos que se proporcionaron más recientemente en onSaveInstanceState (paquete). Nota: de lo contrario es nulo.

Edición: no creo que tenga que proporcionar un paquete en onSaveInstanceState para que no sea nulo después de un cambio de orientación, pero eso sería trivial.

Answer 7

mCurrentOrientation será -1 si la aplicación se inicia por primera vez.

static int mCurrentOrientation = -1;

public void onStart()
{
   int oldOrientation = mCurrentOrientation; 
   mCurrentOrientation = getCurrentOrientation(); 
   if ((oldOrientation != -1) && (oldOrientation != mCurrentOrientation)) {
       // Do your something here.
   }
}

Si entendí tu pregunta correctamente, creo que esto debería funcionar para ti.

Answer 8

public class MyActivity extends Activity {
    boolean fromOrientation=false;
    SharedPreferences myPrefLogin;
    Editor prefsEditor;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        prefsEditor = myPrefLogin.edit();
        myPrefLogin = this.getSharedPreferences("myPrefs", Context.MODE_WORLD_READABLE);
        fromOrientation = myPrefLogin.getString("fromOrient", false);

        if(fromOrientation) {
             // do as per need--- logic of orientation changed.
        } else {
             // do as per need--- logic of default onCreate().
        }
    }

    @Override
    public Object onRetainNonConfigurationInstance() {
        prefsEditor.putString("fromOrient", true);
        prefsEditor.commit();
        return null;
    }

    @Override
    protected void onDestroy() {
        if(fromOrientation) {
            prefsEditor.putString("fromOrient", false);
            prefsEditor.commit();
        }
        super.onDestroy();
    }  
}

flag fromOrientation (indica que el estado de la configuración ha sido cambiado o no) que hicimos anteriormente, como por defalut, estamos considerando que no se llama a onCreate() cambiando la orientación. Si se modificó la orientación ( onRetainNonConfigurationInstance() ), entonces establecemos el valor del indicador en preferencia, que nos permite saber si se llama a onCreate() desde la orientación o no. Y, finalmente, en onDestroy() , restablecemos nuevamente la bandera de orientación.