android-16.0.0_r2/s

/*
 * Copyright (C) 2012 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.view;

import static android.view.Display.INVALID_DISPLAY;
import static android.view.WindowManager.LayoutParams.LAST_APPLICATION_WINDOW;
import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_OPT_OUT_EDGE_TO_EDGE;
import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION;

import android.animation.ValueAnimator;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.compat.annotation.UnsupportedAppUsage;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.res.Configuration;
import android.content.res.TypedArray;
import android.graphics.HardwareRenderer;
import android.os.Binder;
import android.os.Build;
import android.os.IBinder;
import android.os.Looper;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.os.SystemProperties;
import android.util.AndroidRuntimeException;
import android.util.ArrayMap;
import android.util.ArraySet;
import android.util.Log;
import android.util.Pair;
import android.util.SparseArray;
import android.view.inputmethod.InputMethodManager;
import android.window.ITrustedPresentationListener;
import android.window.InputTransferToken;
import android.window.TrustedPresentationThresholds;

import com.android.internal.R;
import com.android.internal.annotations.GuardedBy;
import com.android.internal.policy.PhoneWindow;
import com.android.internal.util.FastPrintWriter;

import java.io.FileDescriptor;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.List;
import java.util.WeakHashMap;
import java.util.concurrent.Executor;
import java.util.function.Consumer;
import java.util.function.IntConsumer;

/**
 * Provides low-level communication with the system window manager for
 * operations that are not associated with any particular context.
 *
 * This class is only used internally to implement global functions where
 * the caller already knows the display and relevant compatibility information
 * for the operation.  For most purposes, you should use {@link WindowManager} instead
 * since it is bound to a context.
 *
 * @see WindowManagerImpl
 * @hide
 */
public final class WindowManagerGlobal {
    private static final String TAG = "WindowManager";

    /**
     * This is the first time the window is being drawn,
     * so the client must call drawingFinished() when done
     */
    public static final int RELAYOUT_RES_FIRST_TIME = 1;

    /**
     * The window manager has changed the surface from the last call.
     */
    public static final int RELAYOUT_RES_SURFACE_CHANGED = 1 << 1;

    /**
     * The window manager has changed the size of the surface from the last call.
     */
    public static final int RELAYOUT_RES_SURFACE_RESIZED = 1 << 2;

    /**
     * In multi-window we force show the system bars. Because we don't want that the surface size
     * changes in this mode, we instead have a flag whether the system bar sizes should always be
     * consumed, so the app is treated like there is no virtual system bars at all.
     */
    public static final int RELAYOUT_RES_CONSUME_ALWAYS_SYSTEM_BARS = 1 << 3;

    /**
     * The window manager has told the window it cannot draw this frame and should retry again.
     */
    public static final int RELAYOUT_RES_CANCEL_AND_REDRAW = 1 << 4;

    /**
     * Flag for relayout: the client will be later giving
     * internal insets; as a result, the window will not impact other window
     * layouts until the insets are given.
     */
    public static final int RELAYOUT_INSETS_PENDING = 0x1;

    public static final int ADD_FLAG_IN_TOUCH_MODE = 0x1;
    public static final int ADD_FLAG_APP_VISIBLE = 0x2;

    /**
     * Like {@link #RELAYOUT_RES_CONSUME_ALWAYS_SYSTEM_BARS}, but as a "hint" when adding the
     * window.
     */
    public static final int ADD_FLAG_ALWAYS_CONSUME_SYSTEM_BARS = 0x4;

    public static final int ADD_OKAY = 0;
    public static final int ADD_BAD_APP_TOKEN = -1;
    public static final int ADD_BAD_SUBWINDOW_TOKEN = -2;
    public static final int ADD_NOT_APP_TOKEN = -3;
    public static final int ADD_APP_EXITING = -4;
    public static final int ADD_DUPLICATE_ADD = -5;
    public static final int ADD_STARTING_NOT_NEEDED = -6;
    public static final int ADD_MULTIPLE_SINGLETON = -7;
    public static final int ADD_PERMISSION_DENIED = -8;
    public static final int ADD_INVALID_DISPLAY = -9;
    public static final int ADD_INVALID_TYPE = -10;
    public static final int ADD_INVALID_USER = -11;

    @UnsupportedAppUsage
    private static WindowManagerGlobal sDefaultWindowManager;
    @UnsupportedAppUsage
    private static IWindowManager sWindowManagerService;
    @UnsupportedAppUsage
    private static IWindowSession sWindowSession;

    @UnsupportedAppUsage
    private final Object mLock = new Object();

    @UnsupportedAppUsage
    private final ArrayList<View> mViews = new ArrayList<View>();
    /**
     * The {@link ListenerGroup} that is associated to {@link #mViews}.
     * @hide
     */
    @GuardedBy("mLock")
    private final ListenerGroup<List<View>> mWindowViewsListenerGroup =
            new ListenerGroup<>(new ArrayList<>());
    @UnsupportedAppUsage
    private final ArrayList<ViewRootImpl> mRoots = new ArrayList<ViewRootImpl>();
    @UnsupportedAppUsage
    private final ArrayList<WindowManager.LayoutParams> mParams =
            new ArrayList<WindowManager.LayoutParams>();
    private final ArraySet<View> mDyingViews = new ArraySet<View>();

    private final ArrayList<ViewRootImpl> mWindowlessRoots = new ArrayList<ViewRootImpl>();

    /** A context token only has one remote registration to system. */
    private WeakHashMap<IBinder, ProposedRotationListenerDelegate> mProposedRotationListenerMap;

    private Runnable mSystemPropertyUpdater;

    private final TrustedPresentationListener mTrustedPresentationListener =
            new TrustedPresentationListener();

    @GuardedBy("mSurfaceControlInputReceivers")
    private final SparseArray<SurfaceControlInputReceiverInfo>
            mSurfaceControlInputReceivers = new SparseArray<>();

    private WindowManagerGlobal() {
    }

    @UnsupportedAppUsage
    public static void initialize() {
        getWindowManagerService();
    }

    @UnsupportedAppUsage
    public static WindowManagerGlobal getInstance() {
        synchronized (WindowManagerGlobal.class) {
            if (sDefaultWindowManager == null) {
                sDefaultWindowManager = new WindowManagerGlobal();
            }
            return sDefaultWindowManager;
        }
    }

    /**
     * Sets {@link com.android.server.wm.WindowManagerService} for the system process.
     * <p>
     * It is needed to prevent possible deadlock. A possible scenario is:
     * In system process, WMS holds {@link com.android.server.wm.WindowManagerGlobalLock} to call
     * {@code WindowManagerGlobal} APIs and wait to lock {@code WindowManagerGlobal} itself
     * (i.e. call {@link #getWindowManagerService()} in the global lock), while
     * another component may lock {@code WindowManagerGlobal} and wait to lock
     * {@link com.android.server.wm.WindowManagerGlobalLock}(i.e call {@link #addView} in the
     * system process, which calls to {@link com.android.server.wm.WindowManagerService} API
     * directly).
     */
    public static void setWindowManagerServiceForSystemProcess(@NonNull IWindowManager wms) {
        sWindowManagerService = wms;
    }

    @Nullable
    @UnsupportedAppUsage
    public static IWindowManager getWindowManagerService() {
        if (sWindowManagerService != null) {
            // Use WMS directly without locking WMGlobal to prevent deadlock.
            return sWindowManagerService;
        }
        synchronized (WindowManagerGlobal.class) {
            if (sWindowManagerService == null) {
                sWindowManagerService = IWindowManager.Stub.asInterface(
                        ServiceManager.getService("window"));
                try {
                    // Can be null if this is called before WindowManagerService is initialized.
                    if (sWindowManagerService != null) {
                        ValueAnimator.setDurationScale(
                                sWindowManagerService.getCurrentAnimatorScale());
                    }
                } catch (RemoteException e) {
                    throw e.rethrowFromSystemServer();
                }
            }
            return sWindowManagerService;
        }
    }

    @UnsupportedAppUsage
    public static IWindowSession getWindowSession() {
        synchronized (WindowManagerGlobal.class) {
            if (sWindowSession == null) {
                try {
                    // Emulate the legacy behavior.  The global instance of InputMethodManager
                    // was instantiated here.
                    // TODO(b/116157766): Remove this hack after cleaning up @UnsupportedAppUsage
                    InputMethodManager.ensureDefaultInstanceForDefaultDisplayIfNecessary();
                    IWindowManager windowManager = getWindowManagerService();
                    sWindowSession = windowManager.openSession(
                            new IWindowSessionCallback.Stub() {
                                @Override
                                public void onAnimatorScaleChanged(float scale) {
                                    ValueAnimator.setDurationScale(scale);
                                }
                            });
                } catch (RemoteException e) {
                    throw e.rethrowFromSystemServer();
                }
            }
            return sWindowSession;
        }
    }

    @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023)
    public static IWindowSession peekWindowSession() {
        synchronized (WindowManagerGlobal.class) {
            return sWindowSession;
        }
    }

    @UnsupportedAppUsage
    public String[] getViewRootNames() {
        synchronized (mLock) {
            final int numRoots = mRoots.size();
            final int windowlessRoots = mWindowlessRoots.size();
            String[] mViewRoots = new String[numRoots + windowlessRoots];
            for (int i = 0; i < numRoots; ++i) {
                mViewRoots[i] = getWindowName(mRoots.get(i));
            }
            for (int i = 0; i < windowlessRoots; ++i) {
                mViewRoots[i + numRoots] = getWindowName(mWindowlessRoots.get(i));
            }
            return mViewRoots;
        }
    }

    @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
    public ArrayList<ViewRootImpl> getRootViews(IBinder token) {
        ArrayList<ViewRootImpl> views = new ArrayList<>();
        synchronized (mLock) {
            final int numRoots = mRoots.size();
            for (int i = 0; i < numRoots; ++i) {
                WindowManager.LayoutParams params = mParams.get(i);
                if (params.token == null) {
                    continue;
                }
                if (params.token != token) {
                    boolean isChild = false;
                    if (params.type >= WindowManager.LayoutParams.FIRST_SUB_WINDOW
                            && params.type <= WindowManager.LayoutParams.LAST_SUB_WINDOW) {
                        for (int j = 0 ; j < numRoots; ++j) {
                            View viewj = mViews.get(j);
                            WindowManager.LayoutParams paramsj = mParams.get(j);
                            if (params.token == viewj.getWindowToken()
                                    && paramsj.token == token) {
                                isChild = true;
                                break;
                            }
                        }
                    }
                    if (!isChild) {
                        continue;
                    }
                }
                views.add(mRoots.get(i));
            }
        }
        return views;
    }

    /**
     * @return the list of all views attached to the global window manager
     */
    @NonNull
    public ArrayList<View> getWindowViews() {
        synchronized (mLock) {
            return new ArrayList<>(mViews);
        }
    }

    /**
     * Adds a listener that will be notified whenever {@link #getWindowViews()} changes. The
     * current value is provided immediately using the provided {@link Executor}. If this
     * {@link Consumer} was registered previously, then this is a no op.
     */
    public void addWindowViewsListener(@NonNull Executor executor,
            @NonNull Consumer<List<View>> consumer) {
        synchronized (mLock) {
            if (mWindowViewsListenerGroup.isConsumerPresent(consumer)) {
                return;
            }
            mWindowViewsListenerGroup.addListener(executor, consumer);
        }
    }

    /**
     * Removes a listener that was registered in
     * {@link #addWindowViewsListener(Executor, Consumer)}. If it was not registered previously,
     * then this is a no op.
     */
    public void removeWindowViewsListener(@NonNull Consumer<List<View>> consumer) {
        synchronized (mLock) {
            mWindowViewsListenerGroup.removeListener(consumer);
        }
    }

    public View getWindowView(IBinder windowToken) {
        synchronized (mLock) {
            final int numViews = mViews.size();
            for (int i = 0; i < numViews; ++i) {
                final View view = mViews.get(i);
                if (view.getWindowToken() == windowToken) {
                    return view;
                }
            }
        }
        return null;
    }

    @UnsupportedAppUsage
    public View getRootView(String name) {
        synchronized (mLock) {
            for (int i = mRoots.size() - 1; i >= 0; --i) {
                final ViewRootImpl root = mRoots.get(i);
                if (name.equals(getWindowName(root))) return root.getView();
            }
            for (int i = mWindowlessRoots.size() - 1; i >= 0; --i) {
                final ViewRootImpl root = mWindowlessRoots.get(i);
                if (name.equals(getWindowName(root))) return root.getView();
            }
        }

        return null;
    }

    public void addView(View view, ViewGroup.LayoutParams params,
            Display display, Window parentWindow, int userId) {
        if (view == null) {
            throw new IllegalArgumentException("view must not be null");
        }
        if (display == null) {
            throw new IllegalArgumentException("display must not be null");
        }
        if (!(params instanceof WindowManager.LayoutParams)) {
            throw new IllegalArgumentException("Params must be WindowManager.LayoutParams");
        }

        final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams) params;
        final Context context = view.getContext();
        if (parentWindow != null) {
            parentWindow.adjustLayoutParamsForSubWindow(wparams);
        } else {
            // If there's no parent, then hardware acceleration for this view is
            // set from the application's hardware acceleration setting.
            if (context != null
                    && (context.getApplicationInfo().flags
                    & ApplicationInfo.FLAG_HARDWARE_ACCELERATED) != 0) {
                wparams.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;
            }
        }

        if (context != null && wparams.type > LAST_APPLICATION_WINDOW) {
            final TypedArray styles = context.obtainStyledAttributes(R.styleable.Window);
            if (PhoneWindow.isOptingOutEdgeToEdgeEnforcement(
                    context.getApplicationInfo(), true /* local */, styles)) {
                wparams.privateFlags |= PRIVATE_FLAG_OPT_OUT_EDGE_TO_EDGE;
            }
            styles.recycle();
        }

        ViewRootImpl root;
        View panelParentView = null;

        synchronized (mLock) {
            // Start watching for system property changes.
            if (mSystemPropertyUpdater == null) {
                mSystemPropertyUpdater = new Runnable() {
                    @Override public void run() {
                        synchronized (mLock) {
                            for (int i = mRoots.size() - 1; i >= 0; --i) {
                                mRoots.get(i).loadSystemProperties();
                            }
                        }
                    }
                };
                SystemProperties.addChangeCallback(mSystemPropertyUpdater);
            }

            int index = findViewLocked(view, false);
            if (index >= 0) {
                if (mDyingViews.contains(view)) {
                    // Don't wait for MSG_DIE to make it's way through root's queue.
                    mRoots.get(index).doDie();
                } else {
                    throw new IllegalStateException("View " + view
                            + " has already been added to the window manager.");
                }
                // The previous removeView() had not completed executing. Now it has.
            }

            // If this is a panel window, then find the window it is being
            // attached to for future reference.
            if (wparams.type >= WindowManager.LayoutParams.FIRST_SUB_WINDOW &&
                    wparams.type <= WindowManager.LayoutParams.LAST_SUB_WINDOW) {
                final int count = mViews.size();
                for (int i = 0; i < count; i++) {
                    if (mRoots.get(i).mWindow.asBinder() == wparams.token) {
                        panelParentView = mViews.get(i);
                    }
                }
            }

            IWindowSession windowlessSession = null;
            // If there is a parent set, but we can't find it, it may be coming
            // from a SurfaceControlViewHost hierarchy.
            if (wparams.token != null && panelParentView == null) {
                for (int i = 0; i < mWindowlessRoots.size(); i++) {
                    ViewRootImpl maybeParent = mWindowlessRoots.get(i);
                    if (maybeParent.getWindowToken() == wparams.token) {
                        windowlessSession = maybeParent.getWindowSession();
                        break;
                    }
                }
            }

            if (windowlessSession == null) {
                root = new ViewRootImpl(view.getContext(), display);
            } else {
                root = new ViewRootImpl(view.getContext(), display,
                        windowlessSession, new WindowlessWindowLayout());
            }

            view.setLayoutParams(wparams);

            mViews.add(view);
            mRoots.add(root);
            mParams.add(wparams);

            // do this last because it fires off messages to start doing things
            try {
                root.setView(view, wparams, panelParentView, userId);
                mWindowViewsListenerGroup.accept(getWindowViews());
            } catch (RuntimeException e) {
                Log.e(TAG, "Couldn't add view: " + view, e);
                final int viewIndex = (index >= 0) ? index : (mViews.size() - 1);
                // BadTokenException or InvalidDisplayException, clean up.
                if (viewIndex >= 0) {
                    removeViewLocked(viewIndex, true);
                }
                throw e;
            }
        }
    }

    public void updateViewLayout(View view, ViewGroup.LayoutParams params) {
        if (view == null) {
            throw new IllegalArgumentException("view must not be null");
        }
        if (!(params instanceof WindowManager.LayoutParams)) {
            throw new IllegalArgumentException("Params must be WindowManager.LayoutParams");
        }

        final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams)params;

        view.setLayoutParams(wparams);

        synchronized (mLock) {
            int index = findViewLocked(view, true);
            ViewRootImpl root = mRoots.get(index);
            mParams.remove(index);
            mParams.add(index, wparams);
            root.setLayoutParams(wparams, false);
        }
    }

    @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
    public void removeView(View view, boolean immediate) {
        if (view == null) {
            throw new IllegalArgumentException("view must not be null");
        }

        synchronized (mLock) {
            int index = findViewLocked(view, true);
            View curView = mRoots.get(index).getView();
            removeViewLocked(index, immediate);
            if (curView == view) {
                return;
            }

            throw new IllegalStateException("Calling with view " + view
                    + " but the ViewAncestor is attached to " + curView);
        }
    }

    /**
     * Remove all roots with specified token.
     *
     * @param token app or window token.
     * @param who name of caller, used in logs.
     * @param what type of caller, used in logs.
     */
    public void closeAll(IBinder token, String who, String what) {
        closeAllExceptView(token, null /* view */, who, what);
    }

    /**
     * Remove all roots with specified token, except maybe one view.
     *
     * @param token app or window token.
     * @param view view that should be should be preserved along with it's root.
     *             Pass null if everything should be removed.
     * @param who name of caller, used in logs.
     * @param what type of caller, used in logs.
     */
    public void closeAllExceptView(IBinder token, View view, String who, String what) {
        synchronized (mLock) {
            int count = mViews.size();
            for (int i = 0; i < count; i++) {
                if ((view == null || mViews.get(i) != view)
                        && (token == null || mParams.get(i).token == token)) {
                    ViewRootImpl root = mRoots.get(i);

                    if (who != null) {
                        WindowLeaked leak = new WindowLeaked(
                                what + " " + who + " has leaked window "
                                        + root.getView() + " that was originally added here");
                        leak.setStackTrace(root.getLocation().getStackTrace());
                        Log.e(TAG, "", leak);
                    }

                    removeViewLocked(i, false);
                }
            }
        }
    }

    private void removeViewLocked(int index, boolean immediate) {
        ViewRootImpl root = mRoots.get(index);
        View view = root.getView();

        if (root != null) {
            root.getImeFocusController().onWindowDismissed();
        }
        boolean deferred = root.die(immediate);
        if (view != null) {
            view.assignParent(null);
            if (deferred) {
                mDyingViews.add(view);
            }
        }
    }

    void doRemoveView(ViewRootImpl root) {
        boolean allViewsRemoved;
        synchronized (mLock) {
            final int index = mRoots.indexOf(root);
            if (index >= 0) {
                mRoots.remove(index);
                mParams.remove(index);
                final View view = mViews.remove(index);
                mDyingViews.remove(view);
            }
            allViewsRemoved = mRoots.isEmpty();
            mWindowViewsListenerGroup.accept(getWindowViews());
        }

        // If we don't have any views anymore in our process, we no longer need the
        // InsetsAnimationThread to save some resources.
        if (allViewsRemoved) {
            InsetsAnimationThread.release();
        }
    }

    private int findViewLocked(View view, boolean required) {
        final int index = mViews.indexOf(view);
        if (required && index < 0) {
            throw new IllegalArgumentException("View=" + view + " not attached to window manager");
        }
        return index;
    }

    @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
    public void trimMemory(int level) {
        ThreadedRenderer.trimMemory(level);
    }

    /** @hide */
    public void trimCaches(@HardwareRenderer.CacheTrimLevel int level) {
        ThreadedRenderer.trimCaches(level);
    }

    public void dumpGfxInfo(FileDescriptor fd, String[] args) {
        FileOutputStream fout = new FileOutputStream(fd);
        PrintWriter pw = new FastPrintWriter(fout);
        try {
            synchronized (mLock) {
                final int count = mViews.size();

                pw.println("Profile data in ms:");

                for (int i = 0; i < count; i++) {
                    ViewRootImpl root = mRoots.get(i);
                    String name = getWindowName(root);
                    pw.printf("\n\t%s (visibility=%d)", name, root.getHostVisibility());

                    ThreadedRenderer renderer =
                            root.getView().mAttachInfo.mThreadedRenderer;
                    if (renderer != null) {
                        renderer.dumpGfxInfo(pw, fd, args);
                    }
                }

                pw.println("\nView hierarchy:\n");

                ViewRootImpl.GfxInfo totals = new ViewRootImpl.GfxInfo();

                for (int i = 0; i < count; i++) {
                    ViewRootImpl root = mRoots.get(i);
                    ViewRootImpl.GfxInfo info = root.getGfxInfo();
                    totals.add(info);

                    String name = getWindowName(root);
                    pw.printf("  %s\n  %d views, %.2f kB of render nodes",
                            name, info.viewCount, info.renderNodeMemoryUsage / 1024.f);
                    pw.printf("\n\n");
                }

                pw.printf("\nTotal %-15s: %d\n", "ViewRootImpl", count);
                pw.printf("Total %-15s: %d\n", "attached Views", totals.viewCount);
                pw.printf("Total %-15s: %.2f kB (used) / %.2f kB (capacity)\n\n", "RenderNode",
                        totals.renderNodeMemoryUsage / 1024.0f,
                        totals.renderNodeMemoryAllocated / 1024.0f);
            }
        } finally {
            pw.flush();
        }
    }

    private static String getWindowName(ViewRootImpl root) {
        return root.mWindowAttributes.getTitle() + "/" +
                root.getClass().getName() + '@' + Integer.toHexString(root.hashCode());
    }

    public void setStoppedState(IBinder token, boolean stopped) {
        ArrayList<ViewRootImpl> nonCurrentThreadRoots = null;
        synchronized (mLock) {
            int count = mViews.size();
            for (int i = count - 1; i >= 0; i--) {
                if (token == null || mParams.get(i).token == token) {
                    ViewRootImpl root = mRoots.get(i);
                    // Client might remove the view by "stopped" event.
                    if (root.mThread == Thread.currentThread()) {
                        root.setWindowStopped(stopped);
                    } else {
                        if (nonCurrentThreadRoots == null) {
                            nonCurrentThreadRoots = new ArrayList<>();
                        }
                        nonCurrentThreadRoots.add(root);
                    }
                    // Recursively forward stopped state to View's attached
                    // to this Window rather than the root application token,
                    // e.g. PopupWindow's.
                    setStoppedState(root.mAttachInfo.mWindowToken, stopped);
                }
            }
        }

        // Update the stopped state synchronously to ensure the surface won't be used after server
        // side has destroyed it. This operation should be outside the lock to avoid any potential
        // paths from setWindowStopped to WindowManagerGlobal which may cause deadlocks.
        if (nonCurrentThreadRoots != null) {
            for (int i = nonCurrentThreadRoots.size() - 1; i >= 0; i--) {
                ViewRootImpl root = nonCurrentThreadRoots.get(i);
                root.mHandler.runWithScissors(() -> root.setWindowStopped(stopped), 0);
            }
        }
    }

    public void reportNewConfiguration(Configuration config) {
        synchronized (mLock) {
            int count = mViews.size();
            config = new Configuration(config);
            for (int i=0; i < count; i++) {
                ViewRootImpl root = mRoots.get(i);
                root.requestUpdateConfiguration(config);
            }
        }
    }

    /** @hide */
    public void changeCanvasOpacity(IBinder token, boolean opaque) {
        if (token == null) {
            return;
        }
        synchronized (mLock) {
            for (int i = mParams.size() - 1; i >= 0; --i) {
                if (mParams.get(i).token == token) {
                    mRoots.get(i).changeCanvasOpacity(opaque);
                    return;
                }
            }
        }
    }

    /** @hide */
    @Nullable
    public SurfaceControl mirrorWallpaperSurface(int displayId) {
        try {
            return getWindowManagerService().mirrorWallpaperSurface(displayId);
        } catch (RemoteException e) {
            throw e.rethrowFromSystemServer();
        }
    }

    /** Registers the listener to the context token and returns the current proposed rotation. */
    public void registerProposedRotationListener(IBinder contextToken, Executor executor,
            IntConsumer listener) {
        ProposedRotationListenerDelegate delegate;
        synchronized (mLock) {
            if (mProposedRotationListenerMap == null) {
                mProposedRotationListenerMap = new WeakHashMap<>(1);
            }
            delegate = mProposedRotationListenerMap.get(contextToken);
            final ProposedRotationListenerDelegate existingDelegate = delegate;
            if (delegate == null) {
                mProposedRotationListenerMap.put(contextToken,
                        delegate = new ProposedRotationListenerDelegate());
            }
            if (!delegate.add(executor, listener)) {
                // Duplicated listener.
                return;
            }
            if (existingDelegate != null) {
                executor.execute(() -> listener.accept(existingDelegate.mLastRotation));
                return;
            }
        }
        try {
            final int currentRotation = getWindowManagerService().registerProposedRotationListener(
                    contextToken, delegate);
            delegate.onRotationChanged(currentRotation);
        } catch (RemoteException e) {
            throw e.rethrowFromSystemServer();
        }
    }

    /** Unregisters the proposed rotation listener of the given token. */
    public void unregisterProposedRotationListener(IBinder contextToken, IntConsumer listener) {
        final ProposedRotationListenerDelegate delegate;
        synchronized (mLock) {
            if (mProposedRotationListenerMap == null) {
                return;
            }
            delegate = mProposedRotationListenerMap.get(contextToken);
            if (delegate == null) {
                return;
            }
            if (delegate.remove(listener)) {
                // The delegate becomes empty.
                mProposedRotationListenerMap.remove(contextToken);
            } else {
                // The delegate still contains other listeners.
                return;
            }
        }
        try {
            getWindowManagerService().removeRotationWatcher(delegate);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    private static class ProposedRotationListenerDelegate extends IRotationWatcher.Stub {
        static class ListenerWrapper {
            final Executor mExecutor;
            final WeakReference<IntConsumer> mListener;

            ListenerWrapper(Executor executor, IntConsumer listener) {
                mExecutor = executor;
                mListener = new WeakReference<>(listener);
            }
        }

        /** The registered listeners. */
        private final ArrayList<ListenerWrapper> mListeners = new ArrayList<>(1);
        /** A thread-safe copy of registered listeners for dispatching events. */
        private volatile ListenerWrapper[] mListenerArray;
        int mLastRotation;

        boolean add(Executor executor, IntConsumer listener) {
            for (int i = mListeners.size() - 1; i >= 0; i--) {
                if (mListeners.get(i).mListener.get() == listener) {
                    // Ignore adding duplicated listener.
                    return false;
                }
            }
            mListeners.add(new ListenerWrapper(executor, listener));
            mListenerArray = mListeners.toArray(new ListenerWrapper[0]);
            return true;
        }

        boolean remove(IntConsumer listener) {
            for (int i = mListeners.size() - 1; i >= 0; i--) {
                if (mListeners.get(i).mListener.get() == listener) {
                    mListeners.remove(i);
                    mListenerArray = mListeners.toArray(new ListenerWrapper[0]);
                    return mListeners.isEmpty();
                }
            }
            return false;
        }

        @Override
        public void onRotationChanged(int rotation) {
            mLastRotation = rotation;
            boolean alive = false;
            for (ListenerWrapper listenerWrapper : mListenerArray) {
                final IntConsumer listener = listenerWrapper.mListener.get();
                if (listener != null) {
                    listenerWrapper.mExecutor.execute(() -> listener.accept(rotation));
                    alive = true;
                }
            }
            if (!alive) {
                // Unregister if there is no strong reference.
                try {
                    getWindowManagerService().removeRotationWatcher(this);
                } catch (RemoteException e) {
                    e.rethrowFromSystemServer();
                }
            }
        }
    }

    public void registerTrustedPresentationListener(@NonNull IBinder window,
            @NonNull TrustedPresentationThresholds thresholds, Executor executor,
            @NonNull Consumer<Boolean> listener) {
        mTrustedPresentationListener.addListener(window, thresholds, listener, executor);
    }

    public void unregisterTrustedPresentationListener(@NonNull Consumer<Boolean> listener) {
        mTrustedPresentationListener.removeListener(listener);
    }

    private static InputChannel createInputChannel(@NonNull IBinder clientToken,
            @NonNull InputTransferToken hostToken, @NonNull SurfaceControl surfaceControl,
            @Nullable InputTransferToken inputTransferToken) {
        InputChannel inputChannel = new InputChannel();
        try {
            // TODO (b/329860681): Use INVALID_DISPLAY for now because the displayId will be
            // selected in  SurfaceFlinger. This should be cleaned up so grantInputChannel doesn't
            // take in a displayId at all
            WindowManagerGlobal.getWindowSession().grantInputChannel(INVALID_DISPLAY,
                    surfaceControl, clientToken, hostToken, 0, 0, TYPE_APPLICATION, 0, null,
                    inputTransferToken, surfaceControl.getName(), inputChannel);
        } catch (RemoteException e) {
            Log.e(TAG, "Failed to create input channel", e);
            e.rethrowAsRuntimeException();
        }
        return inputChannel;
    }

    private static void removeInputChannel(IBinder clientToken) {
        try {
            WindowManagerGlobal.getWindowSession().remove(clientToken);
        } catch (RemoteException e) {
            Log.e(TAG, "Failed to remove input channel", e);
            e.rethrowAsRuntimeException();
        }
    }

    InputTransferToken registerBatchedSurfaceControlInputReceiver(
            @NonNull InputTransferToken hostToken, @NonNull SurfaceControl surfaceControl,
            @NonNull Choreographer choreographer, @NonNull SurfaceControlInputReceiver receiver) {
        IBinder clientToken = new Binder();
        InputTransferToken inputTransferToken = new InputTransferToken();
        InputChannel inputChannel = createInputChannel(clientToken, hostToken,
                surfaceControl, inputTransferToken);

        synchronized (mSurfaceControlInputReceivers) {
            mSurfaceControlInputReceivers.put(surfaceControl.getLayerId(),
                    new SurfaceControlInputReceiverInfo(clientToken,
                            new BatchedInputEventReceiver(inputChannel, choreographer.getLooper(),
                                    choreographer) {
                                @Override
                                public void onInputEvent(InputEvent event) {
                                    boolean handled = receiver.onInputEvent(event);
                                    finishInputEvent(event, handled);
                                }
                            }));
        }
        return inputTransferToken;
    }

    InputTransferToken registerUnbatchedSurfaceControlInputReceiver(
            @NonNull InputTransferToken hostToken, @NonNull SurfaceControl surfaceControl,
            @NonNull Looper looper, @NonNull SurfaceControlInputReceiver receiver) {
        IBinder clientToken = new Binder();
        InputTransferToken inputTransferToken = new InputTransferToken();
        InputChannel inputChannel = createInputChannel(clientToken, hostToken,
                surfaceControl, inputTransferToken);

        synchronized (mSurfaceControlInputReceivers) {
            mSurfaceControlInputReceivers.put(surfaceControl.getLayerId(),
                    new SurfaceControlInputReceiverInfo(clientToken,
                            new InputEventReceiver(inputChannel, looper) {
                                @Override
                                public void onInputEvent(InputEvent event) {
                                    boolean handled = receiver.onInputEvent(event);
                                    finishInputEvent(event, handled);
                                }
                            }));
        }
        return inputTransferToken;
    }

    void unregisterSurfaceControlInputReceiver(@NonNull SurfaceControl surfaceControl) {
        SurfaceControlInputReceiverInfo surfaceControlInputReceiverInfo;
        synchronized (mSurfaceControlInputReceivers) {
            surfaceControlInputReceiverInfo = mSurfaceControlInputReceivers.removeReturnOld(
                    surfaceControl.getLayerId());
        }

        if (surfaceControlInputReceiverInfo == null) {
            Log.w(TAG, "No registered input event receiver with sc: " + surfaceControl);
            return;
        }
        removeInputChannel(surfaceControlInputReceiverInfo.mClientToken);

        surfaceControlInputReceiverInfo.mInputEventReceiver.dispose();
    }

    IBinder getSurfaceControlInputClientToken(@NonNull SurfaceControl surfaceControl) {
        SurfaceControlInputReceiverInfo surfaceControlInputReceiverInfo;
        synchronized (mSurfaceControlInputReceivers) {
            surfaceControlInputReceiverInfo = mSurfaceControlInputReceivers.get(
                    surfaceControl.getLayerId());
        }

        if (surfaceControlInputReceiverInfo == null) {
            Log.w(TAG, "No registered input event receiver with sc: " + surfaceControl);
            return null;
        }
        return surfaceControlInputReceiverInfo.mClientToken;
    }

    boolean transferTouchGesture(@NonNull InputTransferToken transferFromToken,
            @NonNull InputTransferToken transferToToken) {
        try {
            return getWindowManagerService().transferTouchGesture(transferFromToken,
                    transferToToken);
        } catch (RemoteException e) {
            e.rethrowAsRuntimeException();
        }
        return false;
    }

    private final class TrustedPresentationListener extends
            ITrustedPresentationListener.Stub {
        private static int sId = 0;
        private final ArrayMap<Consumer<Boolean>, Pair<Integer, Executor>> mListeners =
                new ArrayMap<>();

        private final Object mTplLock = new Object();

        private void addListener(IBinder window, TrustedPresentationThresholds thresholds,
                Consumer<Boolean> listener, Executor executor) {
            synchronized (mTplLock) {
                if (mListeners.containsKey(listener)) {
                    Log.i(TAG, "Updating listener " + listener + " thresholds to " + thresholds);
                    removeListener(listener);
                }
                int id = sId++;
                mListeners.put(listener, new Pair<>(id, executor));
                try {
                    WindowManagerGlobal.getWindowManagerService()
                            .registerTrustedPresentationListener(window, this, thresholds, id);
                } catch (RemoteException e) {
                    e.rethrowFromSystemServer();
                }
            }
        }

        private void removeListener(Consumer<Boolean> listener) {
            synchronized (mTplLock) {
                var removedListener = mListeners.remove(listener);
                if (removedListener == null) {
                    Log.i(TAG, "listener " + listener + " does not exist.");
                    return;
                }

                try {
                    WindowManagerGlobal.getWindowManagerService()
                            .unregisterTrustedPresentationListener(this, removedListener.first);
                } catch (RemoteException e) {
                    e.rethrowFromSystemServer();
                }
            }
        }

        @Override
        public void onTrustedPresentationChanged(int[] inTrustedStateListenerIds,
                int[] outOfTrustedStateListenerIds) {
            ArrayList<Runnable> firedListeners = new ArrayList<>();
            synchronized (mTplLock) {
                mListeners.forEach((listener, idExecutorPair) -> {
                    final var listenerId =  idExecutorPair.first;
                    final var executor = idExecutorPair.second;
                    for (int id : inTrustedStateListenerIds) {
                        if (listenerId == id) {
                            firedListeners.add(() -> executor.execute(
                                    () -> listener.accept(/*presentationState*/true)));
                        }
                    }
                    for (int id : outOfTrustedStateListenerIds) {
                        if (listenerId == id) {
                            firedListeners.add(() -> executor.execute(
                                    () -> listener.accept(/*presentationState*/false)));
                        }
                    }
                });
            }
            for (int i = 0; i < firedListeners.size(); i++) {
                firedListeners.get(i).run();
            }
        }
    }

    /** @hide */
    public void addWindowlessRoot(ViewRootImpl impl) {
        synchronized (mLock) {
            mWindowlessRoots.add(impl);
        }
    }

    /** @hide */
    public void removeWindowlessRoot(ViewRootImpl impl) {
        synchronized (mLock) {
            mWindowlessRoots.remove(impl);
        }
    }

    public void setRecentsAppBehindSystemBars(boolean behindSystemBars) {
        try {
            getWindowManagerService().setRecentsAppBehindSystemBars(behindSystemBars);
        } catch (RemoteException e) {
            throw e.rethrowFromSystemServer();
        }
    }

    private static class SurfaceControlInputReceiverInfo {
        final IBinder mClientToken;
        final InputEventReceiver mInputEventReceiver;

        private SurfaceControlInputReceiverInfo(IBinder clientToken,
                InputEventReceiver inputEventReceiver) {
            mClientToken = clientToken;
            mInputEventReceiver = inputEventReceiver;
        }
    }
}

final class WindowLeaked extends AndroidRuntimeException {
    @UnsupportedAppUsage
    public WindowLeaked(String msg) {
        super(msg);
    }
}