Merge "SF: Start restructuring display creation" into rvc-dev am: d96f483057 (983279db) · Commits · e / os / android_frameworks_native-old

services/surfaceflinger/CompositionEngine/Android.bp

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -104,6 +104,7 @@ cc_test {
	static_libs: [		static_libs: [
	"libcompositionengine",		"libcompositionengine",
	"libcompositionengine_mocks",		"libcompositionengine_mocks",
			"libgui_mocks",
	"librenderengine_mocks",		"librenderengine_mocks",
	"libgmock",		"libgmock",
	"libgtest",		"libgtest",

services/surfaceflinger/CompositionEngine/include/compositionengine/DisplayCreationArgs.h

+61 −17

Original line number	Original line	Diff line number	Diff line
	@@ -18,6 +18,11 @@

	#include <cstdint>		#include <cstdint>
	#include <optional>		#include <optional>
			#include <string>

			#include <ui/DisplayInfo.h>
			#include <ui/PixelFormat.h>
			#include <ui/Size.h>

	#include "DisplayHardware/DisplayIdentification.h"		#include "DisplayHardware/DisplayIdentification.h"
	#include "DisplayHardware/PowerAdvisor.h"		#include "DisplayHardware/PowerAdvisor.h"
	@@ -30,47 +35,86 @@ class CompositionEngine;
	* A parameter object for creating Display instances		* A parameter object for creating Display instances
	*/		*/
	struct DisplayCreationArgs {		struct DisplayCreationArgs {
	// True if this display is a virtual display		struct Physical {
	bool isVirtual = false;		DisplayId id;
			DisplayConnectionType type;
			};

			// Required for physical displays. Gives the HWC display id for the existing
			// display along with the connection type.
			std::optional<Physical> physical;

			// Size of the display in pixels
			ui::Size pixels = ui::Size::INVALID;

	// Identifies the display to the HWC, if composition is supported by it		// Pixel format of the display
	std::optional<DisplayId> displayId;		ui::PixelFormat pixelFormat = static_cast<ui::PixelFormat>(PIXEL_FORMAT_UNKNOWN);

			// True if virtual displays should be created with the HWC API if possible
			bool useHwcVirtualDisplays = false;

			// True if this display should be considered secure
			bool isSecure = false;

			// Gives the initial layer stack id to be used for the display
			uint32_t layerStackId = ~0u;

	// Optional pointer to the power advisor interface, if one is needed for		// Optional pointer to the power advisor interface, if one is needed for
	// this display.		// this display.
	Hwc2::PowerAdvisor* powerAdvisor = nullptr;		Hwc2::PowerAdvisor* powerAdvisor = nullptr;

			// Debugging. Human readable name for the display.
			std::string name;
	};		};

	/**		/**
	* A helper for setting up a DisplayCreationArgs value in-line.		* A helper for setting up a DisplayCreationArgs value in-line.
	* Prefer this builder over raw structure initialization.		* Prefer this builder over raw structure initialization.
	*
	* Instead of:
	*
	* DisplayCreationArgs{false, false, displayId}
	*
	* Prefer:
	*
	* DisplayCreationArgsBuilder().setIsVirtual(false)
	* .setDisplayId(displayId).build();
	*/		*/
	class DisplayCreationArgsBuilder {		class DisplayCreationArgsBuilder {
	public:		public:
	DisplayCreationArgs build() { return std::move(mArgs); }		DisplayCreationArgs build() { return std::move(mArgs); }

	DisplayCreationArgsBuilder& setIsVirtual(bool isVirtual) {		DisplayCreationArgsBuilder& setPhysical(DisplayCreationArgs::Physical physical) {
	mArgs.isVirtual = isVirtual;		mArgs.physical = physical;
	return *this;		return *this;
	}		}
	DisplayCreationArgsBuilder& setDisplayId(std::optional<DisplayId> displayId) {
	mArgs.displayId = displayId;		DisplayCreationArgsBuilder& setPixels(ui::Size pixels) {
			mArgs.pixels = pixels;
	return *this;		return *this;
	}		}

			DisplayCreationArgsBuilder& setPixelFormat(ui::PixelFormat pixelFormat) {
			mArgs.pixelFormat = pixelFormat;
			return *this;
			}

			DisplayCreationArgsBuilder& setUseHwcVirtualDisplays(bool useHwcVirtualDisplays) {
			mArgs.useHwcVirtualDisplays = useHwcVirtualDisplays;
			return *this;
			}

			DisplayCreationArgsBuilder& setIsSecure(bool isSecure) {
			mArgs.isSecure = isSecure;
			return *this;
			}

			DisplayCreationArgsBuilder& setLayerStackId(uint32_t layerStackId) {
			mArgs.layerStackId = layerStackId;
			return *this;
			}

	DisplayCreationArgsBuilder& setPowerAdvisor(Hwc2::PowerAdvisor* powerAdvisor) {		DisplayCreationArgsBuilder& setPowerAdvisor(Hwc2::PowerAdvisor* powerAdvisor) {
	mArgs.powerAdvisor = powerAdvisor;		mArgs.powerAdvisor = powerAdvisor;
	return *this;		return *this;
	}		}

			DisplayCreationArgsBuilder& setName(std::string name) {
			mArgs.name = std::move(name);
			return *this;
			}

	private:		private:
	DisplayCreationArgs mArgs;		DisplayCreationArgs mArgs;
	};		};

services/surfaceflinger/CompositionEngine/include/compositionengine/impl/Display.h

+24 −9

Original line number	Original line	Diff line number	Diff line
	@@ -16,11 +16,15 @@

	#pragma once		#pragma once

			#include <memory>

	#include <compositionengine/Display.h>		#include <compositionengine/Display.h>
			#include <compositionengine/DisplayColorProfile.h>
	#include <compositionengine/DisplayCreationArgs.h>		#include <compositionengine/DisplayCreationArgs.h>
			#include <compositionengine/RenderSurface.h>
	#include <compositionengine/impl/Output.h>		#include <compositionengine/impl/Output.h>
			#include <ui/PixelFormat.h>
	#include <memory>		#include <ui/Size.h>

	#include "DisplayHardware/DisplayIdentification.h"		#include "DisplayHardware/DisplayIdentification.h"
	#include "DisplayHardware/HWComposer.h"		#include "DisplayHardware/HWComposer.h"
	@@ -36,11 +40,11 @@ namespace impl {
	// actually contain the final display state.		// actually contain the final display state.
	class Display : public compositionengine::impl::Output, public virtual compositionengine::Display {		class Display : public compositionengine::impl::Output, public virtual compositionengine::Display {
	public:		public:
	explicit Display(const compositionengine::DisplayCreationArgs&);
	virtual ~Display();		virtual ~Display();

	// compositionengine::Output overrides		// compositionengine::Output overrides
	std::optional<DisplayId> getDisplayId() const override;		std::optional<DisplayId> getDisplayId() const override;
			bool isValid() const override;
	void dump(std::string&) const override;		void dump(std::string&) const override;
	using compositionengine::impl::Output::setReleasedLayers;		using compositionengine::impl::Output::setReleasedLayers;
	void setReleasedLayers(const CompositionRefreshArgs&) override;		void setReleasedLayers(const CompositionRefreshArgs&) override;
	@@ -73,22 +77,33 @@ public:
	virtual void applyLayerRequestsToLayers(const LayerRequests&);		virtual void applyLayerRequestsToLayers(const LayerRequests&);

	// Internal		// Internal
			virtual void setConfiguration(const compositionengine::DisplayCreationArgs&);
			virtual std::optional<DisplayId> maybeAllocateDisplayIdForVirtualDisplay(ui::Size,
			ui::PixelFormat) const;
	std::unique_ptr<compositionengine::OutputLayer> createOutputLayer(const sp<LayerFE>&) const;		std::unique_ptr<compositionengine::OutputLayer> createOutputLayer(const sp<LayerFE>&) const;

			// Testing
			void setDisplayIdForTesting(std::optional<DisplayId> displayId);

	private:		private:
	const bool mIsVirtual;		bool mIsVirtual = false;
	std::optional<DisplayId> mId;		std::optional<DisplayId> mId;
	Hwc2::PowerAdvisor* const mPowerAdvisor{nullptr};		Hwc2::PowerAdvisor* mPowerAdvisor = nullptr;
	};		};

	// This template factory function standardizes the implementation details of the		// This template factory function standardizes the implementation details of the
	// final class using the types actually required by the implementation. This is		// final class using the types actually required by the implementation. This is
	// not possible to do in the base class as those types may not even be visible		// not possible to do in the base class as those types may not even be visible
	// to the base code.		// to the base code.
	template <typename BaseDisplay, typename CompositionEngine, typename DisplayCreationArgs>		template <typename BaseDisplay, typename CompositionEngine>
	std::shared_ptr<BaseDisplay> createDisplayTemplated(const CompositionEngine& compositionEngine,		std::shared_ptr<BaseDisplay> createDisplayTemplated(
	const DisplayCreationArgs& args) {		const CompositionEngine& compositionEngine,
	return createOutputTemplated<BaseDisplay>(compositionEngine, args);		const compositionengine::DisplayCreationArgs& args) {
			auto display = createOutputTemplated<BaseDisplay>(compositionEngine);

			display->setConfiguration(args);

			return display;
	}		}

	std::shared_ptr<Display> createDisplay(const compositionengine::CompositionEngine&,		std::shared_ptr<Display> createDisplay(const compositionengine::CompositionEngine&,

services/surfaceflinger/CompositionEngine/src/Display.cpp

+32 −3

Original line number	Original line	Diff line number	Diff line
	@@ -47,11 +47,36 @@ std::shared_ptr<Display> createDisplay(
	return createDisplayTemplated<Display>(compositionEngine, args);		return createDisplayTemplated<Display>(compositionEngine, args);
	}		}

	Display::Display(const DisplayCreationArgs& args)
	: mIsVirtual(args.isVirtual), mId(args.displayId), mPowerAdvisor(args.powerAdvisor) {}

	Display::~Display() = default;		Display::~Display() = default;

			void Display::setConfiguration(const compositionengine::DisplayCreationArgs& args) {
			mIsVirtual = !args.physical;
			mId = args.physical ? std::make_optional(args.physical->id) : std::nullopt;
			mPowerAdvisor = args.powerAdvisor;

			editState().isSecure = args.isSecure;

			setLayerStackFilter(args.layerStackId,
			args.physical ? args.physical->type == DisplayConnectionType::Internal
			: false);
			setName(args.name);

			if (!args.physical && args.useHwcVirtualDisplays) {
			mId = maybeAllocateDisplayIdForVirtualDisplay(args.pixels, args.pixelFormat);
			}
			}

			std::optional<DisplayId> Display::maybeAllocateDisplayIdForVirtualDisplay(
			ui::Size pixels, ui::PixelFormat pixelFormat) const {
			auto& hwc = getCompositionEngine().getHwComposer();
			return hwc.allocateVirtualDisplay(static_cast<uint32_t>(pixels.width),
			static_cast<uint32_t>(pixels.height), &pixelFormat);
			}

			bool Display::isValid() const {
			return Output::isValid() && mPowerAdvisor;
			}

	const std::optional<DisplayId>& Display::getId() const {		const std::optional<DisplayId>& Display::getId() const {
	return mId;		return mId;
	}		}
	@@ -68,6 +93,10 @@ std::optional<DisplayId> Display::getDisplayId() const {
	return mId;		return mId;
	}		}

			void Display::setDisplayIdForTesting(std::optional<DisplayId> displayId) {
			mId = displayId;
			}

	void Display::disconnect() {		void Display::disconnect() {
	if (!mId) {		if (!mId) {
	return;		return;

services/surfaceflinger/CompositionEngine/tests/DisplayTest.cpp

+373 −177

File changed.

Preview size limit exceeded, changes collapsed.