рестарт активность на вращение Android

Обновление для Android 3.2 и выше:

Внимание : Начиная с Android 3.2 (уровень API - 13), «размер экрана» также изменяется , когда устройство переключается между портретной и альбомной ориентации. Таким образом, если вы хотите , чтобы предотвратить во время выполнения перезагружается из - за изменения ориентации при разработке для уровня API 13 или выше (как указано в minSdkVersion и targetSdkVersion атрибутов), вы должны включить "screenSize"значение в дополнении к "orientation"стоимости. То есть, вы должны объявить android:configChanges="orientation|screenSize". Тем не менее, если приложение предназначено уровень API 12 или ниже, то ваша деятельность всегда обрабатывает сам это изменение конфигурации (это изменение конфигурации не перезагружать вашу деятельность, даже при работе на Android 3.2 или выше устройства).

Вместо того , чтобы пытаться остановить onCreate()от увольнения вообще, возможно , попробуйте проверить Bundle savedInstanceStateпередается в событие , чтобы увидеть , если она равна нулю или нет.

Например, если у меня есть какая - то логика , которая должна быть запущена , когда Activityдействительно создается, а не на каждой смене ориентации, я только запустить эту логику в onCreate()только если savedInstanceStateравно нулю.

В противном случае, я все еще хочу, чтобы макет перерисовать должным образом для ориентации.

public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_game_list);

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

не уверен, если это окончательный ответ, но это работает для меня.

что я сделал...

в манифесте, раздел деятельности, добавил:

android:configChanges="keyboardHidden|orientation"

в коде деятельности, реализуемая:

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

То, что вы описываете поведение по умолчанию. Вы должны обнаружить и обрабатывать эти события самостоятельно, добавив:

android:configChanges

в манифесте, а затем изменения, которые вы хотите обработать. Таким образом, для ориентации, вы должны использовать:

android:configChanges="orientation"

и для клавиатуры открытия или закрытия вы будете использовать:

android:configChanges="keyboardHidden"

Если вы хотите, чтобы обрабатывать как вы можете просто разделить их с помощью команды трубы, как:

android:configChanges="keyboardHidden|orientation"

Это вызовет onConfigurationChanged метод в любой активности вы звоните. Если переопределить метод, который вы можете перейти в новых значениях.

Надеюсь это поможет.

Я только что обнаружил это знания:

Для поддержания активности живых через изменения ориентации и обращение с ним через onConfigurationChanged, документация и образец коды выше предполагают , что это в файле манифеста:

android:configChanges="keyboardHidden|orientation"

который имеет дополнительное преимущество, что он всегда работает.

Бонус знание является то , что опуская keyboardHiddenможет показаться логичным, но это вызывает сбои в эмуляторе (для Android 2.1 , по крайней мере): указание только orientationсделает эмулятор вызов как OnCreateи onConfigurationChangedиногда, и только OnCreateдругие времена.

Я не видел провал на устройстве, но я слышал о эмуляторе неисправного для других. Так что стоит документированию.

Вы могли бы также рассмотреть возможность использования , как в Android платформы сохраняющихся данных через изменения ориентации: onRetainNonConfigurationInstance()и getLastNonConfigurationInstance().

Это позволяет сохранять данные через изменения конфигурации, такие как информация может быть нечестным с сервера выборки или что - то еще , что это был вычисленного в onCreateили так, в то же время позволяя Android повторно макет вашего Activityиспользования файла XML для ориентации в настоящее время используется ,

Смотрите здесь или здесь .

Следует отметить , что эти методы в настоящее время не рекомендуются (хотя еще более гибки , чем обработка ориентации изменить себя , как большинство из перечисленных выше решений предполагает) с рекомендацией , что каждый переключиться на Fragmentsи вместо этого использовать setRetainInstance(true)на каждом Fragmentвы хотите сохранить.

Такой подход полезен, но является неполным при использовании фрагментов.

Фрагменты обычно получают воссозданы по изменению конфигурации. Если вы не хотите, чтобы это произошло, используйте

setRetainInstance(true); в конструкторе фрагмента (ов)

Это заставит фрагменты должны быть сохранены во время изменения конфигурации.

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

Я просто добавил

     android:configChanges="keyboard|keyboardHidden|orientation"

в файле манифеста и не добавить любой onConfigurationChangedметод в моей деятельности.

Таким образом , каждый раз , когда клавиатура выдвигается или ничего не происходит .

Добавьте эту строку в манифесте: -

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

и этот фрагмент в деятельности: -

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

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

Какая часть манифеста говорит это «не называют onCreate()»?

Кроме того , документы Google говорят , чтобы избежать использования android:configChanges( за исключением случаев , в крайнем случае ) .... Но альтернативные методы , которые они предполагают все DO использовать android:configChanges.

Это был мой опыт , что эмулятор всегда вызывает onCreate()при вращении.
Но 1-2 устройства , которые я бегу один и тот же код на ... нет. (Не знаю , почему было бы никакой разницы.)

Изменения, которые будут сделаны в манифесте Android являются:

android:configChanges="keyboardHidden|orientation" 

Дополнения, которые будут сделаны в деятельности:

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

Есть несколько способов сделать это:

Сохранить активность государство

Вы можете сохранить состояние активности в 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);
}

а затем использовать bundleдля восстановления состояния.

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

Ручка изменения ориентации от себя

Другой альтернативой является обрабатывать изменения ориентации самостоятельно. Но это не считается хорошей практикой.

Добавьте это в файл манифеста.

android:configChanges="keyboardHidden|orientation"

для Android 3.2 и более поздних версий:

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

Ограничить вращение

Вы можете также ограничить вашу активность в портретном или ландшафтном режиме, чтобы избежать вращения.

Добавьте к этому тегу активности в вашем файле манифеста:

        android:screenOrientation="portrait"

Или это реализовать программно в своей деятельности:

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

onCreateМетод еще называют , даже если вы измените orientationот андроида. Таким образом , перемещение всего тяжелые функциональных возможностей этого метода не собирается , чтобы помочь вам

Поместите код ниже внутри <activity>тега Manifest.xml:

android:configChanges="screenLayout|screenSize|orientation"

Способ я нашел , чтобы это сделать , это использовать onRestoreInstanceStateи onSaveInstanceStateсобытия , чтобы сохранить что - то в Bundle(даже если вы не нужны никакие переменные , сохраненные, просто положить что - то там так Bundleне пусто). Затем, по onCreateметоду, проверьте , чтобы увидеть , если Bundleпуст, и если да, то сделать инициализацию, если нет, то сделать это.

Несмотря на то, что это не «Android путь» Я получил очень хорошие результаты при обработке ориентации изменяет себя и просто репозиционирование виджеты в представлении принять измененную ориентацию во внимание. Это быстрее, чем любой другой подход, потому что ваши взгляды не должны быть сохранены и восстановлены. Она также обеспечивает более плавный опыт для пользователя, так как respositioned виджеты точно такие же виджеты, только что переехал и / или изменять их размер. Не только состояние модели, но и просматривать состояние, может быть сохранено в этой манере.

RelativeLayoutиногда может быть хорошим выбором для вида , который должен переориентироваться время от времени. Вы просто предоставить набор портретного Params компоновочного и набор ландшафтного Params макета, с различными правилами относительного позиционирования на каждом, для каждого дочернего виджета. Тогда в вашем onConfigurationChanged()методе, вы передаете подходящую к setLayoutParams()вызову на каждом ребенке. Если какой - либо сам дочерний элемент управления должен быть внутренне переориентироваться, вы просто вызвать метод этого ребенка выполнить переориентацию. Этот ребенок так же вызывает методы на любом из его дочерних элементов управления , которые требуют внутренней переориентации, и так далее.

Это очень просто просто сделать следующие шаги:

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

Это работает для меня:

Примечание: ориентация зависит от requitement

Примечание: я отправляю этот ответ , если кто - то в будущем столкнуться с той же проблемой , как и я. Для меня следующая строка не прийти:

android:configChanges="orientation"

Когда я повернут экран, метод `onConfigurationChanged (Конфигурация newConfig) did вызываются.

Решение: Я также должен добавить « Размер экрана» даже если проблема была связана с ориентацией. Таким образом , в AndroidManifest.xml - файл, добавьте это:

android:configChanges="keyboardHidden|orientation|screenSize"

Затем реализовать метод onConfigurationChanged(Configuration newConfig)

Вы должны использовать метод onSavedInstanceState хранить все значение его параметра имеет то есть расслоение

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

и использование

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

к retrive и установите значение для просмотра объектов он будет обрабатывает экран вращение

Каждый раз, когда экран поворачивается, открытая деятельность закончена и OnCreate () вызывается снова.

1. Вы можете сделать одно сохранить состояние активности при повороте экрана , так что вы можете восстановить все старые вещи , когда OnCreate данного вида деятельности () вызываются снова. См этой ссылки

2. Если вы хотите, чтобы предотвратить повторный запуск деятельности просто поместите следующие строки в файле manifest.xml.

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

В разделе активности из manifest, добавьте:

android:configChanges="keyboardHidden|orientation"

Через некоторое время проб и ошибок, я нашел решение, которое соответствует моим потребностям в большинстве ситуаций. Вот код:

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>

Основная деятельность:

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

}

И образец Фрагмент:

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

}

Можно найти на GitHub .

Используйте orientationслушателю для выполнения различных задач на различной ориентации.

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

Поместите этот код , приведенный ниже в вашем Activityин Android Manifest.

android:configChanges="orientation"

Это не будет перезапущен активность, когда вы изменить ориентацию.

Закрепить ориентацию экрана (ландшафт или портрет) в AndroidManifest.xml

android:screenOrientation="portrait" или android:screenOrientation="landscape"

для этого ваш onResume()метод не вызывается.

Люди говорят, что вы должны использовать

android:configChanges="keyboardHidden|orientation"

Но самый лучший и самый профессиональный способ справиться с вращением в Android является использование класса Loader. Это не известный класс (я не знаю, почему), но это намного лучше, чем AsyncTask. Я использовал его, чтобы завершить задание Популярные-Фильмы-Part-1 от курса Android степени нано.

Популярные фильмы часть 1

Конечно, вы могли бы хранить ценности или взгляды с onSaveInstanceState и читать их с onRestoreInstanceState. Это до вас, на самом деле.

Добавить эту строку андроида: configChanges = «ориентация |» в Размер экрана манифеста

Вы можете заблокировать к текущей ориентации экрана с помощью этого кода ...

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