| /* |
| * 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.hardware.display.DisplayViewport; |
| import android.util.DisplayMetrics; |
| import android.view.Display; |
| import android.view.DisplayCutout; |
| import android.view.Surface; |
| |
| import java.util.Arrays; |
| import java.util.Objects; |
| |
| /** |
| * Describes the characteristics of a physical display device. |
| */ |
| final class DisplayDeviceInfo { |
| /** |
| * Flag: Indicates that this display device should be considered the default display |
| * device of the system. |
| */ |
| public static final int FLAG_DEFAULT_DISPLAY = 1 << 0; |
| |
| /** |
| * Flag: Indicates that the orientation of this display device is coupled to the |
| * rotation of its associated logical display. |
| * <p> |
| * This flag should be applied to the default display to indicate that the user |
| * physically rotates the display when content is presented in a different orientation. |
| * The display manager will apply a coordinate transformation assuming that the |
| * physical orientation of the display matches the logical orientation of its content. |
| * </p><p> |
| * The flag should not be set when the display device is mounted in a fixed orientation |
| * such as on a desk. The display manager will apply a coordinate transformation |
| * such as a scale and translation to letterbox or pillarbox format under the |
| * assumption that the physical orientation of the display is invariant. |
| * </p> |
| */ |
| public static final int FLAG_ROTATES_WITH_CONTENT = 1 << 1; |
| |
| /** |
| * Flag: Indicates that this display device has secure video output, such as HDCP. |
| */ |
| public static final int FLAG_SECURE = 1 << 2; |
| |
| /** |
| * Flag: Indicates that this display device supports compositing |
| * from gralloc protected buffers. |
| */ |
| public static final int FLAG_SUPPORTS_PROTECTED_BUFFERS = 1 << 3; |
| |
| /** |
| * Flag: Indicates that the display device is owned by a particular application |
| * and that no other application should be able to interact with it. |
| * Should typically be used together with {@link #FLAG_OWN_CONTENT_ONLY}. |
| */ |
| public static final int FLAG_PRIVATE = 1 << 4; |
| |
| /** |
| * Flag: Indicates that the display device is not blanked automatically by |
| * the power manager. |
| */ |
| public static final int FLAG_NEVER_BLANK = 1 << 5; |
| |
| /** |
| * Flag: Indicates that the display is suitable for presentations. |
| */ |
| public static final int FLAG_PRESENTATION = 1 << 6; |
| |
| /** |
| * Flag: Only show this display's own content; do not mirror |
| * the content of another display. |
| */ |
| public static final int FLAG_OWN_CONTENT_ONLY = 1 << 7; |
| |
| /** |
| * Flag: This display device has a round shape. |
| */ |
| public static final int FLAG_ROUND = 1 << 8; |
| |
| /** |
| * Flag: This display can show its content when non-secure keyguard is shown. |
| */ |
| public static final int FLAG_CAN_SHOW_WITH_INSECURE_KEYGUARD = 1 << 9; |
| |
| /** |
| * Flag: This display will destroy its content on removal. |
| * @hide |
| */ |
| public static final int FLAG_DESTROY_CONTENT_ON_REMOVAL = 1 << 10; |
| |
| /** |
| * Flag: The display cutout of this display is masked. |
| * @hide |
| */ |
| public static final int FLAG_MASK_DISPLAY_CUTOUT = 1 << 11; |
| |
| /** |
| * Touch attachment: Display does not receive touch. |
| */ |
| public static final int TOUCH_NONE = 0; |
| |
| /** |
| * Touch attachment: Touch input is via the internal interface. |
| */ |
| public static final int TOUCH_INTERNAL = 1; |
| |
| /** |
| * Touch attachment: Touch input is via an external interface, such as USB. |
| */ |
| public static final int TOUCH_EXTERNAL = 2; |
| |
| /** |
| * Touch attachment: Touch input is via an input device matching {@link VirtualDisplay}'s |
| * uniqueId. |
| * @hide |
| */ |
| public static final int TOUCH_VIRTUAL = 3; |
| |
| /** |
| * Diff result: The {@link #state} fields differ. |
| */ |
| public static final int DIFF_STATE = 1 << 0; |
| |
| /** |
| * Diff result: Other fields differ. |
| */ |
| public static final int DIFF_OTHER = 1 << 1; |
| |
| /** |
| * Diff result: The color mode fields differ. |
| */ |
| public static final int DIFF_COLOR_MODE = 1 << 2; |
| |
| /** |
| * Gets the name of the display device, which may be derived from EDID or |
| * other sources. The name may be localized and displayed to the user. |
| */ |
| public String name; |
| |
| /** |
| * Unique Id of display device. |
| */ |
| public String uniqueId; |
| |
| /** |
| * The width of the display in its natural orientation, in pixels. |
| * This value is not affected by display rotation. |
| */ |
| public int width; |
| |
| /** |
| * The height of the display in its natural orientation, in pixels. |
| * This value is not affected by display rotation. |
| */ |
| public int height; |
| |
| /** |
| * The active mode of the display. |
| */ |
| public int modeId; |
| |
| /** |
| * The default mode of the display. |
| */ |
| public int defaultModeId; |
| |
| /** |
| * The supported modes of the display. |
| */ |
| public Display.Mode[] supportedModes = Display.Mode.EMPTY_ARRAY; |
| |
| /** The active color mode of the display */ |
| public int colorMode; |
| |
| /** The supported color modes of the display */ |
| public int[] supportedColorModes = { Display.COLOR_MODE_DEFAULT }; |
| |
| /** |
| * The HDR capabilities this display claims to support. |
| */ |
| public Display.HdrCapabilities hdrCapabilities; |
| |
| /** |
| * The nominal apparent density of the display in DPI used for layout calculations. |
| * This density is sensitive to the viewing distance. A big TV and a tablet may have |
| * the same apparent density even though the pixels on the TV are much bigger than |
| * those on the tablet. |
| */ |
| public int densityDpi; |
| |
| /** |
| * The physical density of the display in DPI in the X direction. |
| * This density should specify the physical size of each pixel. |
| */ |
| public float xDpi; |
| |
| /** |
| * The physical density of the display in DPI in the X direction. |
| * This density should specify the physical size of each pixel. |
| */ |
| public float yDpi; |
| |
| /** |
| * This is a positive value indicating the phase offset of the VSYNC events provided by |
| * Choreographer relative to the display refresh. For example, if Choreographer reports |
| * that the refresh occurred at time N, it actually occurred at (N - appVsyncOffsetNanos). |
| */ |
| public long appVsyncOffsetNanos; |
| |
| /** |
| * This is how far in advance a buffer must be queued for presentation at |
| * a given time. If you want a buffer to appear on the screen at |
| * time N, you must submit the buffer before (N - bufferDeadlineNanos). |
| */ |
| public long presentationDeadlineNanos; |
| |
| /** |
| * Display flags. |
| */ |
| public int flags; |
| |
| /** |
| * The {@link DisplayCutout} if present or {@code null} otherwise. |
| */ |
| public DisplayCutout displayCutout; |
| |
| /** |
| * The touch attachment, per {@link DisplayViewport#touch}. |
| */ |
| public int touch; |
| |
| /** |
| * The additional rotation to apply to all content presented on the display device |
| * relative to its physical coordinate system. Default is {@link Surface#ROTATION_0}. |
| * <p> |
| * This field can be used to compensate for the fact that the display has been |
| * physically rotated relative to its natural orientation such as an HDMI monitor |
| * that has been mounted sideways to appear to be portrait rather than landscape. |
| * </p> |
| */ |
| public int rotation = Surface.ROTATION_0; |
| |
| /** |
| * Display type. |
| */ |
| public int type; |
| |
| /** |
| * Display address, or null if none. |
| * Interpretation varies by display type. |
| */ |
| public String address; |
| |
| /** |
| * Display state. |
| */ |
| public int state = Display.STATE_ON; |
| |
| /** |
| * The UID of the application that owns this display, or zero if it is owned by the system. |
| * <p> |
| * If the display is private, then only the owner can use it. |
| * </p> |
| */ |
| public int ownerUid; |
| |
| /** |
| * The package name of the application that owns this display, or null if it is |
| * owned by the system. |
| * <p> |
| * If the display is private, then only the owner can use it. |
| * </p> |
| */ |
| public String ownerPackageName; |
| |
| public void setAssumedDensityForExternalDisplay(int width, int height) { |
| densityDpi = Math.min(width, height) * DisplayMetrics.DENSITY_XHIGH / 1080; |
| // Technically, these values should be smaller than the apparent density |
| // but we don't know the physical size of the display. |
| xDpi = densityDpi; |
| yDpi = densityDpi; |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| return o instanceof DisplayDeviceInfo && equals((DisplayDeviceInfo)o); |
| } |
| |
| public boolean equals(DisplayDeviceInfo other) { |
| return other != null && diff(other) == 0; |
| } |
| |
| /** |
| * Computes the difference between display device infos. |
| * Assumes other is not null. |
| */ |
| public int diff(DisplayDeviceInfo other) { |
| int diff = 0; |
| if (state != other.state) { |
| diff |= DIFF_STATE; |
| } |
| if (colorMode != other.colorMode) { |
| diff |= DIFF_COLOR_MODE; |
| } |
| if (!Objects.equals(name, other.name) |
| || !Objects.equals(uniqueId, other.uniqueId) |
| || width != other.width |
| || height != other.height |
| || modeId != other.modeId |
| || defaultModeId != other.defaultModeId |
| || !Arrays.equals(supportedModes, other.supportedModes) |
| || !Arrays.equals(supportedColorModes, other.supportedColorModes) |
| || !Objects.equals(hdrCapabilities, other.hdrCapabilities) |
| || densityDpi != other.densityDpi |
| || xDpi != other.xDpi |
| || yDpi != other.yDpi |
| || appVsyncOffsetNanos != other.appVsyncOffsetNanos |
| || presentationDeadlineNanos != other.presentationDeadlineNanos |
| || flags != other.flags |
| || !Objects.equals(displayCutout, other.displayCutout) |
| || touch != other.touch |
| || rotation != other.rotation |
| || type != other.type |
| || !Objects.equals(address, other.address) |
| || ownerUid != other.ownerUid |
| || !Objects.equals(ownerPackageName, other.ownerPackageName)) { |
| diff |= DIFF_OTHER; |
| } |
| return diff; |
| } |
| |
| @Override |
| public int hashCode() { |
| return 0; // don't care |
| } |
| |
| public void copyFrom(DisplayDeviceInfo other) { |
| name = other.name; |
| uniqueId = other.uniqueId; |
| width = other.width; |
| height = other.height; |
| modeId = other.modeId; |
| defaultModeId = other.defaultModeId; |
| supportedModes = other.supportedModes; |
| colorMode = other.colorMode; |
| supportedColorModes = other.supportedColorModes; |
| hdrCapabilities = other.hdrCapabilities; |
| densityDpi = other.densityDpi; |
| xDpi = other.xDpi; |
| yDpi = other.yDpi; |
| appVsyncOffsetNanos = other.appVsyncOffsetNanos; |
| presentationDeadlineNanos = other.presentationDeadlineNanos; |
| flags = other.flags; |
| displayCutout = other.displayCutout; |
| touch = other.touch; |
| rotation = other.rotation; |
| type = other.type; |
| address = other.address; |
| state = other.state; |
| ownerUid = other.ownerUid; |
| ownerPackageName = other.ownerPackageName; |
| } |
| |
| // For debugging purposes |
| @Override |
| public String toString() { |
| StringBuilder sb = new StringBuilder(); |
| sb.append("DisplayDeviceInfo{\""); |
| sb.append(name).append("\": uniqueId=\"").append(uniqueId).append("\", "); |
| sb.append(width).append(" x ").append(height); |
| sb.append(", modeId ").append(modeId); |
| sb.append(", defaultModeId ").append(defaultModeId); |
| sb.append(", supportedModes ").append(Arrays.toString(supportedModes)); |
| sb.append(", colorMode ").append(colorMode); |
| sb.append(", supportedColorModes ").append(Arrays.toString(supportedColorModes)); |
| sb.append(", HdrCapabilities ").append(hdrCapabilities); |
| sb.append(", density ").append(densityDpi); |
| sb.append(", ").append(xDpi).append(" x ").append(yDpi).append(" dpi"); |
| sb.append(", appVsyncOff ").append(appVsyncOffsetNanos); |
| sb.append(", presDeadline ").append(presentationDeadlineNanos); |
| if (displayCutout != null) { |
| sb.append(", cutout ").append(displayCutout); |
| } |
| sb.append(", touch ").append(touchToString(touch)); |
| sb.append(", rotation ").append(rotation); |
| sb.append(", type ").append(Display.typeToString(type)); |
| if (address != null) { |
| sb.append(", address ").append(address); |
| } |
| sb.append(", state ").append(Display.stateToString(state)); |
| if (ownerUid != 0 || ownerPackageName != null) { |
| sb.append(", owner ").append(ownerPackageName); |
| sb.append(" (uid ").append(ownerUid).append(")"); |
| } |
| sb.append(flagsToString(flags)); |
| sb.append("}"); |
| return sb.toString(); |
| } |
| |
| private static String touchToString(int touch) { |
| switch (touch) { |
| case TOUCH_NONE: |
| return "NONE"; |
| case TOUCH_INTERNAL: |
| return "INTERNAL"; |
| case TOUCH_EXTERNAL: |
| return "EXTERNAL"; |
| case TOUCH_VIRTUAL: |
| return "VIRTUAL"; |
| default: |
| return Integer.toString(touch); |
| } |
| } |
| |
| private static String flagsToString(int flags) { |
| StringBuilder msg = new StringBuilder(); |
| if ((flags & FLAG_DEFAULT_DISPLAY) != 0) { |
| msg.append(", FLAG_DEFAULT_DISPLAY"); |
| } |
| if ((flags & FLAG_ROTATES_WITH_CONTENT) != 0) { |
| msg.append(", FLAG_ROTATES_WITH_CONTENT"); |
| } |
| if ((flags & FLAG_SECURE) != 0) { |
| msg.append(", FLAG_SECURE"); |
| } |
| if ((flags & FLAG_SUPPORTS_PROTECTED_BUFFERS) != 0) { |
| msg.append(", FLAG_SUPPORTS_PROTECTED_BUFFERS"); |
| } |
| if ((flags & FLAG_PRIVATE) != 0) { |
| msg.append(", FLAG_PRIVATE"); |
| } |
| if ((flags & FLAG_NEVER_BLANK) != 0) { |
| msg.append(", FLAG_NEVER_BLANK"); |
| } |
| if ((flags & FLAG_PRESENTATION) != 0) { |
| msg.append(", FLAG_PRESENTATION"); |
| } |
| if ((flags & FLAG_OWN_CONTENT_ONLY) != 0) { |
| msg.append(", FLAG_OWN_CONTENT_ONLY"); |
| } |
| if ((flags & FLAG_ROUND) != 0) { |
| msg.append(", FLAG_ROUND"); |
| } |
| if ((flags & FLAG_CAN_SHOW_WITH_INSECURE_KEYGUARD) != 0) { |
| msg.append(", FLAG_CAN_SHOW_WITH_INSECURE_KEYGUARD"); |
| } |
| if ((flags & FLAG_MASK_DISPLAY_CUTOUT) != 0) { |
| msg.append(", FLAG_MASK_DISPLAY_CUTOUT"); |
| } |
| return msg.toString(); |
| } |
| } |