Riavvio dell'attività su Android rotazione

Nella mia applicazione Android, quando ruoto il dispositivo (faccio scorrere la tastiera) quindi il mio Activityviene riavviato (onCreate viene chiamato). Ora, questo è probabilmente come dovrebbe essere, ma faccio molte impostazioni iniziali nel onCreatemetodo, quindi ho bisogno di entrambi:

1. Metti tutte le impostazioni iniziali in un'altra funzione in modo che non siano tutte perse durante la rotazione del dispositivo o
2. Rendilo così onCreate non venga richiamato di nuovo e il layout si regola o
3. Limitare l'app a solo ritratto in modo che onCreatenon venga chiamato.

Utilizzando la classe di applicazione

A seconda di ciò che stai facendo nella tua inizializzazione, potresti prendere in considerazione la creazione di una nuova classe che estende Applicatione sposta il tuo codice di inizializzazione in un onCreatemetodo ignorato all'interno di quella classe.

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

L' onCreatenella classe di applicazione si chiama solo quando viene creata l'intera applicazione, quindi il riavvio di attività sull'orientamento o tastiera modifiche di visibilità non attivano esso.

È buona norma esporre l'istanza di questa classe come singleton ed esporre le variabili dell'applicazione che si stanno inizializzando utilizzando getter e setter.

NOTA: è necessario specificare il nome della nuova classe di applicazione nel manifest affinché sia ​​registrata e utilizzata:

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

Reazione alle modifiche alla configurazione [AGGIORNAMENTO: è obsoleto dall'API 13; vedi l'alternativa consigliata ]

Come ulteriore alternativa, puoi fare in modo che l'applicazione ascolti gli eventi che potrebbero causare un riavvio, come cambiamenti di orientamento e visibilità della tastiera, e gestirli all'interno della tua attività.

Inizia aggiungendo il android:configChangesnodo al nodo manifest della tua attività

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

o per Android 3.2 (livello API 13) e successivi :

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

Quindi, all'interno dell'Attività, sovrascrivere il onConfigurationChangedmetodo e chiamare setContentViewper forzare il layout della GUI da rifare nel nuovo orientamento.

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

Aggiornamento per Android 3.2 e versioni successive:

Attenzione : a partire da Android 3.2 (livello API 13), la "dimensione dello schermo" cambia anche quando il dispositivo passa dall'orientamento verticale a quello orizzontale. Pertanto, se si desidera impedire il riavvio del runtime a causa della modifica dell'orientamento durante lo sviluppo per livello API 13 o superiore (come dichiarato dagli attributi minSdkVersion e targetSdkVersion), è necessario includere il "screenSize"valore oltre al "orientation"valore. Cioè, devi dichiarare android:configChanges="orientation|screenSize". Tuttavia, se l'applicazione ha come target API livello 12 o inferiore, la tua attività gestisce sempre questa modifica della configurazione stessa (questa modifica della configurazione non riavvia la tua attività, anche quando è in esecuzione su un dispositivo Android 3.2 o versione successiva).

Invece di provare a fermare il onCreate()licenziamento del tutto, forse prova a controllareBundle savedInstanceState passaggio nell'evento per vedere se è nullo o no.

Ad esempio, se ho una logica che dovrebbe essere eseguita quando Activityviene veramente creata, non ad ogni cambio di orientamento, eseguo quella logica onCreate()solo se ilsavedInstanceState è nulla.

Altrimenti, voglio ancora ridisegnare correttamente il layout per l'orientamento.

public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_game_list);

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

non sono sicuro che questa sia la risposta definitiva, ma funziona per me.

cosa ho fatto...

nel manifest, nella sezione attività, sono stati aggiunti:

android:configChanges="keyboardHidden|orientation"

nel codice per l'attività, implementato:

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

Quello che descrivi è il comportamento predefinito. Devi rilevare e gestire questi eventi tu stesso aggiungendo:

android:configChanges

al tuo manifest e quindi ai cambiamenti che vuoi gestire. Quindi per l'orientamento, useresti:

android:configChanges="orientation"

e per l'apertura o la chiusura della tastiera dovresti usare:

android:configChanges="keyboardHidden"

Se vuoi gestirli entrambi puoi semplicemente separarli con il comando pipe come:

android:configChanges="keyboardHidden|orientation"

Ciò attiverà il metodo onConfigurationChanged in qualunque attività tu chiami. Se si ignora il metodo, è possibile passare i nuovi valori.

Spero che sia di aiuto.

Ho appena scoperto questa tradizione:

Per mantenere attiva l'attività attraverso una modifica dell'orientamento e gestirla onConfigurationChanged, la documentazione e l'esempio di codice sopra suggeriscono questo nel file manifest:

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

che ha il vantaggio extra che funziona sempre.

La tradizione bonus è che omettendo la keyboardHiddenpuò sembrare logico, ma provoca fallimenti nell'emulatore (per Android 2.1 almeno): specificando solo orientationrenderà la chiamata emulatore sia OnCreatee onConfigurationChangedvolte, e solo OnCreatealtre volte.

Non ho visto l'errore su un dispositivo, ma ho sentito che l'emulatore non funziona per gli altri. Quindi vale la pena documentare.

Potresti anche considerare di utilizzare il modo della piattaforma Android di conservare i dati attraverso i cambiamenti di orientamento: onRetainNonConfigurationInstance()egetLastNonConfigurationInstance() .

Ciò ti consente di conservare i dati attraverso le modifiche alla configurazione, come le informazioni che potresti aver ottenuto da un recupero del server o qualcos'altro che è stato calcolato in onCreateo da allora, consentendo anche ad Android di ridimensionare il tuoActivity utilizzo del file xml per l'orientamento ora in uso .

Vedi qui o qui .

Va notato che questi metodi sono ora deprecati (anche se ancora più flessibili della gestione dell'orientamento cambiano te stesso come la maggior parte delle soluzioni di cui sopra suggeriscono) con la raccomandazione che tutti passano Fragmentse invece utilizzano setRetainInstance(true)su ciascuno che Fragmentsi desidera conservare.

L'approccio è utile ma è incompleto quando si usano i frammenti.

I frammenti di solito vengono ricreati al cambio di configurazione. Se non desideri che ciò accada, utilizza

setRetainInstance(true); nel costruttore (i) del frammento

Ciò causerà la conservazione dei frammenti durante la modifica della configurazione.

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

Ho appena aggiunto

     android:configChanges="keyboard|keyboardHidden|orientation"

nel file manifest e non ha aggiunto alcun onConfigurationChangedmetodo nella mia attività.

Quindi ogni volta che la tastiera scorre o non succede nulla .

Il onCreatemetodo viene ancora chiamato anche quando si cambia orientationAndroid. Quindi spostare tutte le funzionalità pesanti su questo metodo non ti aiuterà

Inserisci il codice sottostante all'interno del <activity>tag in Manifest.xml:

android:configChanges="screenLayout|screenSize|orientation"

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

Quale parte del manifest dice "non chiamare onCreate()"?

Inoltre, documenti di Google dicono di evitare l'uso android:configChanges(se non come ultima risorsa) .... Ma poi i metodi alternativi che suggeriscono tutti DO uso android:configChanges.

È stata la mia esperienza che l'emulatore chiama SEMPRE onCreate()alla rotazione.
Ma i dispositivi 1-2 su cui eseguo lo stesso codice su ... non lo fanno. (Non so perché ci sarebbe qualche differenza.)

È molto semplice, basta fare i seguenti passi:

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

Questo funziona per me:

Nota: l' orientamento dipende dal requisito

Le modifiche da apportare nel manifest Android sono:

android:configChanges="keyboardHidden|orientation" 

Le aggiunte da effettuare all'interno dell'attività sono:

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

Aggiungi questa riga al tuo manifest: -

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

e questo frammento dell'attività: -

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

Esistono diversi modi per farlo:

Salva stato attività

È possibile salvare lo stato dell'attività 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);
}

e quindi utilizzare il bundleper ripristinare lo stato.

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

Gestisci i cambiamenti di orientamento da solo

Un'altra alternativa è gestire i cambiamenti di orientamento da soli. Ma questa non è considerata una buona pratica.

Aggiungi questo al tuo file manifest.

android:configChanges="keyboardHidden|orientation"

per Android 3.2 e versioni successive:

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

Limitare la rotazione

Puoi anche limitare la tua attività alla modalità verticale o orizzontale per evitare la rotazione.

Aggiungi questo al tag attività nel tuo file manifest:

        android:screenOrientation="portrait"

O implementalo programmaticamente nella tua attività:

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

Il modo che ho trovato per farlo è utilizzare le onRestoreInstanceStatee gli onSaveInstanceStateeventi per salvare qualcosa nel Bundle(anche se non avete bisogno di tutte le variabili memorizzate, basta mettere qualcosa in là in modo che il Bundlenon è vuoto). Quindi, sul onCreatemetodo, controlla se Bundleè vuoto e se lo è, quindi esegui l'inizializzazione, in caso contrario, quindi eseguilo.

Anche se non è "il modo Android", ho ottenuto ottimi risultati gestendo me stesso i cambiamenti di orientamento e semplicemente riposizionando i widget in vista per tenere conto dell'orientamento alterato. Questo è più veloce di qualsiasi altro approccio, perché le tue viste non devono essere salvate e ripristinate. Offre inoltre un'esperienza più fluida all'utente, poiché i widget riposizionati sono esattamente gli stessi widget, appena spostati e / o ridimensionati. Non solo lo stato del modello, ma anche lo stato di visualizzazione, può essere preservato in questo modo.

RelativeLayouta volte può essere una buona scelta per una vista che deve riorientarsi di volta in volta. È sufficiente fornire una serie di parametri di layout verticale e una serie di parametri di layout paesaggistici, con diverse regole di posizionamento relative su ciascuno, per ciascun widget figlio. Quindi, nel tuo onConfigurationChanged()metodo, passi quello appropriato a una setLayoutParams()chiamata su ogni bambino. Se uno stesso controllo figlio deve essere riorientato internamente , è sufficiente chiamare un metodo su quel figlio per eseguire il riorientamento. Quel bambino chiama allo stesso modo metodi su uno qualsiasi dei suoi controlli figlio che necessitano di riorientamento interno e così via.

Ogni volta che si ruota lo schermo, l'attività aperta viene terminata e viene richiamato onCreate ().

1 Puoi fare una cosa per salvare lo stato di attività quando lo schermo viene ruotato in modo tale da poter recuperare tutte le cose vecchie quando viene richiamato onCreate () di attività. Fare riferimento questo link

2 Se vuoi impedire il riavvio dell'attività, inserisci le seguenti righe nel tuo file manifest.xml.

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

è necessario utilizzare il metodo onSavedInstanceState per memorizzare tutto il valore nel relativo parametro è bundle

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

e usare

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

per recuperare e impostare il valore per visualizzare gli oggetti, gestirà le rotazioni dello schermo

Nota: invio questa risposta se in futuro qualcuno dovesse affrontare lo stesso problema. Per me la seguente riga non era abbastanza:

android:configChanges="orientation"

Quando ho ruotato lo schermo, il metodo `onConfigurationChanged (Configuration newConfig) non è stato chiamato.

Soluzione: ho anche dovuto aggiungere "screenSize" anche se il problema riguardava l'orientamento. Quindi nel file AndroidManifest.xml, aggiungi questo:

android:configChanges="keyboardHidden|orientation|screenSize"

Quindi implementare il metodo onConfigurationChanged(Configuration newConfig)

Nella sezione attività di manifest, aggiungi:

android:configChanges="keyboardHidden|orientation"

Aggiungi questa riga in manifest: android:configChanges="orientation|screenSize"

La gente dice che dovresti usare

android:configChanges="keyboardHidden|orientation"

Ma il modo migliore e più professionale per gestire la rotazione in Android è utilizzare la classe Loader. Non è una classe famosa (non so perché), ma è molto meglio dell'AsyncTask. Per ulteriori informazioni, puoi leggere i tutorial Android disponibili nei corsi Android di Udacity.

Naturalmente, in un altro modo, è possibile memorizzare i valori o le viste con onSaveInstanceState e leggerli con onRestoreInstanceState. Dipende davvero da te.

Dopo un po 'di tentativi ed errori, ho trovato una soluzione adatta alle mie esigenze nella maggior parte delle situazioni. Ecco il codice:

Configurazione manifest:

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

Attività principale:

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

}

E frammento di esempio:

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

}

Può essere trovato su Github .

Utilizzare l' orientationascoltatore per eseguire diverse attività con orientamento diverso.

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

Mettete questo sotto codice nel tuo Activityin Android Manifest.

android:configChanges="orientation"

Questo non riavvierà la tua attività quando cambierai l'orientamento.

Correggi l'orientamento dello schermo (orizzontale o verticale) in AndroidManifest.xml

android:screenOrientation="portrait" o android:screenOrientation="landscape"

per questo il tuo onResume()metodo non viene chiamato.

Uno dei migliori componenti di Android Architechure introdotti da Google soddisferà tutti i requisiti di ViewModel.

È progettato per archiviare e gestire i dati relativi all'interfaccia utente nel modo del ciclo di vita, oltre a consentire ai dati di sopravvivere durante la rotazione dello schermo

class MyViewModel : ViewModel() {

Si prega di fare riferimento a questo: https://developer.android.com/topic/libraries/architecture/viewmodel

È possibile utilizzare l'oggetto ViewModel nella propria attività.

Gli oggetti ViewModel vengono conservati automaticamente durante le modifiche alla configurazione in modo che i dati in loro possesso siano immediatamente disponibili per l'attività o l'istanza del frammento successiva. Leggi di più:

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