content: /*
   * 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 com.android.server.display;
  
  import android.graphics.Rect;
  import android.hardware.display.DisplayManagerInternal;
  import android.view.Display;
  import android.view.DisplayInfo;
  import android.view.Surface;
  import android.view.SurfaceControl;
  
  import com.android.server.wm.utils.InsetUtils;
  
  import java.io.PrintWriter;
  import java.util.Arrays;
  import java.util.List;
  import java.util.Objects;
  
  /**
   * Describes how a logical display is configured.
   * <p>
   * At this time, we only support logical displays that are coupled to a particular
   * primary display device from which the logical display derives its basic properties
   * such as its size, density and refresh rate.
   * </p><p>
   * A logical display may be mirrored onto multiple display devices in addition to its
   * primary display device.  Note that the contents of a logical display may not
   * always be visible, even on its primary display device, such as in the case where
   * the primary display device is currently mirroring content from a different
   * logical display.
   * </p><p>
   * This object is designed to encapsulate as much of the policy of logical
   * displays as possible.  The idea is to make it easy to implement new kinds of
   * logical displays mostly by making local changes to this class.
   * </p><p>
   * Note: The display manager architecture does not actually require logical displays
   * to be associated with any individual display device.  Logical displays and
   * display devices are orthogonal concepts.  Some mapping will exist between
   * logical displays and display devices but it can be many-to-many and
   * and some might have no relation at all.
   * </p><p>
   * Logical displays are guarded by the {@link DisplayManagerService.SyncRoot} lock.
   * </p>
   */
  final class LogicalDisplay {
      private final DisplayInfo mBaseDisplayInfo = new DisplayInfo();
  
      // The layer stack we use when the display has been blanked to prevent any
      // of its content from appearing.
      private static final int BLANK_LAYER_STACK = -1;
  
      private final int mDisplayId;
      private final int mLayerStack;
      /**
       * Override information set by the window manager. Will be reported instead of {@link #mInfo}
       * if not null.
       * @see #setDisplayInfoOverrideFromWindowManagerLocked(DisplayInfo)
       * @see #getDisplayInfoLocked()
       */
      private DisplayInfo mOverrideDisplayInfo;
      /**
       * Current display info. Initialized with {@link #mBaseDisplayInfo}. Set to {@code null} if
       * needs to be updated.
       * @see #getDisplayInfoLocked()
       */
      private DisplayInfo mInfo;
  
      // The display device that this logical display is based on and which
      // determines the base metrics that it uses.
      private DisplayDevice mPrimaryDisplayDevice;
      private DisplayDeviceInfo mPrimaryDisplayDeviceInfo;
  
      // True if the logical display has unique content.
      private boolean mHasContent;
  
      private int[] mAllowedDisplayModes = new int[0];
      private int mRequestedColorMode;
  
      // The display offsets to apply to the display projection.
      private int mDisplayOffsetX;
      private int mDisplayOffsetY;
  
      /**
       * {@code true} if display scaling is disabled, or {@code false} if the default scaling mode
       * is used.
       * @see #isDisplayScalingDisabled()
       * @see #setDisplayScalingDisabledLocked(boolean)
       */
      private boolean mDisplayScalingDisabled;
  
      // Temporary rectangle used when needed.
      private final Rect mTempLayerStackRect = new Rect();
      private final Rect mTempDisplayRect = new Rect();
  
      public LogicalDisplay(int displayId, int layerStack, DisplayDevice primaryDisplayDevice) {
          mDisplayId = displayId;
          mLayerStack = layerStack;
          mPrimaryDisplayDevice = primaryDisplayDevice;
      }
  
      /**
       * Gets the logical display id of this logical display.
       *
       * @return The logical display id.
       */
      public int getDisplayIdLocked() {
          return mDisplayId;
      }
  
      /**
       * Gets the primary display device associated with this logical display.
       *
       * @return The primary display device.
       */
      public DisplayDevice getPrimaryDisplayDeviceLocked() {
          return mPrimaryDisplayDevice;
      }
  
      /**
       * Gets information about the logical display.
       *
       * @return The device info, which should be treated as immutable by the caller.
       * The logical display should allocate a new display info object whenever
       * the data changes.
       */
      public DisplayInfo getDisplayInfoLocked() {
          if (mInfo == null) {
              mInfo = new DisplayInfo();
              mInfo.copyFrom(mBaseDisplayInfo);
              if (mOverrideDisplayInfo != null) {
                  mInfo.appWidth = mOverrideDisplayInfo.appWidth;
                  mInfo.appHeight = mOverrideDisplayInfo.appHeight;
                  mInfo.smallestNominalAppWidth = mOverrideDisplayInfo.smallestNominalAppWidth;
                  mInfo.smallestNominalAppHeight = mOverrideDisplayInfo.smallestNominalAppHeight;
                  mInfo.largestNominalAppWidth = mOverrideDisplayInfo.largestNominalAppWidth;
                  mInfo.largestNominalAppHeight = mOverrideDisplayInfo.largestNominalAppHeight;
                  mInfo.logicalWidth = mOverrideDisplayInfo.logicalWidth;
                  mInfo.logicalHeight = mOverrideDisplayInfo.logicalHeight;
                  mInfo.overscanLeft = mOverrideDisplayInfo.overscanLeft;
                  mInfo.overscanTop = mOverrideDisplayInfo.overscanTop;
                  mInfo.overscanRight = mOverrideDisplayInfo.overscanRight;
                  mInfo.overscanBottom = mOverrideDisplayInfo.overscanBottom;
                  mInfo.rotation = mOverrideDisplayInfo.rotation;
                  mInfo.displayCutout = mOverrideDisplayInfo.displayCutout;
                  mInfo.logicalDensityDpi = mOverrideDisplayInfo.logicalDensityDpi;
                  mInfo.physicalXDpi = mOverrideDisplayInfo.physicalXDpi;
                  mInfo.physicalYDpi = mOverrideDisplayInfo.physicalYDpi;
              }
          }
          return mInfo;
      }
  
      /**
       * @see DisplayManagerInternal#getNonOverrideDisplayInfo(int, DisplayInfo)
       */
      void getNonOverrideDisplayInfoLocked(DisplayInfo outInfo) {
          outInfo.copyFrom(mBaseDisplayInfo);
      }
  
      /**
       * Sets overridden logical display information from the window manager.
       * This method can be used to adjust application insets, rotation, and other
       * properties that the window manager takes care of.
       *
       * @param info The logical display information, may be null.
       */
      public boolean setDisplayInfoOverrideFromWindowManagerLocked(DisplayInfo info) {
          if (info != null) {
              if (mOverrideDisplayInfo == null) {
                  mOverrideDisplayInfo = new DisplayInfo(info);
                  mInfo = null;
                  return true;
              }
              if (!mOverrideDisplayInfo.equals(info)) {
                  mOverrideDisplayInfo.copyFrom(info);
                  mInfo = null;
                  return true;
              }
          } else if (mOverrideDisplayInfo != null) {
              mOverrideDisplayInfo = null;
              mInfo = null;
              return true;
          }
          return false;
      }
  
      /**
       * Returns true if the logical display is in a valid state.
       * This method should be checked after calling {@link #updateLocked} to handle the
       * case where a logical display should be removed because all of its associated
       * display devices are gone or if it is otherwise no longer needed.
       *
       * @return True if the logical display is still valid.
       */
      public boolean isValidLocked() {
          return mPrimaryDisplayDevice != null;
      }
  
      /**
       * Updates the state of the logical display based on the available display devices.
       * The logical display might become invalid if it is attached to a display device
       * that no longer exists.
       *
       * @param devices The list of all connected display devices.
       */
      public void updateLocked(List<DisplayDevice> devices) {
          // Nothing to update if already invalid.
          if (mPrimaryDisplayDevice == null) {
              return;
          }
  
          // Check whether logical display has become invalid.
          if (!devices.contains(mPrimaryDisplayDevice)) {
              mPrimaryDisplayDevice = null;
              return;
          }
  
          // Bootstrap the logical display using its associated primary physical display.
          // We might use more elaborate configurations later.  It's possible that the
          // configuration of several physical displays might be used to determine the
          // logical display that they are sharing.  (eg. Adjust size for pixel-perfect
          // mirroring over HDMI.)
          DisplayDeviceInfo deviceInfo = mPrimaryDisplayDevice.getDisplayDeviceInfoLocked();
          if (!Objects.equals(mPrimaryDisplayDeviceInfo, deviceInfo)) {
              mBaseDisplayInfo.layerStack = mLayerStack;
              mBaseDisplayInfo.flags = 0;
              if ((deviceInfo.flags & DisplayDeviceInfo.FLAG_SUPPORTS_PROTECTED_BUFFERS) != 0) {
                  mBaseDisplayInfo.flags |= Display.FLAG_SUPPORTS_PROTECTED_BUFFERS;
              }
              if ((deviceInfo.flags & DisplayDeviceInfo.FLAG_SECURE) != 0) {
                  mBaseDisplayInfo.flags |= Display.FLAG_SECURE;
              }
              if ((deviceInfo.flags & DisplayDeviceInfo.FLAG_PRIVATE) != 0) {
                  mBaseDisplayInfo.flags |= Display.FLAG_PRIVATE;
                  // For private displays by default content is destroyed on removal.
                  mBaseDisplayInfo.removeMode = Display.REMOVE_MODE_DESTROY_CONTENT;
              }
              if ((deviceInfo.flags & DisplayDeviceInfo.FLAG_DESTROY_CONTENT_ON_REMOVAL) != 0) {
                  mBaseDisplayInfo.removeMode = Display.REMOVE_MODE_DESTROY_CONTENT;
              }
              if ((deviceInfo.flags & DisplayDeviceInfo.FLAG_PRESENTATION) != 0) {
                  mBaseDisplayInfo.flags |= Display.FLAG_PRESENTATION;
              }
              if ((deviceInfo.flags & DisplayDeviceInfo.FLAG_ROUND) != 0) {
                  mBaseDisplayInfo.flags |= Display.FLAG_ROUND;
              }
              if ((deviceInfo.flags & DisplayDeviceInfo.FLAG_CAN_SHOW_WITH_INSECURE_KEYGUARD) != 0) {
                  mBaseDisplayInfo.flags |= Display.FLAG_CAN_SHOW_WITH_INSECURE_KEYGUARD;
              }
              if ((deviceInfo.flags & DisplayDeviceInfo.FLAG_SHOULD_SHOW_SYSTEM_DECORATIONS) != 0) {
                  mBaseDisplayInfo.flags |= Display.FLAG_SHOULD_SHOW_SYSTEM_DECORATIONS;
              }
              Rect maskingInsets = getMaskingInsets(deviceInfo);
              int maskedWidth = deviceInfo.width - maskingInsets.left - maskingInsets.right;
              int maskedHeight = deviceInfo.height - maskingInsets.top - maskingInsets.bottom;
  
              mBaseDisplayInfo.type = deviceInfo.type;
              mBaseDisplayInfo.address = deviceInfo.address;
              mBaseDisplayInfo.name = deviceInfo.name;
              mBaseDisplayInfo.uniqueId = deviceInfo.uniqueId;
              mBaseDisplayInfo.appWidth = maskedWidth;
              mBaseDisplayInfo.appHeight = maskedHeight;
              mBaseDisplayInfo.logicalWidth = maskedWidth;
              mBaseDisplayInfo.logicalHeight = maskedHeight;
              mBaseDisplayInfo.rotation = Surface.ROTATION_0;
              mBaseDisplayInfo.modeId = deviceInfo.modeId;
              mBaseDisplayInfo.defaultModeId = deviceInfo.defaultModeId;
              mBaseDisplayInfo.supportedModes = Arrays.copyOf(
                      deviceInfo.supportedModes, deviceInfo.supportedModes.length);
              mBaseDisplayInfo.colorMode = deviceInfo.colorMode;
              mBaseDisplayInfo.supportedColorModes = Arrays.copyOf(
                      deviceInfo.supportedColorModes,
                      deviceInfo.supportedColorModes.length);
              mBaseDisplayInfo.hdrCapabilities = deviceInfo.hdrCapabilities;
              mBaseDisplayInfo.logicalDensityDpi = deviceInfo.densityDpi;
              mBaseDisplayInfo.physicalXDpi = deviceInfo.xDpi;
              mBaseDisplayInfo.physicalYDpi = deviceInfo.yDpi;
              mBaseDisplayInfo.appVsyncOffsetNanos = deviceInfo.appVsyncOffsetNanos;
              mBaseDisplayInfo.presentationDeadlineNanos = deviceInfo.presentationDeadlineNanos;
              mBaseDisplayInfo.state = deviceInfo.state;
              mBaseDisplayInfo.smallestNominalAppWidth = maskedWidth;
              mBaseDisplayInfo.smallestNominalAppHeight = maskedHeight;
              mBaseDisplayInfo.largestNominalAppWidth = maskedWidth;
              mBaseDisplayInfo.largestNominalAppHeight = maskedHeight;
              mBaseDisplayInfo.ownerUid = deviceInfo.ownerUid;
              mBaseDisplayInfo.ownerPackageName = deviceInfo.ownerPackageName;
              boolean maskCutout =
                      (deviceInfo.flags & DisplayDeviceInfo.FLAG_MASK_DISPLAY_CUTOUT) != 0;
              mBaseDisplayInfo.displayCutout = maskCutout ? null : deviceInfo.displayCutout;
              mBaseDisplayInfo.displayId = mDisplayId;
  
              mPrimaryDisplayDeviceInfo = deviceInfo;
              mInfo = null;
          }
      }
  
      /**
       * Return the insets currently applied to the display.
       *
       * Note that the base DisplayInfo already takes these insets into account, so if you want to
       * find out the <b>true</b> size of the display, you need to add them back to the logical
       * dimensions.
       */
      public Rect getInsets() {
          return getMaskingInsets(mPrimaryDisplayDeviceInfo);
      }
  
      /**
       * Returns insets in ROTATION_0 for areas that are masked.
       */
      private static Rect getMaskingInsets(DisplayDeviceInfo deviceInfo) {
          boolean maskCutout = (deviceInfo.flags & DisplayDeviceInfo.FLAG_MASK_DISPLAY_CUTOUT) != 0;
          if (maskCutout && deviceInfo.displayCutout != null) {
              return deviceInfo.displayCutout.getSafeInsets();
          } else {
              return new Rect();
          }
      }
  
      /**
       * Applies the layer stack and transformation to the given display device
       * so that it shows the contents of this logical display.
       *
       * We know that the given display device is only ever showing the contents of
       * a single logical display, so this method is expected to blow away all of its
       * transformation properties to make it happen regardless of what the
       * display device was previously showing.
       *
       * The caller must have an open Surface transaction.
       *
       * The display device may not be the primary display device, in the case
       * where the display is being mirrored.
       *
       * @param device The display device to modify.
       * @param isBlanked True if the device is being blanked.
       */
      public void configureDisplayLocked(SurfaceControl.Transaction t,
              DisplayDevice device,
              boolean isBlanked) {
          // Set the layer stack.
          device.setLayerStackLocked(t, isBlanked ? BLANK_LAYER_STACK : mLayerStack);
  
          // Set the color mode and allowed display mode.
          if (device == mPrimaryDisplayDevice) {
              device.setAllowedDisplayModesLocked(mAllowedDisplayModes);
              device.setRequestedColorModeLocked(mRequestedColorMode);
          } else {
              // Reset to default for non primary displays
              device.setAllowedDisplayModesLocked(new int[] {0});
              device.setRequestedColorModeLocked(0);
          }
  
          // Only grab the display info now as it may have been changed based on the requests above.
          final DisplayInfo displayInfo = getDisplayInfoLocked();
          final DisplayDeviceInfo displayDeviceInfo = device.getDisplayDeviceInfoLocked();
  
          // Set the viewport.
          // This is the area of the logical display that we intend to show on the
          // display device.  For now, it is always the full size of the logical display.
          mTempLayerStackRect.set(0, 0, displayInfo.logicalWidth, displayInfo.logicalHeight);
  
          // Set the orientation.
          // The orientation specifies how the physical coordinate system of the display
          // is rotated when the contents of the logical display are rendered.
          int orientation = Surface.ROTATION_0;
          if ((displayDeviceInfo.flags & DisplayDeviceInfo.FLAG_ROTATES_WITH_CONTENT) != 0) {
              orientation = displayInfo.rotation;
          }
  
          // Apply the physical rotation of the display device itself.
          orientation = (orientation + displayDeviceInfo.rotation) % 4;
  
          // Set the frame.
          // The frame specifies the rotated physical coordinates into which the viewport
          // is mapped.  We need to take care to preserve the aspect ratio of the viewport.
          // Currently we maximize the area to fill the display, but we could try to be
          // more clever and match resolutions.
          boolean rotated = (orientation == Surface.ROTATION_90
                  || orientation == Surface.ROTATION_270);
          int physWidth = rotated ? displayDeviceInfo.height : displayDeviceInfo.width;
          int physHeight = rotated ? displayDeviceInfo.width : displayDeviceInfo.height;
  
          Rect maskingInsets = getMaskingInsets(displayDeviceInfo);
          InsetUtils.rotateInsets(maskingInsets, orientation);
          // Don't consider the masked area as available when calculating the scaling below.
          physWidth -= maskingInsets.left + maskingInsets.right;
          physHeight -= maskingInsets.top + maskingInsets.bottom;
  
          // Determine whether the width or height is more constrained to be scaled.
          //    physWidth / displayInfo.logicalWidth    => letter box
          // or physHeight / displayInfo.logicalHeight  => pillar box
          //
          // We avoid a division (and possible floating point imprecision) here by
          // multiplying the fractions by the product of their denominators before
          // comparing them.
          int displayRectWidth, displayRectHeight;
          if ((displayInfo.flags & Display.FLAG_SCALING_DISABLED) != 0 || mDisplayScalingDisabled) {
              displayRectWidth = displayInfo.logicalWidth;
              displayRectHeight = displayInfo.logicalHeight;
          } else if (physWidth * displayInfo.logicalHeight
                  < physHeight * displayInfo.logicalWidth) {
              // Letter box.
              displayRectWidth = physWidth;
              displayRectHeight = displayInfo.logicalHeight * physWidth / displayInfo.logicalWidth;
          } else {
              // Pillar box.
              displayRectWidth = displayInfo.logicalWidth * physHeight / displayInfo.logicalHeight;
              displayRectHeight = physHeight;
          }
          int displayRectTop = (physHeight - displayRectHeight) / 2;
          int displayRectLeft = (physWidth - displayRectWidth) / 2;
          mTempDisplayRect.set(displayRectLeft, displayRectTop,
                  displayRectLeft + displayRectWidth, displayRectTop + displayRectHeight);
  
          // Now add back the offset for the masked area.
          mTempDisplayRect.offset(maskingInsets.left, maskingInsets.top);
  
          if (orientation == Surface.ROTATION_0) {
              mTempDisplayRect.offset(mDisplayOffsetX, mDisplayOffsetY);
          } else if (orientation == Surface.ROTATION_90) {
              mTempDisplayRect.offset(mDisplayOffsetY, -mDisplayOffsetX);
          } else if (orientation == Surface.ROTATION_180) {
              mTempDisplayRect.offset(-mDisplayOffsetX, -mDisplayOffsetY);
          } else {  // Surface.ROTATION_270
              mTempDisplayRect.offset(-mDisplayOffsetY, mDisplayOffsetX);
          }
          device.setProjectionLocked(t, orientation, mTempLayerStackRect, mTempDisplayRect);
      }
  
      /**
       * Returns true if the logical display has unique content.
       * <p>
       * If the display has unique content then we will try to ensure that it is
       * visible on at least its primary display device.  Otherwise we will ignore the
       * logical display and perhaps show mirrored content on the primary display device.
       * </p>
       *
       * @return True if the display has unique content.
       */
      public boolean hasContentLocked() {
          return mHasContent;
      }
  
      /**
       * Sets whether the logical display has unique content.
       *
       * @param hasContent True if the display has unique content.
       */
      public void setHasContentLocked(boolean hasContent) {
          mHasContent = hasContent;
      }
  
      /**
       * Sets the display modes the system is free to switch between.
       */
      public void setAllowedDisplayModesLocked(int[] modes) {
          mAllowedDisplayModes = modes;
      }
  
      /**
       * Returns the display modes the system is free to switch between.
       */
      public int[] getAllowedDisplayModesLocked() {
          return mAllowedDisplayModes;
      }
  
      /**
       * Requests the given color mode.
       */
      public void setRequestedColorModeLocked(int colorMode) {
          mRequestedColorMode = colorMode;
      }
  
      /** Returns the pending requested color mode. */
      public int getRequestedColorModeLocked() {
          return mRequestedColorMode;
      }
  
      /**
       * Gets the burn-in offset in X.
       */
      public int getDisplayOffsetXLocked() {
          return mDisplayOffsetX;
      }
  
      /**
       * Gets the burn-in offset in Y.
       */
      public int getDisplayOffsetYLocked() {
          return mDisplayOffsetY;
      }
  
      /**
       * Sets the burn-in offsets.
       */
      public void setDisplayOffsetsLocked(int x, int y) {
          mDisplayOffsetX = x;
          mDisplayOffsetY = y;
      }
  
      /**
       * @return {@code true} if display scaling is disabled, or {@code false} if the default scaling
       * mode is used.
       */
      public boolean isDisplayScalingDisabled() {
          return mDisplayScalingDisabled;
      }
  
      /**
       * Disables scaling for a display.
       *
       * @param disableScaling {@code true} to disable scaling,
       * {@code false} to use the default scaling behavior of the logical display.
       */
      public void setDisplayScalingDisabledLocked(boolean disableScaling) {
          mDisplayScalingDisabled = disableScaling;
      }
  
      public void dumpLocked(PrintWriter pw) {
          pw.println("mDisplayId=" + mDisplayId);
          pw.println("mLayerStack=" + mLayerStack);
          pw.println("mHasContent=" + mHasContent);
          pw.println("mAllowedDisplayModes=" + Arrays.toString(mAllowedDisplayModes));
          pw.println("mRequestedColorMode=" + mRequestedColorMode);
          pw.println("mDisplayOffset=(" + mDisplayOffsetX + ", " + mDisplayOffsetY + ")");
          pw.println("mDisplayScalingDisabled=" + mDisplayScalingDisabled);
          pw.println("mPrimaryDisplayDevice=" + (mPrimaryDisplayDevice != null ?
                  mPrimaryDisplayDevice.getNameLocked() : "null"));
          pw.println("mBaseDisplayInfo=" + mBaseDisplayInfo);
          pw.println("mOverrideDisplayInfo=" + mOverrideDisplayInfo);
      }
  }
  