Use type safe display IDs.
Use a type safe wrapper around uint64_t for display ids.
We also modify the format of the EDID generated physical
display IDs by setting bit 62 to 1, which will indicate
that the display id is stable across reboot.
Bug: 160679868
Test: m && flash device
Test: take screnshot on device
Test: atest surfaceflinger_unittest
Change-Id: Ie2c7c2b737e0882fa4208c059caa85b7ded922b2
diff --git a/services/surfaceflinger/DisplayHardware/HWComposer.h b/services/surfaceflinger/DisplayHardware/HWComposer.h
index b800038..698e3af 100644
--- a/services/surfaceflinger/DisplayHardware/HWComposer.h
+++ b/services/surfaceflinger/DisplayHardware/HWComposer.h
@@ -84,23 +84,22 @@
virtual void setConfiguration(HWC2::ComposerCallback* callback, int32_t sequenceId) = 0;
- virtual bool getDisplayIdentificationData(hal::HWDisplayId hwcDisplayId, uint8_t* outPort,
+ virtual bool getDisplayIdentificationData(hal::HWDisplayId, uint8_t* outPort,
DisplayIdentificationData* outData) const = 0;
- virtual bool hasCapability(hal::Capability capability) const = 0;
- virtual bool hasDisplayCapability(DisplayId displayId,
- hal::DisplayCapability capability) const = 0;
+ virtual bool hasCapability(hal::Capability) const = 0;
+ virtual bool hasDisplayCapability(DisplayId, hal::DisplayCapability) const = 0;
// Attempts to allocate a virtual display and returns its ID if created on the HWC device.
virtual std::optional<DisplayId> allocateVirtualDisplay(uint32_t width, uint32_t height,
- ui::PixelFormat* format) = 0;
+ ui::PixelFormat*) = 0;
- virtual void allocatePhysicalDisplay(hal::HWDisplayId hwcDisplayId, DisplayId displayId) = 0;
+ virtual void allocatePhysicalDisplay(hal::HWDisplayId, PhysicalDisplayId) = 0;
// Attempts to create a new layer on this display
- virtual HWC2::Layer* createLayer(DisplayId displayId) = 0;
+ virtual HWC2::Layer* createLayer(DisplayId) = 0;
// Destroy a previously created layer
- virtual void destroyLayer(DisplayId displayId, HWC2::Layer* layer) = 0;
+ virtual void destroyLayer(DisplayId, HWC2::Layer*) = 0;
// Gets any required composition change requests from the HWC device.
//
@@ -113,104 +112,97 @@
DisplayId, bool frameUsesClientComposition,
std::optional<DeviceRequestedChanges>* outChanges) = 0;
- virtual status_t setClientTarget(DisplayId displayId, uint32_t slot,
- const sp<Fence>& acquireFence, const sp<GraphicBuffer>& target,
- ui::Dataspace dataspace) = 0;
+ virtual status_t setClientTarget(DisplayId, uint32_t slot, const sp<Fence>& acquireFence,
+ const sp<GraphicBuffer>& target, ui::Dataspace) = 0;
// Present layers to the display and read releaseFences.
- virtual status_t presentAndGetReleaseFences(DisplayId displayId) = 0;
+ virtual status_t presentAndGetReleaseFences(DisplayId) = 0;
// set power mode
- virtual status_t setPowerMode(DisplayId displayId, hal::PowerMode mode) = 0;
+ virtual status_t setPowerMode(DisplayId, hal::PowerMode) = 0;
// Sets a color transform to be applied to the result of composition
- virtual status_t setColorTransform(DisplayId displayId, const mat4& transform) = 0;
+ virtual status_t setColorTransform(DisplayId, const mat4& transform) = 0;
// reset state when an external, non-virtual display is disconnected
- virtual void disconnectDisplay(DisplayId displayId) = 0;
+ virtual void disconnectDisplay(DisplayId) = 0;
// get the present fence received from the last call to present.
- virtual sp<Fence> getPresentFence(DisplayId displayId) const = 0;
+ virtual sp<Fence> getPresentFence(DisplayId) const = 0;
// Get last release fence for the given layer
- virtual sp<Fence> getLayerReleaseFence(DisplayId displayId, HWC2::Layer* layer) const = 0;
+ virtual sp<Fence> getLayerReleaseFence(DisplayId, HWC2::Layer*) const = 0;
// Set the output buffer and acquire fence for a virtual display.
// Returns INVALID_OPERATION if displayId is not a virtual display.
- virtual status_t setOutputBuffer(DisplayId displayId, const sp<Fence>& acquireFence,
+ virtual status_t setOutputBuffer(DisplayId, const sp<Fence>& acquireFence,
const sp<GraphicBuffer>& buffer) = 0;
// After SurfaceFlinger has retrieved the release fences for all the frames,
// it can call this to clear the shared pointers in the release fence map
- virtual void clearReleaseFences(DisplayId displayId) = 0;
+ virtual void clearReleaseFences(DisplayId) = 0;
// Fetches the HDR capabilities of the given display
- virtual status_t getHdrCapabilities(DisplayId displayId, HdrCapabilities* outCapabilities) = 0;
+ virtual status_t getHdrCapabilities(DisplayId, HdrCapabilities* outCapabilities) = 0;
- virtual int32_t getSupportedPerFrameMetadata(DisplayId displayId) const = 0;
+ virtual int32_t getSupportedPerFrameMetadata(DisplayId) const = 0;
// Returns the available RenderIntent of the given display.
- virtual std::vector<ui::RenderIntent> getRenderIntents(DisplayId displayId,
- ui::ColorMode colorMode) const = 0;
+ virtual std::vector<ui::RenderIntent> getRenderIntents(DisplayId, ui::ColorMode) const = 0;
- virtual mat4 getDataspaceSaturationMatrix(DisplayId displayId, ui::Dataspace dataspace) = 0;
+ virtual mat4 getDataspaceSaturationMatrix(DisplayId, ui::Dataspace) = 0;
// Returns the attributes of the color sampling engine.
- virtual status_t getDisplayedContentSamplingAttributes(DisplayId displayId,
- ui::PixelFormat* outFormat,
+ virtual status_t getDisplayedContentSamplingAttributes(DisplayId, ui::PixelFormat* outFormat,
ui::Dataspace* outDataspace,
uint8_t* outComponentMask) = 0;
- virtual status_t setDisplayContentSamplingEnabled(DisplayId displayId, bool enabled,
+ virtual status_t setDisplayContentSamplingEnabled(DisplayId, bool enabled,
uint8_t componentMask,
uint64_t maxFrames) = 0;
- virtual status_t getDisplayedContentSample(DisplayId displayId, uint64_t maxFrames,
- uint64_t timestamp,
+ virtual status_t getDisplayedContentSample(DisplayId, uint64_t maxFrames, uint64_t timestamp,
DisplayedFrameStats* outStats) = 0;
// Sets the brightness of a display.
- virtual std::future<status_t> setDisplayBrightness(DisplayId displayId, float brightness) = 0;
+ virtual std::future<status_t> setDisplayBrightness(DisplayId, float brightness) = 0;
// Events handling ---------------------------------------------------------
// Returns stable display ID (and display name on connection of new or previously disconnected
// display), or std::nullopt if hotplug event was ignored.
// This function is called from SurfaceFlinger.
- virtual std::optional<DisplayIdentificationInfo> onHotplug(hal::HWDisplayId hwcDisplayId,
- hal::Connection connection) = 0;
+ virtual std::optional<DisplayIdentificationInfo> onHotplug(hal::HWDisplayId,
+ hal::Connection) = 0;
- virtual bool onVsync(hal::HWDisplayId hwcDisplayId, int64_t timestamp) = 0;
- virtual void setVsyncEnabled(DisplayId displayId, hal::Vsync enabled) = 0;
+ virtual bool onVsync(hal::HWDisplayId, int64_t timestamp) = 0;
+ virtual void setVsyncEnabled(DisplayId, hal::Vsync enabled) = 0;
- virtual nsecs_t getRefreshTimestamp(DisplayId displayId) const = 0;
- virtual bool isConnected(DisplayId displayId) const = 0;
+ virtual nsecs_t getRefreshTimestamp(DisplayId) const = 0;
+ virtual bool isConnected(DisplayId) const = 0;
// Non-const because it can update configMap inside of mDisplayData
virtual std::vector<std::shared_ptr<const HWC2::Display::Config>> getConfigs(
- DisplayId displayId) const = 0;
+ DisplayId) const = 0;
- virtual std::shared_ptr<const HWC2::Display::Config> getActiveConfig(
- DisplayId displayId) const = 0;
- virtual int getActiveConfigIndex(DisplayId displayId) const = 0;
+ virtual std::shared_ptr<const HWC2::Display::Config> getActiveConfig(DisplayId) const = 0;
+ virtual int getActiveConfigIndex(DisplayId) const = 0;
- virtual std::vector<ui::ColorMode> getColorModes(DisplayId displayId) const = 0;
+ virtual std::vector<ui::ColorMode> getColorModes(DisplayId) const = 0;
- virtual status_t setActiveColorMode(DisplayId displayId, ui::ColorMode mode,
- ui::RenderIntent renderIntent) = 0;
+ virtual status_t setActiveColorMode(DisplayId, ui::ColorMode mode, ui::RenderIntent) = 0;
virtual bool isUsingVrComposer() const = 0;
// Composer 2.4
virtual DisplayConnectionType getDisplayConnectionType(DisplayId) const = 0;
- virtual bool isVsyncPeriodSwitchSupported(DisplayId displayId) const = 0;
- virtual nsecs_t getDisplayVsyncPeriod(DisplayId displayId) const = 0;
+ virtual bool isVsyncPeriodSwitchSupported(DisplayId) const = 0;
+ virtual nsecs_t getDisplayVsyncPeriod(DisplayId) const = 0;
virtual status_t setActiveConfigWithConstraints(
- DisplayId displayId, size_t configId,
- const hal::VsyncPeriodChangeConstraints& constraints,
+ DisplayId, size_t configId, const hal::VsyncPeriodChangeConstraints&,
hal::VsyncPeriodChangeTimeline* outTimeline) = 0;
- virtual status_t setAutoLowLatencyMode(DisplayId displayId, bool on) = 0;
+ virtual status_t setAutoLowLatencyMode(DisplayId, bool on) = 0;
virtual status_t getSupportedContentTypes(
- DisplayId displayId, std::vector<hal::ContentType>* outSupportedContentTypes) = 0;
- virtual status_t setContentType(DisplayId displayId, hal::ContentType contentType) = 0;
+ DisplayId, std::vector<hal::ContentType>* outSupportedContentTypes) = 0;
+ virtual status_t setContentType(DisplayId, hal::ContentType) = 0;
virtual const std::unordered_map<std::string, bool>& getSupportedLayerGenericMetadata()
const = 0;
@@ -223,8 +215,8 @@
virtual std::optional<hal::HWDisplayId> getInternalHwcDisplayId() const = 0;
virtual std::optional<hal::HWDisplayId> getExternalHwcDisplayId() const = 0;
- virtual std::optional<DisplayId> toPhysicalDisplayId(hal::HWDisplayId hwcDisplayId) const = 0;
- virtual std::optional<hal::HWDisplayId> fromPhysicalDisplayId(DisplayId displayId) const = 0;
+ virtual std::optional<PhysicalDisplayId> toPhysicalDisplayId(hal::HWDisplayId) const = 0;
+ virtual std::optional<hal::HWDisplayId> fromPhysicalDisplayId(PhysicalDisplayId) const = 0;
};
namespace impl {
@@ -238,118 +230,112 @@
void setConfiguration(HWC2::ComposerCallback* callback, int32_t sequenceId) override;
- bool getDisplayIdentificationData(hal::HWDisplayId hwcDisplayId, uint8_t* outPort,
+ bool getDisplayIdentificationData(hal::HWDisplayId, uint8_t* outPort,
DisplayIdentificationData* outData) const override;
- bool hasCapability(hal::Capability capability) const override;
- bool hasDisplayCapability(DisplayId displayId,
- hal::DisplayCapability capability) const override;
+ bool hasCapability(hal::Capability) const override;
+ bool hasDisplayCapability(DisplayId, hal::DisplayCapability) const override;
// Attempts to allocate a virtual display and returns its ID if created on the HWC device.
std::optional<DisplayId> allocateVirtualDisplay(uint32_t width, uint32_t height,
- ui::PixelFormat* format) override;
+ ui::PixelFormat*) override;
// Called from SurfaceFlinger, when the state for a new physical display needs to be recreated.
- void allocatePhysicalDisplay(hal::HWDisplayId hwcDisplayId, DisplayId displayId) override;
+ void allocatePhysicalDisplay(hal::HWDisplayId, PhysicalDisplayId) override;
// Attempts to create a new layer on this display
- HWC2::Layer* createLayer(DisplayId displayId) override;
+ HWC2::Layer* createLayer(DisplayId) override;
// Destroy a previously created layer
- void destroyLayer(DisplayId displayId, HWC2::Layer* layer) override;
+ void destroyLayer(DisplayId, HWC2::Layer*) override;
status_t getDeviceCompositionChanges(
DisplayId, bool frameUsesClientComposition,
std::optional<DeviceRequestedChanges>* outChanges) override;
- status_t setClientTarget(DisplayId displayId, uint32_t slot, const sp<Fence>& acquireFence,
- const sp<GraphicBuffer>& target, ui::Dataspace dataspace) override;
+ status_t setClientTarget(DisplayId, uint32_t slot, const sp<Fence>& acquireFence,
+ const sp<GraphicBuffer>& target, ui::Dataspace) override;
// Present layers to the display and read releaseFences.
- status_t presentAndGetReleaseFences(DisplayId displayId) override;
+ status_t presentAndGetReleaseFences(DisplayId) override;
// set power mode
- status_t setPowerMode(DisplayId displayId, hal::PowerMode mode) override;
+ status_t setPowerMode(DisplayId, hal::PowerMode mode) override;
// Sets a color transform to be applied to the result of composition
- status_t setColorTransform(DisplayId displayId, const mat4& transform) override;
+ status_t setColorTransform(DisplayId, const mat4& transform) override;
// reset state when an external, non-virtual display is disconnected
- void disconnectDisplay(DisplayId displayId) override;
+ void disconnectDisplay(DisplayId) override;
// get the present fence received from the last call to present.
- sp<Fence> getPresentFence(DisplayId displayId) const override;
+ sp<Fence> getPresentFence(DisplayId) const override;
// Get last release fence for the given layer
- sp<Fence> getLayerReleaseFence(DisplayId displayId, HWC2::Layer* layer) const override;
+ sp<Fence> getLayerReleaseFence(DisplayId, HWC2::Layer*) const override;
// Set the output buffer and acquire fence for a virtual display.
// Returns INVALID_OPERATION if displayId is not a virtual display.
- status_t setOutputBuffer(DisplayId displayId, const sp<Fence>& acquireFence,
+ status_t setOutputBuffer(DisplayId, const sp<Fence>& acquireFence,
const sp<GraphicBuffer>& buffer) override;
// After SurfaceFlinger has retrieved the release fences for all the frames,
// it can call this to clear the shared pointers in the release fence map
- void clearReleaseFences(DisplayId displayId) override;
+ void clearReleaseFences(DisplayId) override;
// Fetches the HDR capabilities of the given display
- status_t getHdrCapabilities(DisplayId displayId, HdrCapabilities* outCapabilities) override;
+ status_t getHdrCapabilities(DisplayId, HdrCapabilities* outCapabilities) override;
- int32_t getSupportedPerFrameMetadata(DisplayId displayId) const override;
+ int32_t getSupportedPerFrameMetadata(DisplayId) const override;
// Returns the available RenderIntent of the given display.
- std::vector<ui::RenderIntent> getRenderIntents(DisplayId displayId,
- ui::ColorMode colorMode) const override;
+ std::vector<ui::RenderIntent> getRenderIntents(DisplayId, ui::ColorMode) const override;
- mat4 getDataspaceSaturationMatrix(DisplayId displayId, ui::Dataspace dataspace) override;
+ mat4 getDataspaceSaturationMatrix(DisplayId, ui::Dataspace) override;
// Returns the attributes of the color sampling engine.
- status_t getDisplayedContentSamplingAttributes(DisplayId displayId, ui::PixelFormat* outFormat,
+ status_t getDisplayedContentSamplingAttributes(DisplayId, ui::PixelFormat* outFormat,
ui::Dataspace* outDataspace,
uint8_t* outComponentMask) override;
- status_t setDisplayContentSamplingEnabled(DisplayId displayId, bool enabled,
- uint8_t componentMask, uint64_t maxFrames) override;
- status_t getDisplayedContentSample(DisplayId displayId, uint64_t maxFrames, uint64_t timestamp,
+ status_t setDisplayContentSamplingEnabled(DisplayId, bool enabled, uint8_t componentMask,
+ uint64_t maxFrames) override;
+ status_t getDisplayedContentSample(DisplayId, uint64_t maxFrames, uint64_t timestamp,
DisplayedFrameStats* outStats) override;
- std::future<status_t> setDisplayBrightness(DisplayId displayId, float brightness) override;
+ std::future<status_t> setDisplayBrightness(DisplayId, float brightness) override;
// Events handling ---------------------------------------------------------
// Returns stable display ID (and display name on connection of new or previously disconnected
// display), or std::nullopt if hotplug event was ignored.
- std::optional<DisplayIdentificationInfo> onHotplug(hal::HWDisplayId hwcDisplayId,
- hal::Connection connection) override;
+ std::optional<DisplayIdentificationInfo> onHotplug(hal::HWDisplayId, hal::Connection) override;
- bool onVsync(hal::HWDisplayId hwcDisplayId, int64_t timestamp) override;
- void setVsyncEnabled(DisplayId displayId, hal::Vsync enabled) override;
+ bool onVsync(hal::HWDisplayId, int64_t timestamp) override;
+ void setVsyncEnabled(DisplayId, hal::Vsync enabled) override;
- nsecs_t getRefreshTimestamp(DisplayId displayId) const override;
- bool isConnected(DisplayId displayId) const override;
+ nsecs_t getRefreshTimestamp(DisplayId) const override;
+ bool isConnected(DisplayId) const override;
// Non-const because it can update configMap inside of mDisplayData
- std::vector<std::shared_ptr<const HWC2::Display::Config>> getConfigs(
- DisplayId displayId) const override;
+ std::vector<std::shared_ptr<const HWC2::Display::Config>> getConfigs(DisplayId) const override;
- std::shared_ptr<const HWC2::Display::Config> getActiveConfig(
- DisplayId displayId) const override;
- int getActiveConfigIndex(DisplayId displayId) const override;
+ std::shared_ptr<const HWC2::Display::Config> getActiveConfig(DisplayId) const override;
+ int getActiveConfigIndex(DisplayId) const override;
- std::vector<ui::ColorMode> getColorModes(DisplayId displayId) const override;
+ std::vector<ui::ColorMode> getColorModes(DisplayId) const override;
- status_t setActiveColorMode(DisplayId displayId, ui::ColorMode mode,
- ui::RenderIntent renderIntent) override;
+ status_t setActiveColorMode(DisplayId, ui::ColorMode, ui::RenderIntent) override;
bool isUsingVrComposer() const override;
// Composer 2.4
DisplayConnectionType getDisplayConnectionType(DisplayId) const override;
- bool isVsyncPeriodSwitchSupported(DisplayId displayId) const override;
- nsecs_t getDisplayVsyncPeriod(DisplayId displayId) const override;
- status_t setActiveConfigWithConstraints(DisplayId displayId, size_t configId,
- const hal::VsyncPeriodChangeConstraints& constraints,
+ bool isVsyncPeriodSwitchSupported(DisplayId) const override;
+ nsecs_t getDisplayVsyncPeriod(DisplayId) const override;
+ status_t setActiveConfigWithConstraints(DisplayId, size_t configId,
+ const hal::VsyncPeriodChangeConstraints&,
hal::VsyncPeriodChangeTimeline* outTimeline) override;
- status_t setAutoLowLatencyMode(DisplayId displayId, bool) override;
- status_t getSupportedContentTypes(DisplayId displayId, std::vector<hal::ContentType>*) override;
- status_t setContentType(DisplayId displayId, hal::ContentType) override;
+ status_t setAutoLowLatencyMode(DisplayId, bool) override;
+ status_t getSupportedContentTypes(DisplayId, std::vector<hal::ContentType>*) override;
+ status_t setContentType(DisplayId, hal::ContentType) override;
const std::unordered_map<std::string, bool>& getSupportedLayerGenericMetadata() const override;
@@ -366,17 +352,16 @@
return mExternalHwcDisplayId;
}
- std::optional<DisplayId> toPhysicalDisplayId(hal::HWDisplayId hwcDisplayId) const override;
- std::optional<hal::HWDisplayId> fromPhysicalDisplayId(DisplayId displayId) const override;
+ std::optional<PhysicalDisplayId> toPhysicalDisplayId(hal::HWDisplayId) const override;
+ std::optional<hal::HWDisplayId> fromPhysicalDisplayId(PhysicalDisplayId) const override;
private:
// For unit tests
friend TestableSurfaceFlinger;
- std::optional<DisplayIdentificationInfo> onHotplugConnect(hal::HWDisplayId hwcDisplayId);
- std::optional<DisplayIdentificationInfo> onHotplugDisconnect(hal::HWDisplayId hwcDisplayId);
- bool shouldIgnoreHotplugConnect(hal::HWDisplayId hwcDisplayId,
- bool hasDisplayIdentificationData) const;
+ std::optional<DisplayIdentificationInfo> onHotplugConnect(hal::HWDisplayId);
+ std::optional<DisplayIdentificationInfo> onHotplugDisconnect(hal::HWDisplayId);
+ bool shouldIgnoreHotplugConnect(hal::HWDisplayId, bool hasDisplayIdentificationData) const;
void loadCapabilities();
void loadLayerMetadataSupport();
@@ -411,7 +396,7 @@
std::unordered_map<std::string, bool> mSupportedLayerGenericMetadata;
bool mRegisteredCallback = false;
- std::unordered_map<hal::HWDisplayId, DisplayId> mPhysicalDisplayIdMap;
+ std::unordered_map<hal::HWDisplayId, PhysicalDisplayId> mPhysicalDisplayIdMap;
std::optional<hal::HWDisplayId> mInternalHwcDisplayId;
std::optional<hal::HWDisplayId> mExternalHwcDisplayId;
bool mHasMultiDisplaySupport = false;