您所描述的是默认行为。您必须通过添加以下内容自行检测和处理这些事件：

android:configChanges

然后是您想要处理的更改。因此，对于方向，您可以使用：

android:configChanges="orientation"

对于正在打开或关闭的键盘，您可以使用：

android:configChanges="keyboardHidden"

如果要同时处理这两种情况，只需使用pipe命令将它们分开，如：

android:configChanges="keyboardHidden|orientation"

这将在您调用的任何Activity中触发onConfigurationChanged方法。如果重写该方法，则可以传入新值。

希望这有帮助。

使用应用程序类

根据您在初始化中所做的操作，您可以考虑创建一个扩展Application的新类，并将初始化代码移动到该类中的重写onCreate方法中。

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

应用程序类中的onCreate仅在创建整个应用程序时调用，因此“活动”在方向或键盘可见性更改时重新启动不会触发它。

最好将这个类的实例公开为一个单例，并使用getter和setter公开正在初始化的应用程序变量。

注意：您需要在清单中指定要注册和使用的新Application类的名称：

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

对配置更改作出反应[UPDATE：自API 13以来，这已被弃用；请参阅推荐的替代方案]

作为另一种选择，您可以让应用程序监听可能导致重新启动的事件（如方向和键盘可见性更改），并在“活动”中处理这些事件。

首先将android:configChanges节点添加到“活动”的清单节点

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

或适用于Android 3.2（API级别13）及更高版本：

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

然后在“活动”中重写onConfigurationChanged方法，并调用setContentView以强制以新方向重新完成GUI布局。

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

即使更改android的方向，onCreate方法仍会被调用。因此，将所有繁重的功能转移到这个方法并不会对您有所帮助

我刚刚发现了这个传说：

为了通过方向更改保持活动活动，并通过onConfigurationChanged处理活动，上面的文档和代码示例在Manifest文件中建议：

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

这有一个额外的好处，那就是它总是有效的。

另一个好处是，省略keyboardHidden可能看起来合乎逻辑，但它会导致模拟器失败（至少对于Android 2.1）：只指定方向会使模拟器有时同时调用OnCreate和onConfigurationChanged，而其他时候只调用OnCreate。

我还没有看到设备出现故障，但我听说过其他设备的仿真器出现故障。因此值得记录。

我所做的。。。

在清单的活动部分中，添加了：

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平台的跨方向更改持久化数据的方式：onRetainNonConfigurationInstance（）和getLastNonConfigurationInstance）。

这允许您在配置更改中保存数据，例如您可能从服务器获取的信息或在onCreate中或之后计算的其他信息，同时还允许Android使用xml文件重新布局“活动”，以适应当前使用的方向。

请看这里或这里。

应该注意的是，这些方法现在已经被弃用（尽管比上面大多数解决方案所建议的自己处理方向改变更灵活），建议每个人都切换到Fragments，而不是在每个想要保留的Fragment上使用setRetainInstance（true）。

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

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

清单的哪个部分告诉它“不要调用onCreate（）”？

而且谷歌的文档说要避免使用android:configChanges（除非作为最后手段）。但是，他们建议的替代方法都使用android：configChanges。

根据我的经验，模拟器总是在旋转时调用onCreate（）。但我运行相同代码的1-2台设备……没有。（不知道为什么会有什么不同。）

Android 3.2及更高版本更新：

警告：从Android 3.2（API级别13）开始，当设备在纵向和横向方向之间切换时，“屏幕大小”也会发生变化。因此，如果在为API级别13或更高级别开发时（如minSdkVersion和targetSdkVersion属性所声明的），想要防止因方向改变而导致运行时重新启动，则除了“方向”值之外，还必须包含“screenSize”值。也就是说，您必须声明android:configChanges=“orientation|screenSize”。但是，如果您的应用程序以API级别12或更低为目标，则您的活动始终自行处理此配置更改（即使在Android 3.2或更高版本的设备上运行时，此配置更改也不会重新启动您的活动）。

从…起http://web.archive.org/web/20120805085007/http://developer.android.com/guide/topics/resources/runtime-更改.html

尽管这不是“Android方式”，但我自己处理方向变化，并简单地在视图中重新定位小部件，以将改变的方向考虑在内，从而获得了非常好的结果。这比任何其他方法都快，因为您的视图不必保存和恢复。它还为用户提供了更无缝的体验，因为重新定位的小部件是完全相同的小部件，只是移动和/或调整大小。不仅可以以这种方式保存模型状态，还可以保存视图状态。

RelativeLayout有时对于需要不时调整自身方向的视图来说是一个不错的选择。您只需为每个子控件提供一组纵向布局参数和一组景观布局参数，每个参数上有不同的相对定位规则。然后，在onConfigurationChanged（）方法中，将适当的值传递给每个子级的setLayoutParams（）调用。如果任何子控件本身需要在内部重新定向，只需调用该子控件上的方法来执行重新定向。该子控件类似地调用其任何需要内部重新定向的子控件上的方法，依此类推。

与其试图阻止onCreate（）被完全激发，不如尝试检查传递到事件中的Bundle savedInstanceState，看看它是否为null。

例如，如果我有一些逻辑应该在真正创建“活动”时运行，而不是在每次方向更改时运行，那么只有当savedInstanceState为空时，我才在onCreate（）中运行该逻辑。

否则，我仍然希望布局按照方向正确重新绘制。

public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_game_list);

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

不确定这是否是最终答案，但这对我来说是有效的。

我只是简单地补充了一句：

android:configChanges="keyboard|keyboardHidden|orientation"

在AndroidManifest.xml文件中，并且没有在我的活动中添加任何onConfigurationChanged方法。

所以，每当键盘滑出或滑入时，什么都不会发生！也可以查看这篇关于这个问题的文章。

该方法是有用的，但在使用碎片时是不完整的。

片段通常在配置更改时重新创建。如果您不希望发生这种情况，请使用

setRetainInstance（true）；在Fragment的构造函数中

这将导致在配置更改期间保留碎片。

http://developer.android.com/reference/android/app/Fragment.html#setRetainInstance（布尔值）

我发现这样做的方法是使用onRestoreInstanceState和onSaveInstanceState事件在Bundle中保存一些东西（即使您不需要保存任何变量，也只需在其中放置一些东西，这样Bundle就不会为空）。然后，在onCreate方法上，检查Bundle是否为空，如果为空，则进行初始化，如果不是，则执行初始化。

修复AndroidManifest.xml中的屏幕方向（横向或纵向）

android:screenOrientation=“纵向”或android:scheenOrientation=“横向”

为此，不会调用onResume（）方法。

将以下代码放在Android清单中的活动中。

android:configChanges="orientation"

当你改变方向时，这不会重新开始你的活动。

注意：如果将来有人和我面临同样的问题，我会发布这个答案。对我来说，下面这行是不够的：

android:configChanges="orientation"

当我旋转屏幕时，没有调用方法`onConfigurationChanged（配置新配置）。

解决方案：即使问题与方向有关，我也必须添加“screenSize”。因此，在AndroidManifest.xml文件中，添加以下内容：

android:configChanges="keyboardHidden|orientation|screenSize"

然后实现方法onConfigurationChanged（Configuration newConfig）

您可以使用此代码锁定屏幕的当前方向。。。

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

将此行添加到清单中：-

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

将以下代码放入Manifest.xml中的<activity>标记中：

android:configChanges="screenLayout|screenSize|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);
    }
}

经过一段时间的反复尝试，我找到了一个在大多数情况下都能满足我需求的解决方案。以下是代码：

清单配置：

<?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上找到。

很简单，只需执行以下步骤：

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

这对我有用：

注意：方向取决于你的要求

有几种方法可以做到这一点：

保存活动状态

您可以在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);
}

然后使用捆绑包恢复状态。

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

您需要使用onSavedInstanceState方法来存储其参数的所有值。is是一个捆绑包

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

检索并设置值以查看对象它将处理屏幕旋转

每次旋转屏幕时，打开的活动都会完成，并再次调用onCreate（）。

1.当屏幕旋转时，您可以做一件事来保存活动状态，这样，当再次调用活动的onCreate（）时，您就可以恢复所有旧的内容。参考此链接

2.如果要阻止重新启动活动，只需在manifest.xml文件中放置以下行。

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

在清单的活动部分中，添加：

android:configChanges="keyboardHidden|orientation"

在清单中添加此行：android:configChanges=“orientation | screenSize”

人们都说你应该使用

android:configChanges="keyboardHidden|orientation"

但在Android中处理旋转的最佳和最专业的方法是使用Loader类。这不是一个著名的类（我不知道为什么），但它比AsyncTask要好得多。有关更多信息，您可以阅读Udacity的Android课程中的Android教程。

当然，作为另一种方式，您可以使用onSaveInstanceState存储值或视图，并使用onRestoreInstanceState读取它们。这真的取决于你。

您可以在活动中使用ViewModel对象。

ViewModel对象在配置更改期间自动保留，以便它们所保存的数据可立即用于下一个活动或片段实例。阅读更多信息：https://developer.android.com/topic/libraries/architecture/viewmodel

谷歌推出的android架构中最好的组件之一将满足ViewModel的所有要求。

它旨在以生命周期的方式存储和管理与UI相关的数据，并允许数据在屏幕旋转时继续存在

class MyViewModel : ViewModel() {

请参阅：https://developer.android.com/topic/libraries/architecture/viewmodel

将此代码添加到manifest.xml中。

这是你的活动。

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

在该活动集中，配置更改如下

 android:configChanges="orientation|screenSize|keyboardHidden"

有很多方法可以做到这一点：

在创建时使用标志在清单文件中添加以下行


> android:screenOrientation=“纵向”


在onCreate（）中


setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

使用onConfigurationChanged（）方法


在清单文件中，为Android 3.2及更高版本添加以下行/

     


android:configChanges="keyboardHidden|orientation" / 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 portrait mode here
    } else if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE){
        //Handle rotation from portrait to landscape mode here
    }
}

使用onSaveInstanceState（）@覆盖public void onSaveInstanceState（捆绑outState）{/在此处保存要还原的数据示例：outState.putLong（“time_state”，time），时间是一个长变量/super.onSaveInstanceState（outState）；}

和恢复

@覆盖protected void onCreate（捆绑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
}

}