Merge changes from topic "evs_on_osprey" (3729f2c6) · Commits · e / os / platform_frameworks_native

libs/bufferqueueconverter/Android.bp

0 → 100644

+28 −0

Original line number	Diff line number	Diff line
		cc_library_headers {
		name: "libbufferqueueconverter_headers",
		vendor_available: true,
		export_include_dirs: ["include"],
		}

		cc_library_shared {
		name: "libbufferqueueconverter",
		vendor_available: true,
		vndk: {
		enabled: true,
		},
		double_loadable: true,

		srcs: [
		"BufferQueueConverter.cpp",
		],

		shared_libs: [
		"libgui",
		"libui",
		"libutils",
		"libbinder",
		"libbase",
		"liblog",
		],
		export_include_dirs: ["include"],
		}

libs/bufferqueueconverter/BufferQueueConverter.cpp

0 → 100644

+74 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2020 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.
		*/

		#include <gui/Surface.h>
		#include <gui/bufferqueue/2.0/H2BGraphicBufferProducer.h>

		#include "include/bufferqueueconverter/BufferQueueConverter.h"


		using ::android::Surface;
		using ::android::IGraphicBufferProducer;
		using ::android::hardware::graphics::bufferqueue::V2_0::utils::H2BGraphicBufferProducer;


		namespace android {

		struct SurfaceHolder {
		sp<Surface> surface;
		SurfaceHolder(const sp<Surface>& s) : surface(s) {}
		};

		/**
		* Custom deleter for SurfaceHolder unique pointer
		*/
		void destroySurfaceHolder(SurfaceHolder* surfaceHolder) {
		delete surfaceHolder;
		}


		SurfaceHolderUniquePtr getSurfaceFromHGBP(const sp<HGraphicBufferProducer>& token) {
		if (token == nullptr) {
		ALOGE("Passed IGraphicBufferProducer handle is invalid.");
		return SurfaceHolderUniquePtr(nullptr, nullptr);
		}

		sp<IGraphicBufferProducer> bufferProducer = new H2BGraphicBufferProducer(token);
		if (bufferProducer == nullptr) {
		ALOGE("Failed to get IGraphicBufferProducer.");
		return SurfaceHolderUniquePtr(nullptr, nullptr);
		}

		sp<Surface> newSurface(new Surface(bufferProducer, true));
		if (newSurface == nullptr) {
		ALOGE("Failed to create Surface from HGBP.");
		return SurfaceHolderUniquePtr(nullptr, nullptr);
		}

		return SurfaceHolderUniquePtr(new SurfaceHolder(newSurface), destroySurfaceHolder);
		}


		ANativeWindow* getNativeWindow(SurfaceHolder* handle) {
		if (handle == nullptr) {
		ALOGE("SurfaceHolder is invalid.");
		return nullptr;
		}

		return static_cast<ANativeWindow*>(handle->surface.get());
		}

		} // namespace android

libs/bufferqueueconverter/include/bufferqueueconverter/BufferQueueConverter.h

0 → 100644

+58 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2020 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.
		*/

		#ifndef ANDROID_BUFFER_QUEUE_CONVERTER_H
		#define ANDROID_BUFFER_QUEUE_CONVERTER_H

		#include <gui/IGraphicBufferProducer.h>
		#include <android/native_window.h>

		using ::android::sp;
		using HGraphicBufferProducer =
		::android::hardware::graphics::bufferqueue::V2_0::IGraphicBufferProducer;

		namespace android {
		/**
		* Opaque handle for a data structure holding Surface.
		*/
		typedef struct SurfaceHolder SurfaceHolder;

		/**
		* SurfaceHolder unique pointer type
		*/
		using SurfaceHolderUniquePtr = std::unique_ptr<SurfaceHolder, void()(SurfaceHolder)>;

		/**
		* Returns a SurfaceHolder that wraps a Surface generated from a given HGBP.
		*
		* @param token Hardware IGraphicBufferProducer to create a
		* Surface.
		* @return SurfaceHolder Unique pointer to created SurfaceHolder object.
		*/
		SurfaceHolderUniquePtr getSurfaceFromHGBP(const sp<HGraphicBufferProducer>& token);

		/**
		* Returns ANativeWindow pointer from a given SurfaceHolder. Returned
		* pointer is valid only while the containing SurfaceHolder is alive.
		*
		* @param surfaceHolder SurfaceHolder to generate a native window.
		* @return ANativeWindow* a pointer to a generated native window.
		*/
		ANativeWindow* getNativeWindow(SurfaceHolder* surfaceHolder);

		} // namespace android

		#endif // ANDROID_BUFFER_QUEUE_CONVERTER_H

services/automotive/display/CarWindowService.cpp

+5 −9

Original line number	Diff line number	Diff line
		@@ -17,8 +17,6 @@
		#include <utility>

		#include <gui/bufferqueue/2.0/B2HGraphicBufferProducer.h>
		#include <ui/DisplayConfig.h>
		#include <ui/DisplayState.h>

		#include "CarWindowService.h"

		@@ -48,26 +46,24 @@ Return<sp<IGraphicBufferProducer>>
		return nullptr;
		}

		DisplayConfig displayConfig;
		err = SurfaceComposerClient::getActiveDisplayConfig(displayToken, &displayConfig);
		err = SurfaceComposerClient::getActiveDisplayConfig(displayToken, &mDpyConfig);
		if (err != NO_ERROR) {
		ALOGE("Failed to get active display config");
		return nullptr;
		}

		ui::DisplayState displayState;
		err = SurfaceComposerClient::getDisplayState(displayToken, &displayState);
		err = SurfaceComposerClient::getDisplayState(displayToken, &mDpyState);
		if (err != NO_ERROR) {
		ALOGE("Failed to get display state");
		return nullptr;
		}

		const ui::Size& resolution = displayConfig.resolution;
		const ui::Size& resolution = mDpyConfig.resolution;
		auto width = resolution.getWidth();
		auto height = resolution.getHeight();

		if (displayState.orientation == ui::ROTATION_90 \|\|
		displayState.orientation == ui::ROTATION_270) {
		if (mDpyState.orientation == ui::ROTATION_90 \|\|
		mDpyState.orientation == ui::ROTATION_270) {
		std::swap(width, height);
		}

services/automotive/display/include/CarWindowService.h

+14 −0

Original line number	Diff line number	Diff line
		@@ -20,6 +20,8 @@
		#include <gui/IGraphicBufferProducer.h>
		#include <gui/Surface.h>
		#include <gui/SurfaceComposerClient.h>
		#include <ui/DisplayConfig.h>
		#include <ui/DisplayState.h>

		namespace android {
		namespace frameworks {
		@@ -37,11 +39,23 @@ public:
		Return<sp<IGraphicBufferProducer>> getIGraphicBufferProducer() override;
		Return<bool> showWindow() override;
		Return<bool> hideWindow() override;
		Return<void> getDisplayInfo(getDisplayInfo_cb _info_cb) override {
		HwDisplayConfig cfg;
		cfg.setToExternal((uint8_t*)&mDpyConfig, sizeof(DisplayConfig));

		HwDisplayState state;
		state.setToExternal((uint8_t*)&mDpyState, sizeof(DisplayState));

		_info_cb(cfg, state);
		return hardware::Void();
		}

		private:
		sp<android::Surface> mSurface;
		sp<android::SurfaceComposerClient> mSurfaceComposerClient;
		sp<android::SurfaceControl> mSurfaceControl;
		DisplayConfig mDpyConfig;
		ui::DisplayState mDpyState;
		};
		} // namespace implementation
		} // namespace V1_0