content: /*
   * Copyright (C) 2011 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 com.android.server.wm;
  
  import static android.view.WindowManager.LayoutParams.FLAG_SHOW_WALLPAPER;
  import static android.view.WindowManager.LayoutParams.TYPE_NAVIGATION_BAR;
  
  import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_ADD_REMOVE;
  import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_FOCUS;
  import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_WINDOW_MOVEMENT;
  import static com.android.server.wm.WindowManagerDebugConfig.TAG_WITH_CLASS_NAME;
  import static com.android.server.wm.WindowManagerDebugConfig.TAG_WM;
  import static com.android.server.wm.WindowManagerService.UPDATE_FOCUS_NORMAL;
  import static com.android.server.wm.WindowTokenProto.HASH_CODE;
  import static com.android.server.wm.WindowTokenProto.HIDDEN;
  import static com.android.server.wm.WindowTokenProto.PAUSED;
  import static com.android.server.wm.WindowTokenProto.WAITING_TO_SHOW;
  import static com.android.server.wm.WindowTokenProto.WINDOWS;
  import static com.android.server.wm.WindowTokenProto.WINDOW_CONTAINER;
  
  import android.annotation.CallSuper;
  import android.os.Debug;
  import android.os.IBinder;
  import android.util.Slog;
  import android.util.proto.ProtoOutputStream;
  
  import java.io.PrintWriter;
  import java.util.Comparator;
  
  /**
   * Container of a set of related windows in the window manager. Often this is an AppWindowToken,
   * which is the handle for an Activity that it uses to display windows. For nested windows, there is
   * a WindowToken created for the parent window to manage its children.
   */
  class WindowToken extends WindowContainer<WindowState> {
      private static final String TAG = TAG_WITH_CLASS_NAME ? "WindowToken" : TAG_WM;
  
      // The actual token.
      final IBinder token;
  
      // The type of window this token is for, as per WindowManager.LayoutParams.
      final int windowType;
  
      /** {@code true} if this holds the rounded corner overlay */
      final boolean mRoundedCornerOverlay;
  
      // Set if this token was explicitly added by a client, so should
      // persist (not be removed) when all windows are removed.
      boolean mPersistOnEmpty;
  
      // For printing.
      String stringName;
  
      // Is key dispatching paused for this token?
      boolean paused = false;
  
      // Should this token's windows be hidden?
      private boolean mHidden;
  
      // Temporary for finding which tokens no longer have visible windows.
      boolean hasVisible;
  
      // Set to true when this token is in a pending transaction where it
      // will be shown.
      boolean waitingToShow;
  
      // Set to true when this token is in a pending transaction where its
      // windows will be put to the bottom of the list.
      boolean sendingToBottom;
  
      /** The owner has {@link android.Manifest.permission#MANAGE_APP_TOKENS} */
      final boolean mOwnerCanManageAppTokens;
  
      /**
       * Compares two child window of this token and returns -1 if the first is lesser than the
       * second in terms of z-order and 1 otherwise.
       */
      private final Comparator<WindowState> mWindowComparator =
              (WindowState newWindow, WindowState existingWindow) -> {
          final WindowToken token = WindowToken.this;
          if (newWindow.mToken != token) {
              throw new IllegalArgumentException("newWindow=" + newWindow
                      + " is not a child of token=" + token);
          }
  
          if (existingWindow.mToken != token) {
              throw new IllegalArgumentException("existingWindow=" + existingWindow
                      + " is not a child of token=" + token);
          }
  
          return isFirstChildWindowGreaterThanSecond(newWindow, existingWindow) ? 1 : -1;
      };
  
      WindowToken(WindowManagerService service, IBinder _token, int type, boolean persistOnEmpty,
              DisplayContent dc, boolean ownerCanManageAppTokens) {
          this(service, _token, type, persistOnEmpty, dc, ownerCanManageAppTokens,
                  false /* roundedCornersOverlay */);
      }
  
      WindowToken(WindowManagerService service, IBinder _token, int type, boolean persistOnEmpty,
              DisplayContent dc, boolean ownerCanManageAppTokens, boolean roundedCornerOverlay) {
          super(service);
          token = _token;
          windowType = type;
          mPersistOnEmpty = persistOnEmpty;
          mOwnerCanManageAppTokens = ownerCanManageAppTokens;
          mRoundedCornerOverlay = roundedCornerOverlay;
          onDisplayChanged(dc);
      }
  
      void setHidden(boolean hidden) {
          if (hidden != mHidden) {
              mHidden = hidden;
          }
      }
  
      boolean isHidden() {
          return mHidden;
      }
  
      void removeAllWindowsIfPossible() {
          for (int i = mChildren.size() - 1; i >= 0; --i) {
              final WindowState win = mChildren.get(i);
              if (DEBUG_WINDOW_MOVEMENT) Slog.w(TAG_WM,
                      "removeAllWindowsIfPossible: removing win=" + win);
              win.removeIfPossible();
          }
      }
  
      void setExiting() {
          if (mChildren.size() == 0) {
              super.removeImmediately();
              return;
          }
  
          // This token is exiting, so allow it to be removed when it no longer contains any windows.
          mPersistOnEmpty = false;
  
          if (mHidden) {
              return;
          }
  
          final int count = mChildren.size();
          boolean changed = false;
          boolean delayed = false;
  
          for (int i = 0; i < count; i++) {
              final WindowState win = mChildren.get(i);
              if (win.isAnimating()) {
                  delayed = true;
              }
              changed |= win.onSetAppExiting();
          }
  
          setHidden(true);
  
          if (changed) {
              mWmService.mWindowPlacerLocked.performSurfacePlacement();
              mWmService.updateFocusedWindowLocked(UPDATE_FOCUS_NORMAL, false /*updateInputWindows*/);
          }
  
          if (delayed) {
              mDisplayContent.mExitingTokens.add(this);
          }
      }
  
      /**
       * @return The scale for applications running in compatibility mode. Multiply the size in the
       *         application by this scale will be the size in the screen.
       */
      float getSizeCompatScale() {
          return mDisplayContent.mCompatibleScreenScale;
      }
  
      /**
       * Returns true if the new window is considered greater than the existing window in terms of
       * z-order.
       */
      protected boolean isFirstChildWindowGreaterThanSecond(WindowState newWindow,
              WindowState existingWindow) {
          // New window is considered greater if it has a higher or equal base layer.
          return newWindow.mBaseLayer >= existingWindow.mBaseLayer;
      }
  
      void addWindow(final WindowState win) {
          if (DEBUG_FOCUS) Slog.d(TAG_WM,
                  "addWindow: win=" + win + " Callers=" + Debug.getCallers(5));
  
          if (win.isChildWindow()) {
              // Child windows are added to their parent windows.
              return;
          }
          if (!mChildren.contains(win)) {
              if (DEBUG_ADD_REMOVE) Slog.v(TAG_WM, "Adding " + win + " to " + this);
              addChild(win, mWindowComparator);
              mWmService.mWindowsChanged = true;
              // TODO: Should we also be setting layout needed here and other places?
          }
      }
  
      /** Returns true if the token windows list is empty. */
      boolean isEmpty() {
          return mChildren.isEmpty();
      }
  
      WindowState getReplacingWindow() {
          for (int i = mChildren.size() - 1; i >= 0; i--) {
              final WindowState win = mChildren.get(i);
              final WindowState replacing = win.getReplacingWindow();
              if (replacing != null) {
                  return replacing;
              }
          }
          return null;
      }
  
      /** Return true if this token has a window that wants the wallpaper displayed behind it. */
      boolean windowsCanBeWallpaperTarget() {
          for (int j = mChildren.size() - 1; j >= 0; j--) {
              final WindowState w = mChildren.get(j);
              if ((w.mAttrs.flags & FLAG_SHOW_WALLPAPER) != 0) {
                  return true;
              }
          }
  
          return false;
      }
  
      AppWindowToken asAppWindowToken() {
          // TODO: Not sure if this is the best way to handle this vs. using instanceof and casting.
          // I am not an app window token!
          return null;
      }
  
      @Override
      void removeImmediately() {
          if (mDisplayContent != null) {
              mDisplayContent.removeWindowToken(token);
          }
          // Needs to occur after the token is removed from the display above to avoid attempt at
          // duplicate removal of this window container from it's parent.
          super.removeImmediately();
      }
  
      @Override
      void onDisplayChanged(DisplayContent dc) {
          dc.reParentWindowToken(this);
  
          // TODO(b/36740756): One day this should perhaps be hooked
          // up with goodToGo, so we don't move a window
          // to another display before the window behind
          // it is ready.
  
          super.onDisplayChanged(dc);
      }
  
      @CallSuper
      @Override
      public void writeToProto(ProtoOutputStream proto, long fieldId,
              @WindowTraceLogLevel int logLevel) {
          if (logLevel == WindowTraceLogLevel.CRITICAL && !isVisible()) {
              return;
          }
  
          final long token = proto.start(fieldId);
          super.writeToProto(proto, WINDOW_CONTAINER, logLevel);
          proto.write(HASH_CODE, System.identityHashCode(this));
          for (int i = 0; i < mChildren.size(); i++) {
              final WindowState w = mChildren.get(i);
              w.writeToProto(proto, WINDOWS, logLevel);
          }
          proto.write(HIDDEN, mHidden);
          proto.write(WAITING_TO_SHOW, waitingToShow);
          proto.write(PAUSED, paused);
          proto.end(token);
      }
  
      void dump(PrintWriter pw, String prefix, boolean dumpAll) {
          super.dump(pw, prefix, dumpAll);
          pw.print(prefix); pw.print("windows="); pw.println(mChildren);
          pw.print(prefix); pw.print("windowType="); pw.print(windowType);
                  pw.print(" hidden="); pw.print(mHidden);
                  pw.print(" hasVisible="); pw.println(hasVisible);
          if (waitingToShow || sendingToBottom) {
              pw.print(prefix); pw.print("waitingToShow="); pw.print(waitingToShow);
                      pw.print(" sendingToBottom="); pw.print(sendingToBottom);
          }
      }
  
      @Override
      public String toString() {
          if (stringName == null) {
              StringBuilder sb = new StringBuilder();
              sb.append("WindowToken{");
              sb.append(Integer.toHexString(System.identityHashCode(this)));
              sb.append(" "); sb.append(token); sb.append('}');
              stringName = sb.toString();
          }
          return stringName;
      }
  
      @Override
      String getName() {
          return toString();
      }
  
      boolean okToDisplay() {
          return mDisplayContent != null && mDisplayContent.okToDisplay();
      }
  
      boolean okToAnimate() {
          return mDisplayContent != null && mDisplayContent.okToAnimate();
      }
  
      /**
       * Return whether windows from this token can layer above the
       * system bars, or in other words extend outside of the "Decor Frame"
       */
      boolean canLayerAboveSystemBars() {
          int layer = mWmService.mPolicy.getWindowLayerFromTypeLw(windowType,
                  mOwnerCanManageAppTokens);
          int navLayer = mWmService.mPolicy.getWindowLayerFromTypeLw(TYPE_NAVIGATION_BAR,
                  mOwnerCanManageAppTokens);
          return mOwnerCanManageAppTokens && (layer > navLayer);
      }
  }
  