diff --git a/services/core/java/com/android/server/wm/ActivityRecord.java b/services/core/java/com/android/server/wm/ActivityRecord.java
index 6ff1023..d1faa71 100644
--- a/services/core/java/com/android/server/wm/ActivityRecord.java
+++ b/services/core/java/com/android/server/wm/ActivityRecord.java
@@ -17,6 +17,7 @@
 package com.android.server.wm;
 
 import static android.app.ActivityManager.LOCK_TASK_MODE_NONE;
+import static android.app.ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND;
 import static android.app.ActivityManager.TaskDescription.ATTR_TASKDESCRIPTION_PREFIX;
 import static android.app.ActivityOptions.ANIM_CLIP_REVEAL;
 import static android.app.ActivityOptions.ANIM_CUSTOM;
@@ -2726,12 +2727,27 @@
         }
 
         final Rect parentAppBounds = parentConfig.windowConfiguration.getAppBounds();
-        if (parentAppBounds.width() < resolvedAppBounds.width()
-                || parentAppBounds.height() < resolvedAppBounds.height()) {
+        final int appWidth = resolvedAppBounds.width();
+        final int appHeight = resolvedAppBounds.height();
+        final int parentAppWidth = parentAppBounds.width();
+        final int parentAppHeight = parentAppBounds.height();
+        if (parentAppWidth < appWidth || parentAppHeight < appHeight) {
             // One side is larger than the parent.
             return true;
         }
 
+        if (info.hasFixedAspectRatio()) {
+            final float aspectRatio = (0.5f + Math.max(appWidth, appHeight))
+                    / Math.min(appWidth, appHeight);
+            final float parentAspectRatio = (0.5f + Math.max(parentAppWidth, parentAppHeight))
+                    / Math.min(parentAppWidth, parentAppHeight);
+            // Check if the parent still has available space in long side.
+            if (aspectRatio < parentAspectRatio
+                    && (aspectRatio < info.maxAspectRatio || info.minAspectRatio > 0)) {
+                return true;
+            }
+        }
+
         final Rect resolvedBounds = resolvedConfig.windowConfiguration.getBounds();
         // If the width or height is the same as parent, it is already the best fit of the override
         // bounds, therefore this condition is considered as not size compatibility mode. Here uses
@@ -2930,8 +2946,27 @@
         }
 
         final ActivityDisplay display = getDisplay();
-        if (display != null) {
+        if (display == null) {
+            return;
+        }
+        if (visible) {
+            // It may toggle the UI for user to restart the size compatibility mode activity.
             display.handleActivitySizeCompatModeIfNeeded(this);
+        } else if (shouldUseSizeCompatMode()) {
+            // The override changes can only be obtained from display, because we don't have the
+            // difference of full configuration in each hierarchy.
+            final int displayChanges = display.getLastOverrideConfigurationChanges();
+            final int orientationChanges = CONFIG_WINDOW_CONFIGURATION
+                    | CONFIG_SCREEN_SIZE | CONFIG_ORIENTATION;
+            final boolean hasNonOrienSizeChanged = hasResizeChange(displayChanges)
+                    // Filter out the case of simple orientation change.
+                    && (displayChanges & orientationChanges) != orientationChanges;
+            // For background activity that uses size compatibility mode, if the size or density of
+            // the display is changed, then reset the override configuration and kill the activity's
+            // process if its process state is not important to user.
+            if (hasNonOrienSizeChanged || (displayChanges & ActivityInfo.CONFIG_DENSITY) != 0) {
+                restartProcessIfVisible();
+            }
         }
     }
 
@@ -3398,7 +3433,8 @@
     void restartProcessIfVisible() {
         Slog.i(TAG, "Request to restart process of " + this);
 
-        // Reset the existing override configuration to the latest configuration.
+        // Reset the existing override configuration so it can be updated according to the latest
+        // configuration.
         getRequestedOverrideConfiguration().setToDefaults();
         getResolvedOverrideConfiguration().setToDefaults();
         if (visible) {
@@ -3418,8 +3454,17 @@
             // Kill its process immediately because the activity should be in background.
             // The activity state will be update to {@link #DESTROYED} in
             // {@link ActivityStack#cleanUpActivityLocked} when handling process died.
-            mAtmService.mH.post(() -> mAtmService.mAmInternal.killProcess(
-                    app.mName, app.mUid, "restartActivityProcess"));
+            mAtmService.mH.post(() -> {
+                final WindowProcessController wpc;
+                synchronized (mAtmService.mGlobalLock) {
+                    if (!hasProcess()
+                            || app.getReportedProcState() <= PROCESS_STATE_IMPORTANT_FOREGROUND) {
+                        return;
+                    }
+                    wpc = app;
+                }
+                mAtmService.mAmInternal.killProcess(wpc.mName, wpc.mUid, "resetConfig");
+            });
             return;
         }
 
diff --git a/services/core/java/com/android/server/wm/ActivityTaskManagerService.java b/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
index 118eb5b..b3b4cbe 100644
--- a/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
+++ b/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
@@ -5209,7 +5209,7 @@
                 // the ATMS lock held.
                 final Message msg = PooledLambda.obtainMessage(
                         ActivityManagerInternal::killAllBackgroundProcessesExcept, mAmInternal,
-                        N, ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE);
+                        N, ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND);
                 mH.sendMessage(msg);
             }
         }
diff --git a/services/core/java/com/android/server/wm/ConfigurationContainer.java b/services/core/java/com/android/server/wm/ConfigurationContainer.java
index 5c528c7..3886ae1 100644
--- a/services/core/java/com/android/server/wm/ConfigurationContainer.java
+++ b/services/core/java/com/android/server/wm/ConfigurationContainer.java
@@ -77,6 +77,9 @@
      */
     private Configuration mFullConfiguration = new Configuration();
 
+    /** The bit mask of the last override fields of full configuration. */
+    private int mLastOverrideConfigurationChanges;
+
     /**
      * Contains merged override configuration settings from the top of the hierarchy down to this
      * particular instance. It is different from {@link #mFullConfiguration} because it starts from
@@ -108,6 +111,11 @@
         return mFullConfiguration;
     }
 
+    /** Returns the last changes from applying override configuration. */
+    int getLastOverrideConfigurationChanges() {
+        return mLastOverrideConfigurationChanges;
+    }
+
     /**
      * Notify that parent config changed and we need to update full configuration.
      * @see #mFullConfiguration
@@ -116,7 +124,8 @@
         mTmpConfig.setTo(mResolvedOverrideConfiguration);
         resolveOverrideConfiguration(newParentConfig);
         mFullConfiguration.setTo(newParentConfig);
-        mFullConfiguration.updateFrom(mResolvedOverrideConfiguration);
+        mLastOverrideConfigurationChanges =
+                mFullConfiguration.updateFrom(mResolvedOverrideConfiguration);
         if (!mTmpConfig.equals(mResolvedOverrideConfiguration)) {
             onMergedOverrideConfigurationChanged();
             // This depends on the assumption that change-listeners don't do
diff --git a/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java b/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java
index 2a0dc27..d580557 100644
--- a/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java
@@ -43,7 +43,10 @@
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.anyString;
 
+import android.app.ActivityManager;
+import android.app.ActivityManagerInternal;
 import android.app.ActivityOptions;
 import android.app.servertransaction.ActivityConfigurationChangeItem;
 import android.app.servertransaction.ClientTransaction;
@@ -61,6 +64,8 @@
 import org.junit.Test;
 import org.mockito.invocation.InvocationOnMock;
 
+import java.util.concurrent.TimeUnit;
+
 /**
  * Tests for the {@link ActivityRecord} class.
  *
@@ -175,13 +180,11 @@
     @Test
     public void testRestartProcessIfVisible() {
         doNothing().when(mSupervisor).scheduleRestartTimeout(mActivity);
-        mTask.getWindowConfiguration().setAppBounds(0, 0, 500, 1000);
         mActivity.visible = true;
         mActivity.haveState = false;
-        mActivity.info.resizeMode = ActivityInfo.RESIZE_MODE_UNRESIZEABLE;
-        mActivity.info.maxAspectRatio = 1.5f;
         mActivity.setState(ActivityStack.ActivityState.RESUMED, "testRestart");
-        ensureActivityConfiguration();
+        prepareFixedAspectRatioUnresizableActivity();
+
         final Rect originalOverrideBounds = new Rect(mActivity.getBounds());
         mTask.getWindowConfiguration().setAppBounds(0, 0, 600, 1200);
         // The visible activity should recompute configuration according to the last parent bounds.
@@ -459,13 +462,9 @@
         newDisplay.getWindowConfiguration().setAppBounds(new Rect(0, 0, 1000, 2000));
         newDisplay.getConfiguration().densityDpi = 300;
 
-        mTask.getWindowConfiguration().setAppBounds(mStack.getDisplay().getBounds());
         mTask.getConfiguration().densityDpi = 200;
-        when(mActivity.mAppWindowToken.getOrientationIgnoreVisibility()).thenReturn(
-                ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
-        mActivity.info.resizeMode = ActivityInfo.RESIZE_MODE_UNRESIZEABLE;
-        mActivity.info.maxAspectRatio = 1.5f;
-        ensureActivityConfiguration();
+        prepareFixedAspectRatioUnresizableActivity();
+
         final Rect originalBounds = new Rect(mActivity.getBounds());
         final int originalDpi = mActivity.getConfiguration().densityDpi;
 
@@ -475,14 +474,16 @@
 
         assertEquals(originalBounds, mActivity.getBounds());
         assertEquals(originalDpi, mActivity.getConfiguration().densityDpi);
+        assertTrue(mActivity.inSizeCompatMode());
     }
 
     @Test
     public void testSizeCompatMode_FixedScreenBoundsWhenDisplaySizeChanged() {
         when(mActivity.mAppWindowToken.getOrientationIgnoreVisibility()).thenReturn(
-                ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
+                ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
         mTask.getWindowConfiguration().setAppBounds(mStack.getDisplay().getBounds());
-        mActivity.info.screenOrientation = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
+        mTask.getConfiguration().orientation = Configuration.ORIENTATION_PORTRAIT;
+        mActivity.info.screenOrientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
         mActivity.info.resizeMode = ActivityInfo.RESIZE_MODE_UNRESIZEABLE;
         ensureActivityConfiguration();
         final Rect originalBounds = new Rect(mActivity.getBounds());
@@ -492,6 +493,7 @@
         ensureActivityConfiguration();
 
         assertEquals(originalBounds, mActivity.getBounds());
+        assertTrue(mActivity.inSizeCompatMode());
     }
 
     @Test
@@ -500,10 +502,7 @@
                 | Configuration.SCREENLAYOUT_SIZE_NORMAL;
         mTask.getConfiguration().screenLayout = fixedScreenLayout
                 | Configuration.SCREENLAYOUT_LAYOUTDIR_LTR;
-        mTask.getWindowConfiguration().setAppBounds(mStack.getDisplay().getBounds());
-        mActivity.info.resizeMode = ActivityInfo.RESIZE_MODE_UNRESIZEABLE;
-        mActivity.info.maxAspectRatio = 1.5f;
-        ensureActivityConfiguration();
+        prepareFixedAspectRatioUnresizableActivity();
 
         // The initial configuration should inherit from parent.
         assertEquals(mTask.getConfiguration().screenLayout,
@@ -517,4 +516,46 @@
         assertEquals(fixedScreenLayout | Configuration.SCREENLAYOUT_LAYOUTDIR_RTL,
                 mActivity.getConfiguration().screenLayout);
     }
+
+    @Test
+    public void testSizeCompatMode_ResetNonVisibleActivity() {
+        final ActivityDisplay display = mStack.getDisplay();
+        spyOn(display);
+
+        prepareFixedAspectRatioUnresizableActivity();
+        mActivity.setState(STOPPED, "testSizeCompatMode");
+        mActivity.visible = false;
+        mActivity.app.setReportedProcState(ActivityManager.PROCESS_STATE_CACHED_ACTIVITY);
+        // Make the parent bounds to be different so the activity is in size compatibility mode.
+        mTask.getWindowConfiguration().setAppBounds(new Rect(0, 0, 600, 1200));
+
+        // Simulate the display changes orientation.
+        doReturn(ActivityInfo.CONFIG_SCREEN_SIZE | ActivityInfo.CONFIG_ORIENTATION
+                | ActivityInfo.CONFIG_WINDOW_CONFIGURATION)
+                        .when(display).getLastOverrideConfigurationChanges();
+        mActivity.onConfigurationChanged(mTask.getConfiguration());
+        // The override configuration should not change so it is still in size compatibility mode.
+        assertTrue(mActivity.inSizeCompatMode());
+
+        // Simulate the display changes density.
+        doReturn(ActivityInfo.CONFIG_DENSITY).when(display).getLastOverrideConfigurationChanges();
+        mService.mAmInternal = mock(ActivityManagerInternal.class);
+        mActivity.onConfigurationChanged(mTask.getConfiguration());
+        // The override configuration should be reset and the activity's process will be killed.
+        assertFalse(mActivity.inSizeCompatMode());
+        verify(mActivity).restartProcessIfVisible();
+        mService.mH.runWithScissors(() -> { }, TimeUnit.SECONDS.toMillis(3));
+        verify(mService.mAmInternal).killProcess(
+                eq(mActivity.app.mName), eq(mActivity.app.mUid), anyString());
+    }
+
+    /** Setup {@link #mActivity} as a size-compat-mode-able activity without fixed orientation. */
+    private void prepareFixedAspectRatioUnresizableActivity() {
+        when(mActivity.mAppWindowToken.getOrientationIgnoreVisibility()).thenReturn(
+                ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
+        mTask.getWindowConfiguration().setAppBounds(mStack.getDisplay().getBounds());
+        mActivity.info.resizeMode = ActivityInfo.RESIZE_MODE_UNRESIZEABLE;
+        mActivity.info.maxAspectRatio = 1.5f;
+        ensureActivityConfiguration();
+    }
 }