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

services/surfaceflinger/CompositionEngine/Android.bp

+1 −0

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

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

+61 −17

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

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

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

		#include "DisplayHardware/DisplayIdentification.h"
		#include "DisplayHardware/PowerAdvisor.h"
		@@ -30,47 +35,86 @@ class CompositionEngine;
		* A parameter object for creating Display instances
		*/
		struct DisplayCreationArgs {
		// True if this display is a virtual display
		bool isVirtual = false;
		struct Physical {
		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
		std::optional<DisplayId> displayId;
		// Pixel format of the display
		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
		// this display.
		Hwc2::PowerAdvisor* powerAdvisor = nullptr;

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

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

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

		DisplayCreationArgsBuilder& setPixels(ui::Size pixels) {
		mArgs.pixels = pixels;
		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) {
		mArgs.powerAdvisor = powerAdvisor;
		return *this;
		}

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

		private:
		DisplayCreationArgs mArgs;
		};

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

+24 −9

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

		#pragma once

		#include <memory>

		#include <compositionengine/Display.h>
		#include <compositionengine/DisplayColorProfile.h>
		#include <compositionengine/DisplayCreationArgs.h>
		#include <compositionengine/RenderSurface.h>
		#include <compositionengine/impl/Output.h>

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

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

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

		// 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;

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

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

		// This template factory function standardizes the implementation details of the
		// 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
		// to the base code.
		template <typename BaseDisplay, typename CompositionEngine, typename DisplayCreationArgs>
		std::shared_ptr<BaseDisplay> createDisplayTemplated(const CompositionEngine& compositionEngine,
		const DisplayCreationArgs& args) {
		return createOutputTemplated<BaseDisplay>(compositionEngine, args);
		template <typename BaseDisplay, typename CompositionEngine>
		std::shared_ptr<BaseDisplay> createDisplayTemplated(
		const CompositionEngine& compositionEngine,
		const compositionengine::DisplayCreationArgs& args) {
		auto display = createOutputTemplated<BaseDisplay>(compositionEngine);

		display->setConfiguration(args);

		return display;
		}

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

services/surfaceflinger/CompositionEngine/src/Display.cpp

+32 −3

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

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

		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 {
		return mId;
		}
		@@ -68,6 +93,10 @@ std::optional<DisplayId> Display::getDisplayId() const {
		return mId;
		}

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

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

services/surfaceflinger/CompositionEngine/tests/DisplayTest.cpp

+373 −177

File changed.

Preview size limit exceeded, changes collapsed.