Snap for 6069976 from b81762c72c55a91f6c1fa7ce2370bc194d48e34e to rvc-release (ecb74e7c) · Commits · e / os / android_frameworks_native-old

cmds/installd/InstalldNativeService.cpp

+13 −0

Original line number	Diff line number	Diff line
		@@ -2595,6 +2595,8 @@ binder::Status InstalldNativeService::invalidateMounts() {
		std::getline(in, ignored);

		if (android::base::GetBoolProperty(kFuseProp, false)) {
		// TODO(b/146139106): Use sdcardfs mounts on devices running sdcardfs so we don't bypass
		// it's VFS cache
		if (target.compare(0, 17, "/mnt/pass_through") == 0) {
		LOG(DEBUG) << "Found storage mount " << source << " at " << target;
		mStorageMounts[source] = target;
		@@ -2616,6 +2618,17 @@ std::string InstalldNativeService::findDataMediaPath(
		std::lock_guard<std::recursive_mutex> lock(mMountsLock);
		const char* uuid_ = uuid ? uuid->c_str() : nullptr;
		auto path = StringPrintf("%s/media", create_data_path(uuid_).c_str());
		if (android::base::GetBoolProperty(kFuseProp, false)) {
		// TODO(b/146139106): This is only safe on devices not running sdcardfs where there is no
		// risk of bypassing the sdcardfs VFS cache

		// Always use the lower filesystem path on FUSE enabled devices not running sdcardfs
		// The upper filesystem path, /mnt/pass_through/<userid>/<vol>/ which was a bind mount
		// to the lower filesytem may have been unmounted already when a user is
		// removed and the path will now be pointing to a tmpfs without content
		return StringPrintf("%s/%u", path.c_str(), userid);
		}

		auto resolved = mStorageMounts[path];
		if (resolved.empty()) {
		LOG(WARNING) << "Failed to find storage mount for " << path;

include/input/InputWindow.h

+0 −1

Original line number	Diff line number	Diff line
		@@ -63,7 +63,6 @@ struct InputWindowInfo {
		FLAG_DISMISS_KEYGUARD = 0x00400000,
		FLAG_SPLIT_TOUCH = 0x00800000,
		FLAG_SLIPPERY = 0x20000000,
		FLAG_NEEDS_MENU_KEY = 0x40000000,
		};

		// Window types from WindowManager.LayoutParams

libs/gralloc/types/Gralloc4.cpp

+129 −15

Original line number	Diff line number	Diff line
		@@ -25,15 +25,19 @@

		using android::hardware::hidl_vec;

		using ::aidl::android::hardware::graphics::common::BlendMode;
		using ::aidl::android::hardware::graphics::common::Dataspace;
		using ::aidl::android::hardware::graphics::common::PlaneLayout;
		using ::aidl::android::hardware::graphics::common::PlaneLayoutComponent;
		using ::aidl::android::hardware::graphics::common::ExtendableType;
		using ::aidl::android::hardware::graphics::common::Rect;
		using ::aidl::android::hardware::graphics::common::StandardMetadataType;

		using MetadataType = ::android::hardware::graphics::mapper::V4_0::IMapper::MetadataType;
		using aidl::android::hardware::graphics::common::BlendMode;
		using aidl::android::hardware::graphics::common::ChromaSiting;
		using aidl::android::hardware::graphics::common::Compression;
		using aidl::android::hardware::graphics::common::Dataspace;
		using aidl::android::hardware::graphics::common::ExtendableType;
		using aidl::android::hardware::graphics::common::Interlaced;
		using aidl::android::hardware::graphics::common::PlaneLayout;
		using aidl::android::hardware::graphics::common::PlaneLayoutComponent;
		using aidl::android::hardware::graphics::common::PlaneLayoutComponentType;
		using aidl::android::hardware::graphics::common::Rect;
		using aidl::android::hardware::graphics::common::StandardMetadataType;

		using MetadataType = android::hardware::graphics::mapper::V4_0::IMapper::MetadataType;

		namespace android {

		@@ -545,12 +549,9 @@ void clearPlaneLayouts(std::vector<PlaneLayout>* output) {
		/**
		* Public API functions
		*/
		bool isStandardMetadataType(const MetadataType& metadataType) {
		return !std::strncmp(metadataType.name.c_str(), GRALLOC4_STANDARD_METADATA_TYPE, metadataType.name.size());
		}

		StandardMetadataType getStandardMetadataTypeValue(const MetadataType& metadataType) {
		return static_cast<StandardMetadataType>(metadataType.value);
		PlaneLayoutComponentType getStandardPlaneLayoutComponentTypeValue(
		const ExtendableType& planeLayoutComponentType) {
		return static_cast<PlaneLayoutComponentType>(planeLayoutComponentType.value);
		}

		status_t encodeBufferId(uint64_t bufferId, hidl_vec<uint8_t>* outBufferId) {
		@@ -691,6 +692,119 @@ status_t decodeBlendMode(const hidl_vec<uint8_t>& blendMode, BlendMode* outBlend
		return decode(blendMode, reinterpret_cast<int32_t*>(outBlendMode), decodeInteger);
		}

		bool isStandardMetadataType(const MetadataType& metadataType) {
		return !std::strncmp(metadataType.name.c_str(), GRALLOC4_STANDARD_METADATA_TYPE,
		metadataType.name.size());
		}

		bool isStandardCompression(const ExtendableType& compression) {
		return !std::strncmp(compression.name.c_str(), GRALLOC4_STANDARD_COMPRESSION,
		compression.name.size());
		}

		bool isStandardInterlaced(const ExtendableType& interlaced) {
		return !std::strncmp(interlaced.name.c_str(), GRALLOC4_STANDARD_INTERLACED,
		interlaced.name.size());
		}

		bool isStandardChromaSiting(const ExtendableType& chromaSiting) {
		return !std::strncmp(chromaSiting.name.c_str(), GRALLOC4_STANDARD_CHROMA_SITING,
		chromaSiting.name.size());
		}

		bool isStandardPlaneLayoutComponentType(const ExtendableType& planeLayoutComponentType) {
		return !std::strncmp(planeLayoutComponentType.name.c_str(), GRALLOC4_STANDARD_PLANE_LAYOUT_COMPONENT_TYPE,
		planeLayoutComponentType.name.size());
		}

		StandardMetadataType getStandardMetadataTypeValue(const MetadataType& metadataType) {
		return static_cast<StandardMetadataType>(metadataType.value);
		}

		Compression getStandardCompressionValue(const ExtendableType& compression) {
		return static_cast<Compression>(compression.value);
		}

		Interlaced getStandardInterlacedValue(const ExtendableType& interlaced) {
		return static_cast<Interlaced>(interlaced.value);
		}

		ChromaSiting getStandardChromaSitingValue(const ExtendableType& chromaSiting) {
		return static_cast<ChromaSiting>(chromaSiting.value);
		}

		std::string getCompressionName(const ExtendableType& compression) {
		if (!isStandardCompression(compression)) {
		std::ostringstream stream;
		stream << compression.name << "#" << compression.value;
		return stream.str();
		}
		switch (getStandardCompressionValue(compression)) {
		case Compression::NONE:
		return "None";
		case Compression::DISPLAY_STREAM_COMPRESSION:
		return "DisplayStreamCompression";
		}
		}

		std::string getInterlacedName(const ExtendableType& interlaced) {
		if (!isStandardInterlaced(interlaced)) {
		std::ostringstream stream;
		stream << interlaced.name << "#" << interlaced.value;
		return stream.str();
		}
		switch (getStandardInterlacedValue(interlaced)) {
		case Interlaced::NONE:
		return "None";
		case Interlaced::TOP_BOTTOM:
		return "TopBottom";
		case Interlaced::RIGHT_LEFT:
		return "RightLeft";
		}
		}

		std::string getChromaSitingName(const ExtendableType& chromaSiting) {
		if (!isStandardChromaSiting(chromaSiting)) {
		std::ostringstream stream;
		stream << chromaSiting.name << "#" << chromaSiting.value;
		return stream.str();
		}
		switch (getStandardChromaSitingValue(chromaSiting)) {
		case ChromaSiting::NONE:
		return "None";
		case ChromaSiting::UNKNOWN:
		return "Unknown";
		case ChromaSiting::SITED_INTERSTITIAL:
		return "SitedInterstitial";
		case ChromaSiting::COSITED_HORIZONTAL:
		return "CositedHorizontal";
		}
		}

		std::string getPlaneLayoutComponentTypeName(const ExtendableType& planeLayoutComponentType) {
		if (!isStandardPlaneLayoutComponentType(planeLayoutComponentType)) {
		std::ostringstream stream;
		stream << planeLayoutComponentType.name << "#" << planeLayoutComponentType.value;
		return stream.str();
		}
		switch (getStandardPlaneLayoutComponentTypeValue(planeLayoutComponentType)) {
		case PlaneLayoutComponentType::Y:
		return "Y";
		case PlaneLayoutComponentType::CB:
		return "Cb";
		case PlaneLayoutComponentType::CR:
		return "Cr";
		case PlaneLayoutComponentType::R:
		return "R";
		case PlaneLayoutComponentType::G:
		return "G";
		case PlaneLayoutComponentType::B:
		return "B";
		case PlaneLayoutComponentType::A:
		return "A";
		}
		}

		} // namespace gralloc4

		} // namespace android

libs/gralloc/types/include/gralloctypes/Gralloc4.h

+113 −68

Original line number	Diff line number	Diff line
		@@ -34,10 +34,11 @@ namespace android {
		namespace gralloc4 {

		#define GRALLOC4_STANDARD_METADATA_TYPE "android.hardware.graphics.common.StandardMetadataType"
		#define GRALLOC4_CHROMA_SITING "android.hardware.graphics.common.ChromaSiting"
		#define GRALLOC4_COMPRESSION "android.hardware.graphics.common.Compression"
		#define GRALLOC4_INTERLACED "android.hardware.graphics.common.Interlaced"
		#define GRALLOC4_PLANE_LAYOUT_COMPONENT_TYPE "android.hardware.graphics.common.PlaneLayoutComponentType"
		#define GRALLOC4_STANDARD_CHROMA_SITING "android.hardware.graphics.common.ChromaSiting"
		#define GRALLOC4_STANDARD_COMPRESSION "android.hardware.graphics.common.Compression"
		#define GRALLOC4_STANDARD_INTERLACED "android.hardware.graphics.common.Interlaced"
		#define GRALLOC4_STANDARD_PLANE_LAYOUT_COMPONENT_TYPE \
		"android.hardware.graphics.common.PlaneLayoutComponentType"

		/---------------------------------------------------------------------------------------------/
		/**
		@@ -118,13 +119,15 @@ static const android::hardware::graphics::mapper::V4_0::IMapper::MetadataType Me
		* Definitions of the standard compression strategies. It is recommended that everyone uses
		* these definitions directly for standard compression strategies.
		*/
		static const aidl::android::hardware::graphics::common::ExtendableType Compression_None = {
		GRALLOC4_COMPRESSION, static_cast<int64_t>(aidl::android::hardware::graphics::common::Compression::NONE)
		};
		static const aidl::android::hardware::graphics::common::ExtendableType Compression_None =
		{GRALLOC4_STANDARD_COMPRESSION,
		static_cast<int64_t>(aidl::android::hardware::graphics::common::Compression::NONE)};

		static const aidl::android::hardware::graphics::common::ExtendableType Compression_DisplayStreamCompression = {
		GRALLOC4_COMPRESSION, static_cast<int64_t>(aidl::android::hardware::graphics::common::Compression::DISPLAY_STREAM_COMPRESSION)
		};
		static const aidl::android::hardware::graphics::common::ExtendableType
		Compression_DisplayStreamCompression =
		{GRALLOC4_STANDARD_COMPRESSION,
		static_cast<int64_t>(aidl::android::hardware::graphics::common::Compression::
		DISPLAY_STREAM_COMPRESSION)};

		/---------------------------------------------------------------------------------------------/

		@@ -132,17 +135,17 @@ static const aidl::android::hardware::graphics::common::ExtendableType Compressi
		* Definitions of the standard interlaced strategies. It is recommended that everyone uses
		* these definitions directly for standard interlaced strategies.
		*/
		static const aidl::android::hardware::graphics::common::ExtendableType Interlaced_None = {
		GRALLOC4_INTERLACED, static_cast<int64_t>(aidl::android::hardware::graphics::common::Interlaced::NONE)
		};
		static const aidl::android::hardware::graphics::common::ExtendableType Interlaced_None =
		{GRALLOC4_STANDARD_INTERLACED,
		static_cast<int64_t>(aidl::android::hardware::graphics::common::Interlaced::NONE)};

		static const aidl::android::hardware::graphics::common::ExtendableType Interlaced_TopBottom = {
		GRALLOC4_INTERLACED, static_cast<int64_t>(aidl::android::hardware::graphics::common::Interlaced::TOP_BOTTOM)
		};
		static const aidl::android::hardware::graphics::common::ExtendableType Interlaced_TopBottom =
		{GRALLOC4_STANDARD_INTERLACED,
		static_cast<int64_t>(aidl::android::hardware::graphics::common::Interlaced::TOP_BOTTOM)};

		static const aidl::android::hardware::graphics::common::ExtendableType Interlaced_RightLeft = {
		GRALLOC4_INTERLACED, static_cast<int64_t>(aidl::android::hardware::graphics::common::Interlaced::RIGHT_LEFT)
		};
		static const aidl::android::hardware::graphics::common::ExtendableType Interlaced_RightLeft =
		{GRALLOC4_STANDARD_INTERLACED,
		static_cast<int64_t>(aidl::android::hardware::graphics::common::Interlaced::RIGHT_LEFT)};

		/---------------------------------------------------------------------------------------------/

		@@ -150,21 +153,25 @@ static const aidl::android::hardware::graphics::common::ExtendableType Interlace
		* Definitions of the standard chroma siting. It is recommended that everyone uses
		* these definitions directly for standard chroma siting.
		*/
		static const aidl::android::hardware::graphics::common::ExtendableType ChromaSiting_None = {
		GRALLOC4_CHROMA_SITING, static_cast<int64_t>(aidl::android::hardware::graphics::common::ChromaSiting::NONE)
		};

		static const aidl::android::hardware::graphics::common::ExtendableType ChromaSiting_Unknown = {
		GRALLOC4_CHROMA_SITING, static_cast<int64_t>(aidl::android::hardware::graphics::common::ChromaSiting::UNKNOWN)
		};

		static const aidl::android::hardware::graphics::common::ExtendableType ChromaSiting_SitedInterstitial = {
		GRALLOC4_CHROMA_SITING, static_cast<int64_t>(aidl::android::hardware::graphics::common::ChromaSiting::SITED_INTERSTITIAL)
		};

		static const aidl::android::hardware::graphics::common::ExtendableType ChromaSiting_CositedHorizontal = {
		GRALLOC4_CHROMA_SITING, static_cast<int64_t>(aidl::android::hardware::graphics::common::ChromaSiting::COSITED_HORIZONTAL)
		};
		static const aidl::android::hardware::graphics::common::ExtendableType ChromaSiting_None =
		{GRALLOC4_STANDARD_CHROMA_SITING,
		static_cast<int64_t>(aidl::android::hardware::graphics::common::ChromaSiting::NONE)};

		static const aidl::android::hardware::graphics::common::ExtendableType ChromaSiting_Unknown =
		{GRALLOC4_STANDARD_CHROMA_SITING,
		static_cast<int64_t>(aidl::android::hardware::graphics::common::ChromaSiting::UNKNOWN)};

		static const aidl::android::hardware::graphics::common::ExtendableType
		ChromaSiting_SitedInterstitial = {GRALLOC4_STANDARD_CHROMA_SITING,
		static_cast<int64_t>(
		aidl::android::hardware::graphics::common::
		ChromaSiting::SITED_INTERSTITIAL)};

		static const aidl::android::hardware::graphics::common::ExtendableType
		ChromaSiting_CositedHorizontal = {GRALLOC4_STANDARD_CHROMA_SITING,
		static_cast<int64_t>(
		aidl::android::hardware::graphics::common::
		ChromaSiting::COSITED_HORIZONTAL)};

		/---------------------------------------------------------------------------------------------/

		@@ -172,43 +179,43 @@ static const aidl::android::hardware::graphics::common::ExtendableType ChromaSit
		* Definitions of the standard plane layout component types. It is recommended that everyone uses
		* these definitions directly for standard plane layout component types
		*/
		static const aidl::android::hardware::graphics::common::ExtendableType PlaneLayoutComponentType_Y = {
		GRALLOC4_PLANE_LAYOUT_COMPONENT_TYPE, static_cast<int64_t>(aidl::android::hardware::graphics::common::PlaneLayoutComponentType::Y)
		};

		static const aidl::android::hardware::graphics::common::ExtendableType PlaneLayoutComponentType_CB = {
		GRALLOC4_PLANE_LAYOUT_COMPONENT_TYPE, static_cast<int64_t>(aidl::android::hardware::graphics::common::PlaneLayoutComponentType::CB)
		};

		static const aidl::android::hardware::graphics::common::ExtendableType PlaneLayoutComponentType_CR = {
		GRALLOC4_PLANE_LAYOUT_COMPONENT_TYPE, static_cast<int64_t>(aidl::android::hardware::graphics::common::PlaneLayoutComponentType::CR)
		};

		static const aidl::android::hardware::graphics::common::ExtendableType PlaneLayoutComponentType_R = {
		GRALLOC4_PLANE_LAYOUT_COMPONENT_TYPE, static_cast<int64_t>(aidl::android::hardware::graphics::common::PlaneLayoutComponentType::R)
		};

		static const aidl::android::hardware::graphics::common::ExtendableType PlaneLayoutComponentType_G = {
		GRALLOC4_PLANE_LAYOUT_COMPONENT_TYPE, static_cast<int64_t>(aidl::android::hardware::graphics::common::PlaneLayoutComponentType::G)
		};

		static const aidl::android::hardware::graphics::common::ExtendableType PlaneLayoutComponentType_B = {
		GRALLOC4_PLANE_LAYOUT_COMPONENT_TYPE, static_cast<int64_t>(aidl::android::hardware::graphics::common::PlaneLayoutComponentType::B)
		};

		static const aidl::android::hardware::graphics::common::ExtendableType PlaneLayoutComponentType_A = {
		GRALLOC4_PLANE_LAYOUT_COMPONENT_TYPE, static_cast<int64_t>(aidl::android::hardware::graphics::common::PlaneLayoutComponentType::A)
		};
		static const aidl::android::hardware::graphics::common::ExtendableType PlaneLayoutComponentType_Y =
		{GRALLOC4_STANDARD_PLANE_LAYOUT_COMPONENT_TYPE,
		static_cast<int64_t>(
		aidl::android::hardware::graphics::common::PlaneLayoutComponentType::Y)};

		static const aidl::android::hardware::graphics::common::ExtendableType PlaneLayoutComponentType_CB =
		{GRALLOC4_STANDARD_PLANE_LAYOUT_COMPONENT_TYPE,
		static_cast<int64_t>(
		aidl::android::hardware::graphics::common::PlaneLayoutComponentType::CB)};

		static const aidl::android::hardware::graphics::common::ExtendableType PlaneLayoutComponentType_CR =
		{GRALLOC4_STANDARD_PLANE_LAYOUT_COMPONENT_TYPE,
		static_cast<int64_t>(
		aidl::android::hardware::graphics::common::PlaneLayoutComponentType::CR)};

		static const aidl::android::hardware::graphics::common::ExtendableType PlaneLayoutComponentType_R =
		{GRALLOC4_STANDARD_PLANE_LAYOUT_COMPONENT_TYPE,
		static_cast<int64_t>(
		aidl::android::hardware::graphics::common::PlaneLayoutComponentType::R)};

		static const aidl::android::hardware::graphics::common::ExtendableType PlaneLayoutComponentType_G =
		{GRALLOC4_STANDARD_PLANE_LAYOUT_COMPONENT_TYPE,
		static_cast<int64_t>(
		aidl::android::hardware::graphics::common::PlaneLayoutComponentType::G)};

		static const aidl::android::hardware::graphics::common::ExtendableType PlaneLayoutComponentType_B =
		{GRALLOC4_STANDARD_PLANE_LAYOUT_COMPONENT_TYPE,
		static_cast<int64_t>(
		aidl::android::hardware::graphics::common::PlaneLayoutComponentType::B)};

		static const aidl::android::hardware::graphics::common::ExtendableType PlaneLayoutComponentType_A =
		{GRALLOC4_STANDARD_PLANE_LAYOUT_COMPONENT_TYPE,
		static_cast<int64_t>(
		aidl::android::hardware::graphics::common::PlaneLayoutComponentType::A)};

		/---------------------------------------------------------------------------------------------/

		/**
		* The functions below can be used to parse a StandardMetadataType.
		*/
		bool isStandardMetadataType(const android::hardware::graphics::mapper::V4_0::IMapper::MetadataType& metadataType);

		aidl::android::hardware::graphics::common::StandardMetadataType getStandardMetadataTypeValue(const android::hardware::graphics::mapper::V4_0::IMapper::MetadataType& metadataType);

		/**
		* The functions below encode and decode standard metadata into a byte stream. It is STRONGLY
		* recommended that both the vendor and system partitions use these functions when getting
		@@ -265,6 +272,44 @@ status_t decodeDataspace(const android::hardware::hidl_vec<uint8_t>& dataspace,
		status_t encodeBlendMode(const aidl::android::hardware::graphics::common::BlendMode& blendMode, android::hardware::hidl_vec<uint8_t>* outBlendMode);
		status_t decodeBlendMode(const android::hardware::hidl_vec<uint8_t>& blendMode, aidl::android::hardware::graphics::common::BlendMode* outBlendMode);

		/**
		* The functions below can be used to parse extendable types.
		*/
		bool isStandardMetadataType(
		const android::hardware::graphics::mapper::V4_0::IMapper::MetadataType& metadataType);
		bool isStandardCompression(
		const aidl::android::hardware::graphics::common::ExtendableType& compression);
		bool isStandardInterlaced(
		const aidl::android::hardware::graphics::common::ExtendableType& interlaced);
		bool isStandardChromaSiting(
		const aidl::android::hardware::graphics::common::ExtendableType& chromaSiting);
		bool isStandardPlaneLayoutComponentType(
		const aidl::android::hardware::graphics::common::ExtendableType& planeLayoutComponentType);

		aidl::android::hardware::graphics::common::StandardMetadataType getStandardMetadataTypeValue(
		const android::hardware::graphics::mapper::V4_0::IMapper::MetadataType& metadataType);
		aidl::android::hardware::graphics::common::Compression getStandardCompressionValue(
		const aidl::android::hardware::graphics::common::ExtendableType& compression);
		aidl::android::hardware::graphics::common::Interlaced getStandardInterlacedValue(
		const aidl::android::hardware::graphics::common::ExtendableType& interlaced);
		aidl::android::hardware::graphics::common::ChromaSiting getStandardChromaSitingValue(
		const aidl::android::hardware::graphics::common::ExtendableType& chromaSiting);
		aidl::android::hardware::graphics::common::PlaneLayoutComponentType
		getStandardPlaneLayoutComponentTypeValue(
		const aidl::android::hardware::graphics::common::ExtendableType& planeLayoutComponentType);

		/**
		* The functions below return string representations of ExtendableTypes
		*/
		std::string getCompressionName(
		const aidl::android::hardware::graphics::common::ExtendableType& compression);
		std::string getInterlacedName(
		const aidl::android::hardware::graphics::common::ExtendableType& interlaced);
		std::string getChromaSitingName(
		const aidl::android::hardware::graphics::common::ExtendableType& chromaSiting);
		std::string getPlaneLayoutComponentTypeName(
		const aidl::android::hardware::graphics::common::ExtendableType& planeLayoutComponentType);

		} // namespace gralloc4

		} // namespace android

libs/renderengine/include/renderengine/DisplaySettings.h

+28 −0

Original line number	Diff line number	Diff line
		@@ -16,6 +16,8 @@

		#pragma once

		#include <iosfwd>

		#include <math/mat4.h>
		#include <ui/GraphicTypes.h>
		#include <ui/Rect.h>
		@@ -62,5 +64,31 @@ struct DisplaySettings {
		uint32_t orientation = ui::Transform::ROT_0;
		};

		static inline bool operator==(const DisplaySettings& lhs, const DisplaySettings& rhs) {
		return lhs.physicalDisplay == rhs.physicalDisplay && lhs.clip == rhs.clip &&
		lhs.globalTransform == rhs.globalTransform && lhs.maxLuminance == rhs.maxLuminance &&
		lhs.outputDataspace == rhs.outputDataspace &&
		lhs.colorTransform == rhs.colorTransform &&
		lhs.clearRegion.hasSameRects(rhs.clearRegion) && lhs.orientation == rhs.orientation;
		}

		// Defining PrintTo helps with Google Tests.
		static inline void PrintTo(const DisplaySettings& settings, ::std::ostream* os) {
		*os << "DisplaySettings {";
		*os << "\n .physicalDisplay = ";
		PrintTo(settings.physicalDisplay, os);
		*os << "\n .clip = ";
		PrintTo(settings.clip, os);
		*os << "\n .globalTransform = " << settings.globalTransform;
		*os << "\n .maxLuminance = " << settings.maxLuminance;
		*os << "\n .outputDataspace = ";
		PrintTo(settings.outputDataspace, os);
		*os << "\n .colorTransform = " << settings.colorTransform;
		*os << "\n .clearRegion = ";
		PrintTo(settings.clearRegion, os);
		*os << "\n .orientation = " << settings.orientation;
		*os << "\n}";
		}

		} // namespace renderengine
		} // namespace android