restart aktivita na otáčení Android

hlasů
1k

V mé aplikaci pro Android, když jsem se otáčet zařízení (vysouvací klávesnici), pak můj Activityrestartování ( onCreatese nazývá). Nyní, toto je pravděpodobně jak to mělo být, ale mám hodně počáteční zřízení v onCreatemetodě, takže musím buď:

  1. Dát všechny výchozí nastavení v jiné funkci, takže to není vše ztraceno na otočení přístroje nebo
  2. Ať je to tak onCreatenení zavolal znovu a uspořádání právě upravuje nebo
  3. Omezte aplikaci pouze na výšku, takže onCreatenení volána.
Položena 19/01/2009 v 01:28
zdroj uživatelem
V jiných jazycích...                            


31 odpovědí

hlasů
885

Použití třídy Application

V závislosti na tom, co děláte ve svém inicializace byste mohli uvažovat o vytvoření nové třídy, která rozšiřuje Applicationa pohybem inicializační kód do překryté onCreatemetody v této třídě.

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

onCreateVe třídě aplikace se nazývá pouze tehdy, když je vytvořena celá aplikace, takže aktivita restartuje na orientaci nebo klávesnice změně viditelnosti, nespustí se.

Je dobrým zvykem vystavit instance této třídy jako jedináček a vystavení proměnné aplikace jste inicializace s použitím metody pro čtení a zápis.

Poznámka: Budete muset zadat název vaší nové třídy aplikace v manifestu, aby mohla být registrována a použita:

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

V reakci na změny konfigurace [UPDATE: to je zastaralý, protože API 13; viz doporučenou alternativou ]

Jako další alternativa, můžete mít svou aplikaci poslouchat události, které by mohly znamenat restart - jako je orientace a změnami viditelnosti klávesnice - a manipulovali s nimi v rámci vaší činnosti.

Začněte tím, že přidá android:configChangesuzel do svého manifestu uzlu Activity je

android:configChanges="keyboardHidden|orientation"

nebo pro Android 3.2 (na úrovni API 13) a novější :

android:configChanges="keyboardHidden|orientation|screenSize"

Pak v rámci aktivity přepsat onConfigurationChangedmetody a volání setContentViewpřinutit vzhled GUI být znovu provedeno v nové orientaci.

@Override
public void onConfigurationChanged(Configuration newConfig) {
  super.onConfigurationChanged(newConfig);
  setContentView(R.layout.myLayout);
}
Odpovězeno 19/01/2009 v 09:47
zdroj uživatelem

hlasů
173

Aktualizace pro Android 3.2 a vyšší:

Upozornění : Počínaje s operačním systémem Android 3.2 (na úrovni API 13), dále jen „velikost obrazovky“ se také změní , když přístroj se mezi orientací na výšku a na šířku. Takže pokud chcete, aby se zabránilo runtime restartuje kvůli změně orientace při vývoji na úrovni API 13 nebo vyšší (podle prohlášení parametr versionCode a targetSdkVersion atributů), je nutné zahrnout "screenSize"hodnotu navíc k "orientation"hodnotě. To znamená, že musí deklarovat android:configChanges="orientation|screenSize". Nicméně, pokud vaše aplikace cílí na úroveň API 12 nebo nižší, pak se vaše aktivita vždy zpracovává tuto konfiguraci změnu sám (tato změna konfigurace neobnoví svou činnost, i když běží na Android 3.2 nebo vyšším zařízení).

Odpovězeno 03/03/2012 v 22:56
zdroj uživatelem

hlasů
108

Místo toho se snaží zastavit onCreate()od vyhazovu vůbec, možná zkusit zaškrtnutím Bundle savedInstanceStatebyly přeneseny do akce, aby zjistili, zda je null nebo není.

Například, když mám nějakou logiku, který by měl být spuštěn, když Activityje skutečně vytvořen, ne při každé změně orientace, já jen spustit tuto logiku v onCreate()pouze v případě, že savedInstanceStateje nulový.

Jinak stále chci rozložení správně překreslit pro orientaci.

public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_game_list);

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

Není si jistý, jestli je to konečná odpověď, ale funguje to pro mě.

Odpovězeno 04/08/2012 v 22:04
zdroj uživatelem

hlasů
93

to, co jsem udělal...

v manifestu, k části aktivita, která zní:

android:configChanges="keyboardHidden|orientation"

v kódu pro činnost, realizována:

//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();
}
Odpovězeno 04/01/2011 v 02:26
zdroj uživatelem

hlasů
57

Co byste popsat, je výchozí chování. Musíte odhalit a tyto události sami zvládnout a dodává:

android:configChanges

vašich zjevných a pak změny, které chcete zvládnout. Takže pro orientaci, měli byste použít:

android:configChanges="orientation"

a klávesnice je otevření nebo zavření byste použili:

android:configChanges="keyboardHidden"

Chcete-li zvládnout obojí stačí oddělte pomocí příkazu trubky, jako je:

android:configChanges="keyboardHidden|orientation"

To spustí onConfigurationChanged metodu v jakékoliv aktivity říkáte. Pokud přepsat metodu, kterou lze předat do nové hodnoty.

Snad to pomůže.

Odpovězeno 19/01/2009 v 03:28
zdroj uživatelem

hlasů
39

Právě jsem objevil tuto tradici:

Pro zachování aktivity při životě pomocí změny orientace a manipulace to přes onConfigurationChanged, dokumentace a ukázkový kód výše naznačují to v manifestu souboru:

android:configChanges="keyboardHidden|orientation"

která má navíc výhodu, že vždy funguje.

Bonus tradice je, že vynechání keyboardHiddense může zdát logické, ale to způsobí selhání v emulátoru (pro Android 2.1 přinejmenším): zadáním pouze orientationučiní emulátoru volání jak OnCreatea onConfigurationChangedněkdy, a to pouze OnCreatejiné časy.

Neviděl jsem poruchu na zařízení, ale slyšel jsem o emulátoru selhání pro ostatní. Tak to stojí za dokumentování.

Odpovězeno 22/12/2010 v 22:50
zdroj uživatelem

hlasů
33

Můžete také zvážit použití cestu platformě Android je přetrvávajících dat v rámci změny orientace: onRetainNonConfigurationInstance()a getLastNonConfigurationInstance().

To vám umožní přetrvávat dat napříč konfiguračních změn, jako jsou informace, které jste dostali od načtení serveru nebo něco jiného, který byl počítán onCreateani potom, a zároveň umožňuje Android znovu dispozic Activitypomocí XML souboru pro orientaci nyní v provozu ,

Viz zde nebo zde .

Je třeba poznamenat, že tyto metody jsou nyní zastaralé (i když stále pružnější než manipulace orientaci změnit sami sebe, protože většina z výše uvedených řešení navrhnout) s doporučením, aby se všichni přejít na Fragmentsa místo toho použít setRetainInstance(true)na každém Fragmentchcete zachovat.

Odpovězeno 22/09/2011 v 04:03
zdroj uživatelem

hlasů
28

Tento přístup je užitečná, ale je neúplný při použití fragmentů.

Fragmenty obvykle dostat znovu na změnu konfigurace. Pokud si nepřejete, aby se to stalo, využívání

setRetainInstance(true); ve fragmentu konstruktoru (y)

To způsobí, že fragmenty, které se uchovávají při změně konfigurace.

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

Odpovězeno 21/09/2012 v 10:09
zdroj uživatelem

hlasů
21

Já prostě přidán

     android:configChanges="keyboard|keyboardHidden|orientation"

v souboru manifestu a nepřidali žádnou onConfigurationChangedmetodu mého působení.

Takže pokaždé, když je klávesnice se vysouvá nebo nic se neděje .

Odpovězeno 09/08/2012 v 10:58
zdroj uživatelem

hlasů
13

Přidejte tento řádek do svého manifestu: -

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

a tento úryvek k činnosti: -

@Override
    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                WindowManager.LayoutParams.FLAG_FULLSCREEN);
    }
Odpovězeno 23/07/2014 v 11:00
zdroj uživatelem

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

Jaká část manifestu jej říká „nevolají onCreate()“?

Také Dokumenty Google říkají, aby se zabránilo používání android:configChanges(s výjimkou v krajním případě) .... Ale pak alternativní metody, které vyvolávají dojem, všichni DO používat android:configChanges.

To byla moje zkušenost, že emulátor vždy volá onCreate()při otáčení.
Ale 1-2 zařízení, které jsem spustit stejný kód na ... ne. (Nejste si jisti, proč tam by byl nějaký rozdíl.)

Odpovězeno 01/02/2012 v 16:55
zdroj uživatelem

hlasů
12

Změny, které mají být provedené v Android manifestu jsou:

android:configChanges="keyboardHidden|orientation" 

Dodatky, které mají být vyrobeny v činnosti jsou:

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();
    }
}
Odpovězeno 11/11/2011 v 13:20
zdroj uživatelem

hlasů
11

Existuje několik způsobů, jak toho dosáhnout:

Save State aktivity

Můžete uložit stav aktivity v 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);
}

a pak použít bundlek obnovení stavu.

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

Zvládnout změny orientace sami

Jinou alternativou je zvládnout změny orientace sami. Ale to není považováno za dobrou praxi.

Přidejte toto do vašeho souboru manifestu.

android:configChanges="keyboardHidden|orientation"

pro Android 3.2 a novější:

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

omezovat rotaci

Můžete také omezit svou činnost na výšku i na šířku, aby se zabránilo rotaci.

Přidat tuto značku aktivity ve svém manifestu souboru:

        android:screenOrientation="portrait"

Nebo realizovat tento programově ve své činnosti:

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}
Odpovězeno 07/01/2016 v 18:55
zdroj uživatelem

hlasů
11

onCreateMetoda se dodnes nazývá, i když změníte orientationAndroid. Tak dojemné veškerou těžkou funkčnost této metody není ti pomůže

Odpovězeno 21/01/2010 v 11:40
zdroj uživatelem

hlasů
10

Vložit níže uvedený kód uvnitř <activity>tagu Manifest.xml:

android:configChanges="screenLayout|screenSize|orientation"
Odpovězeno 21/08/2014 v 12:55
zdroj uživatelem

hlasů
10

To, jak jsem zjistil, jak to udělat, je použít onRestoreInstanceStatea onSaveInstanceStateudálosti pro uložení něco v Bundle(i když nepotřebujete všechny proměnné uložené, prostě dát něco tam, takže Bundlenení prázdný). Potom na onCreatemetodě, zkontrolujte, zda je Bundleprázdná, a pokud ano, pak to inicializaci, pokud ne, tak to udělej.

Odpovězeno 21/12/2012 v 21:15
zdroj uživatelem

hlasů
9

I když to není „způsob, jakým Android“ Získala jsem velmi dobré výsledky při manipulaci orientace se změní sám a jednoduše přemístit widgety v rámci cílem převzít změněnou orientaci v úvahu. To je rychlejší než jakýkoli jiný přístup, protože vaše názory nemusejí být uloženy a obnoveny. Poskytuje také další bezproblémové pro uživatele, protože respositioned widgety jsou naprosto stejné widgety, se přestěhoval a / nebo velikost. Nejen modelu stát, ale také zobrazit stav, může být zachována tímto způsobem.

RelativeLayoutNěkdy může být dobrou volbou pro zobrazení, které musí přeorientovat sebe čas od času. Právě jste poskytnout soubor portrétních rozložení params a sadu upravené rozvržení params, s různými pravidly relativní polohy na každém, pro každé dítě widgetu. Pak se ve svém onConfigurationChanged()způsobu, minete příslušný jeden k setLayoutParams()hovoru na každé dítě. Pokud je třeba některý kontrola dítě samo musí být vnitřně přeorientovat, stačí zavolat metodu k tomuto dítěti provést změnu orientace. Že dítě podobně volá metody na některý z jeho podřízených ovládacích prvků, které vyžadují vnitřní novou orientaci, a tak dále.

Odpovězeno 16/03/2012 v 10:13
zdroj uživatelem

hlasů
8

Je to velmi jednoduché, stačí provést následující kroky:

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

To funguje pro mě:

Poznámka: orientace závisí na vaší requitement

Odpovězeno 14/12/2015 v 06:39
zdroj uživatelem

hlasů
6

Poznámka: I tento post odpověď, pokud někdo v budoucnu čelit stejnému problému jako já. Pro mě je následující řádek nebyl enought:

android:configChanges="orientation"

Když jsem se otáčet obrazovku, metoda `onConfigurationChanged (Configuration NewConfig) did't dorovnán.

Řešení: Také jsem měl přidat „screenSize“ iv případě, že problém má co dělat s orientací. Takže v AndroidManifest.xml - souboru přidejte následující:

android:configChanges="keyboardHidden|orientation|screenSize"

Potom implementovat metodu onConfigurationChanged(Configuration newConfig)

Odpovězeno 24/04/2014 v 15:40
zdroj uživatelem

hlasů
5

budete muset použít onSavedInstanceState metodu ukládat všechny hodnoty jeho parametrů se má, že je svazek

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

a využívání

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

retrive a nastavte hodnotu pro zobrazení objektů, bude to zvládá rotaci obrazovky

Odpovězeno 07/12/2016 v 10:23
zdroj uživatelem

hlasů
4

Pokaždé, když se otočí displej, otevřel aktivita je dokončena a OnCreate () je volána znovu.

1. Můžete to udělat jednu věc uložit stav aktivity, když se otočí displej, takže můžete obnovit všechny staré věci, když onCreate činnost vznikla () je volána znovu. Viz tento link

2. Chcete-li zabránit restartování činnosti stačí umístit tyto řádky ve vašem Manifest.xml souboru.

  <activity android:name=".Youractivity"
  android:configChanges="orientation|screenSize"/>
Odpovězeno 03/02/2017 v 10:47
zdroj uživatelem

hlasů
2

V sekci aktivitu manifest, přidejte:

android:configChanges="keyboardHidden|orientation"
Odpovězeno 10/03/2017 v 08:14
zdroj uživatelem

hlasů
2

Po nějaké době pokusů a omylů, jsem našel řešení, které vyhovuje mým potřebám ve většině situací. Zde je kód:

Zjevná konfigurace:

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

Hlavní aktivita:

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

}

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

}

Lze nalézt na GitHub .

Odpovězeno 30/10/2015 v 03:53
zdroj uživatelem

hlasů
2

Použijte orientationposluchače plnit různé úkoly na různých zaměření.

@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);
    }
}
Odpovězeno 04/02/2015 v 06:58
zdroj uživatelem

hlasů
2

Dej to pod kód do vašich Activityin Android Manifest.

android:configChanges="orientation"

To nebude restartovat aktivitu, když se změní orientace.

Odpovězeno 29/07/2013 v 08:09
zdroj uživatelem

hlasů
2

Fix orientace obrazovky (na výšku nebo na šířku) v AndroidManifest.xml

android:screenOrientation="portrait" nebo android:screenOrientation="landscape"

za to vaše onResume()je metoda není volána.

Odpovězeno 15/02/2013 v 12:14
zdroj uživatelem

hlasů
1

Jeden z nejlepších složky android architechure zavede google splní vaše veškeré požadavky, které jsou ViewModel.

Který je určen pro ukládání a správu UI související data životního cyklu způsobem a který umožní údaje o přežití jako obrazovky se otáčí

class MyViewModel : ViewModel() {

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

Odpovězeno 24/10/2018 v 10:37
zdroj uživatelem

hlasů
1

Lidé říkají, že byste měli používat

android:configChanges="keyboardHidden|orientation"

Ale nejlepší a nejprofesionálnější způsob, jak zvládnout rotace v Android je použít třídu Loader. Není to slavná třída (nevím proč), ale je to mnohem lepší než AsyncTask. Použil jsem ji dokončit populárně-filmy-Part-1 úkol z Android nano studijního programu.

Oblíbené filmy část 1

Samozřejmě byste mohli ukládat hodnoty nebo názory s onSaveInstanceState a číst je s onRestoreInstanceState. Záleží jen na vás opravdu.

Odpovězeno 09/01/2018 v 10:03
zdroj uživatelem

hlasů
1

Přidejte tento řádek androida: configChanges = „orientace | screenSize“ v manifestu

Odpovězeno 28/11/2017 v 12:42
zdroj uživatelem

hlasů
0

Můžete použít viewmodel objekt ve vaší činnosti.

objekty ViewModel jsou automaticky zachovány během změny konfigurace tak, že data, která drží, je okamžitě k dispozici pro další činnost nebo fragmentu instance. Přečtěte si více:

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

Odpovězeno 19/09/2018 v 16:24
zdroj uživatelem

hlasů
0

Můžete zamknout na aktuální orientace obrazovky pomocí tohoto kódu ...

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);
        }
Odpovězeno 06/05/2014 v 07:23
zdroj uživatelem

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more