Merge "Fix testRegisterComponentCallbacksOnWindowContext flaky" into tm-dev am: db7b4503f3

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/base/+/17799887

Change-Id: Ifa008d9475fb2ce04db0a8f3e9303714d0d79f23
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>

core/java/android/window/WindowProviderService.java

@@ -165,10 +165,11 @@ public abstract class WindowProviderService extends Service implements WindowPro
         }
     }
 
+    // Suppress the lint because ths is overridden from Context.
     @SuppressLint("OnNameExpected")
     @Override
-    // Suppress the lint because ths is overridden from Context.
+    @Nullable
-    public @Nullable Object getSystemService(@NonNull String name) {
+    public Object getSystemService(@NonNull String name) {
         if (WINDOW_SERVICE.equals(name)) {
             return mWindowManager;
         }

core/java/android/window/WindowTokenClient.java

@@ -91,7 +91,6 @@ public class WindowTokenClient extends IWindowToken.Stub {
             throw new IllegalStateException("Context is already attached.");
         }
         mContextRef = new WeakReference<>(context);
-        mConfiguration.setTo(context.getResources().getConfiguration());
         mShouldDumpConfigForIme = Build.IS_DEBUGGABLE
                 && context instanceof AbstractInputMethodService;
     }
@@ -112,7 +111,8 @@ public class WindowTokenClient extends IWindowToken.Stub {
             if (configuration == null) {
                 return false;
             }
-            onConfigurationChanged(configuration, displayId, false /* shouldReportConfigChange */);
+            mHandler.runWithScissors(() -> onConfigurationChanged(configuration, displayId,
+                    false /* shouldReportConfigChange */), 0 /* timeout */);
             mAttachToWindowContainer = true;
             return true;
         } catch (RemoteException e) {
@@ -137,8 +137,8 @@ public class WindowTokenClient extends IWindowToken.Stub {
             if (configuration == null) {
                 return false;
             }
-            mHandler.post(() -> onConfigurationChanged(configuration, displayId,
+            mHandler.runWithScissors(() -> onConfigurationChanged(configuration, displayId,
-                    false /* shouldReportConfigChange */));
+                    false /* shouldReportConfigChange */), 0 /* timeout */);
             mAttachToWindowContainer = true;
             return true;
         } catch (RemoteException e) {

services/core/java/com/android/server/wm/ConfigurationContainer.java

@@ -637,12 +637,19 @@ public abstract class ConfigurationContainer<E extends ConfigurationContainer> {
     }
 
     void registerConfigurationChangeListener(ConfigurationContainerListener listener) {
+        registerConfigurationChangeListener(listener, true /* shouldDispatchConfig */);
+    }
+
+    void registerConfigurationChangeListener(ConfigurationContainerListener listener,
+            boolean shouldDispatchConfig) {
         if (mChangeListeners.contains(listener)) {
             return;
         }
         mChangeListeners.add(listener);
-        listener.onRequestedOverrideConfigurationChanged(mResolvedOverrideConfiguration);
+        if (shouldDispatchConfig) {
-        listener.onMergedOverrideConfigurationChanged(mMergedOverrideConfiguration);
+            listener.onRequestedOverrideConfigurationChanged(mResolvedOverrideConfiguration);
+            listener.onMergedOverrideConfigurationChanged(mMergedOverrideConfiguration);
+        }
     }
 
     void unregisterConfigurationChangeListener(ConfigurationContainerListener listener) {

services/core/java/com/android/server/wm/WindowContainer.java

@@ -3747,13 +3747,20 @@ class WindowContainer<E extends WindowContainer> extends ConfigurationContainer<
     }
 
     void registerWindowContainerListener(WindowContainerListener listener) {
+        registerWindowContainerListener(listener, true /* shouldPropConfig */);
+    }
+
+    void registerWindowContainerListener(WindowContainerListener listener,
+            boolean shouldDispatchConfig) {
         if (mListeners.contains(listener)) {
             return;
         }
         mListeners.add(listener);
         // Also register to ConfigurationChangeListener to receive configuration changes.
-        registerConfigurationChangeListener(listener);
+        registerConfigurationChangeListener(listener, shouldDispatchConfig);
-        listener.onDisplayChanged(getDisplayContent());
+        if (shouldDispatchConfig) {
+            listener.onDisplayChanged(getDisplayContent());
+        }
     }
 
     void unregisterWindowContainerListener(WindowContainerListener listener) {

services/core/java/com/android/server/wm/WindowContextListenerController.java

@@ -68,6 +68,16 @@ class WindowContextListenerController {
     @VisibleForTesting
     final ArrayMap<IBinder, WindowContextListenerImpl> mListeners = new ArrayMap<>();
 
+    /**
+     * @see #registerWindowContainerListener(IBinder, WindowContainer, int, int, Bundle, boolean)
+     */
+    void registerWindowContainerListener(@NonNull IBinder clientToken,
+            @NonNull WindowContainer<?> container, int ownerUid, @WindowType int type,
+            @Nullable Bundle options) {
+        registerWindowContainerListener(clientToken, container, ownerUid, type, options,
+                true /* shouDispatchConfigWhenRegistering */);
+    }
+
     /**
      * Registers the listener to a {@code container} which is associated with
      * a {@code clientToken}, which is a {@link android.window.WindowContext} representation. If the
@@ -80,15 +90,18 @@ class WindowContextListenerController {
      * @param ownerUid the caller UID
      * @param type the window type
      * @param options a bundle used to pass window-related options.
+     * @param shouDispatchConfigWhenRegistering {@code true} to indicate the current
+     *                {@code container}'s config will dispatch to the client side when
+     *                registering the {@link WindowContextListenerImpl}
      */
     void registerWindowContainerListener(@NonNull IBinder clientToken,
             @NonNull WindowContainer<?> container, int ownerUid, @WindowType int type,
-            @Nullable Bundle options) {
+            @Nullable Bundle options, boolean shouDispatchConfigWhenRegistering) {
         WindowContextListenerImpl listener = mListeners.get(clientToken);
         if (listener == null) {
             listener = new WindowContextListenerImpl(clientToken, container, ownerUid, type,
                     options);
-            listener.register();
+            listener.register(shouDispatchConfigWhenRegistering);
         } else {
             listener.updateContainer(container);
         }
@@ -228,12 +241,16 @@ class WindowContextListenerController {
         }
 
         private void register() {
+            register(true /* shouldDispatchConfig */);
+        }
+
+        private void register(boolean shouldDispatchConfig) {
             final IBinder token = mClientToken.asBinder();
             if (mDeathRecipient == null) {
                 throw new IllegalStateException("Invalid client token: " + token);
             }
             mListeners.putIfAbsent(token, this);
-            mContainer.registerWindowContainerListener(this);
+            mContainer.registerWindowContainerListener(this, shouldDispatchConfig);
         }
 
         private void unregister() {

services/core/java/com/android/server/wm/WindowManagerService.java

@@ -2770,12 +2770,10 @@ public class WindowManagerService extends IWindowManager.Stub
                 }
                 // TODO(b/155340867): Investigate if we still need roundedCornerOverlay after
                 // the feature b/155340867 is completed.
-                final DisplayArea da = dc.findAreaForWindowType(type, options,
+                final DisplayArea<?> da = dc.findAreaForWindowType(type, options,
                         callerCanManageAppTokens, false /* roundedCornerOverlay */);
-                // TODO(b/190019118): Avoid to send onConfigurationChanged because it has been done
-                //  in return value of attachWindowContextToDisplayArea.
                 mWindowContextListenerController.registerWindowContainerListener(clientToken, da,
-                        callingUid, type, options);
+                        callingUid, type, options, false /* shouDispatchConfigWhenRegistering */);
                 return da.getConfiguration();
             }
         } finally {
@@ -2871,7 +2869,8 @@ public class WindowManagerService extends IWindowManager.Stub
                 }
 
                 mWindowContextListenerController.registerWindowContainerListener(clientToken, dc,
-                        callingUid, INVALID_WINDOW_TYPE, null /* options */);
+                        callingUid, INVALID_WINDOW_TYPE, null /* options */,
+                        false /* shouDispatchConfigWhenRegistering */);
                 return dc.getConfiguration();
             }
         } finally {