Merge "Merged vr window manager and vr composer" (0814c36b) · Commits · e / os / platform_frameworks_native

services/vr/vr_window_manager/Android.mk

+1 −0

Original line number	Diff line number	Diff line
		@@ -71,6 +71,7 @@ shared_libs := \
		libbinder \
		libinput \
		libhardware \
		libhwbinder \
		libsync \
		libutils \
		libgui \

services/vr/vr_window_manager/application.cpp

+2 −2

Original line number	Diff line number	Diff line
		@@ -123,8 +123,8 @@ void Application::ProcessTasks(const std::vector<MainThreadTask>& tasks) {
		break;
		case MainThreadTask::EnteringVrMode:
		if (!initialized_) {
		if (AllocateResources())
		ALOGE("Failed to allocate resources");
		LOG_ALWAYS_FATAL_IF(AllocateResources(),
		"Failed to allocate resources");
		}
		break;
		case MainThreadTask::ExitingVrMode:

services/vr/vr_window_manager/composer/impl/vr_composer_view.cpp

+8 −53

Original line number	Diff line number	Diff line
		@@ -3,7 +3,9 @@
		namespace android {
		namespace dvr {

		VrComposerView::VrComposerView() : composer_view_(nullptr) {}
		VrComposerView::VrComposerView(
		std::unique_ptr<VrComposerView::Callback> callback)
		: composer_view_(nullptr), callback_(std::move(callback)) {}

		VrComposerView::~VrComposerView() {
		composer_view_->UnregisterObserver(this);
		@@ -14,66 +16,19 @@ void VrComposerView::Initialize(ComposerView* composer_view) {
		composer_view_->RegisterObserver(this);
		}

		Return<void> VrComposerView::registerCallback(
		const sp<IVrComposerCallback>& callback) {
		callback_ = callback;
		return Void();
		}

		Return<void> VrComposerView::releaseFrame() {
		void VrComposerView::ReleaseFrame() {
		LOG_ALWAYS_FATAL_IF(!composer_view_, "VrComposerView not initialized");
		composer_view_->ReleaseFrame();
		return Void();
		}

		void VrComposerView::OnNewFrame(const ComposerView::Frame& frame) {
		std::lock_guard<std::mutex> guard(mutex_);
		if (!callback_.get()) {
		releaseFrame();
		ReleaseFrame();
		return;
		}

		std::vector<IVrComposerCallback::Layer> layers;
		std::vector<native_handle_t*> fences;
		for (size_t i = 0; i < frame.size(); ++i) {
		native_handle_t* fence;
		if (frame[i].fence->isValid()) {
		fence = native_handle_create(1, 0);
		fence->data[0] = frame[i].fence->dup();
		} else {
		fence = native_handle_create(0, 0);
		}
		fences.push_back(fence);

		layers.push_back(IVrComposerCallback::Layer{
		.buffer = hidl_handle(frame[i].buffer->getNativeBuffer()->handle),
		.fence = hidl_handle(fence),
		.display_frame = frame[i].display_frame,
		.crop = frame[i].crop,
		.blend_mode= frame[i].blend_mode,
		.alpha = frame[i].alpha,
		.type = frame[i].type,
		.app_id = frame[i].app_id,
		});
		}

		auto status =
		callback_->onNewFrame(hidl_vec<IVrComposerCallback::Layer>(layers));
		if (!status.isOk()) {
		ALOGE("Failed to send onNewFrame: %s", status.description().c_str());
		releaseFrame();
		}

		for (size_t i = 0; i < fences.size(); ++i) {
		native_handle_close(fences[i]);
		native_handle_delete(fences[i]);
		}
		}

		VrComposerView* GetVrComposerViewFromIVrComposerView(IVrComposerView* view) {
		return static_cast<VrComposerView*>(view);
		}

		IVrComposerView* HIDL_FETCH_IVrComposerView(const char* name) {
		return new VrComposerView();
		callback_->OnNewFrame(frame);
		}

		} // namespace dvr

services/vr/vr_window_manager/composer/impl/vr_composer_view.h

+12 −16

Original line number	Diff line number	Diff line
		#ifndef VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_COMPOSER_VIEW_H_
		#define VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_COMPOSER_VIEW_H_

		#include <android/dvr/composer/1.0/IVrComposerCallback.h>
		#include <android/dvr/composer/1.0/IVrComposerView.h>
		#include <memory>

		#include "vr_hwc.h"

		namespace android {
		namespace dvr {

		using composer::V1_0::IVrComposerView;
		using composer::V1_0::IVrComposerCallback;

		class VrComposerView : public IVrComposerView, public ComposerView::Observer {
		class VrComposerView : public ComposerView::Observer {
		public:
		class Callback {
		public:
		VrComposerView();
		virtual ~Callback() = default;
		virtual void OnNewFrame(const ComposerView::Frame& frame) = 0;
		};

		VrComposerView(std::unique_ptr<Callback> callback);
		~VrComposerView() override;

		void Initialize(ComposerView* composer_view);

		// IVrComposerView
		Return<void> registerCallback(const sp<IVrComposerCallback>& callback)
		override;
		Return<void> releaseFrame() override;
		void ReleaseFrame();

		// ComposerView::Observer
		void OnNewFrame(const ComposerView::Frame& frame) override;

		private:
		ComposerView* composer_view_;
		sp<IVrComposerCallback> callback_;
		std::unique_ptr<Callback> callback_;
		std::mutex mutex_;
		};

		VrComposerView* GetVrComposerViewFromIVrComposerView(IVrComposerView* view);

		IVrComposerView* HIDL_FETCH_IVrComposerView(const char* name);

		} // namespace dvr
		} // namespace android

services/vr/vr_window_manager/hwc_callback.cpp

+4 −16

Original line number	Diff line number	Diff line
		@@ -63,27 +63,18 @@ HwcCallback::FrameStatus GetFrameStatus(const HwcCallback::Frame& frame) {

		} // namespace

		HwcCallback::HwcCallback(IVrComposerView* composer_view, Client* client)
		: composer_view_(composer_view),
		client_(client) {
		composer_view_->registerCallback(this);
		HwcCallback::HwcCallback(Client* client) : client_(client) {
		}

		HwcCallback::~HwcCallback() {
		composer_view_->registerCallback(nullptr);
		}

		Return<void> HwcCallback::onNewFrame(
		const hidl_vec<IVrComposerCallback::Layer>& frame) {

		void HwcCallback::OnNewFrame(const ComposerView::Frame& frame) {
		std::vector<HwcLayer> hwc_frame(frame.size());
		for (size_t i = 0; i < frame.size(); ++i) {
		int fence = frame[i].fence.getNativeHandle()->numFds ?
		dup(frame[i].fence.getNativeHandle()->data[0]) : -1;

		hwc_frame[i] = HwcLayer{
		.fence = new Fence(fence),
		.buffer = GetBufferFromHandle(frame[i].buffer.getNativeHandle()),
		.fence = frame[i].fence,
		.buffer = frame[i].buffer,
		.crop = frame[i].crop,
		.display_frame = frame[i].display_frame,
		.blending = static_cast<int32_t>(frame[i].blend_mode),
		@@ -93,10 +84,7 @@ Return<void> HwcCallback::onNewFrame(
		};
		}

		std::lock_guard<std::mutex> guard(mutex_);
		client_->OnFrame(std::make_unique<Frame>(std::move(hwc_frame)));

		return Void();
		}

		HwcCallback::Frame::Frame(std::vector<HwcLayer>&& layers)