hwc3/ComposerClient.cpp - platform/hardware/google/graphics/common - Git at Google

 /*
  * Copyright (C) 2021 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.
  */

 #define ATRACE_TAG (ATRACE_TAG_GRAPHICS | ATRACE_TAG_HAL)

 #include "ComposerClient.h"

 #include <android-base/logging.h>
 #include <android/binder_ibinder_platform.h>

 #include "Util.h"

 namespace aidl::android::hardware::graphics::composer3::impl {

 bool ComposerClient::init() {
     DEBUG_FUNC();
     mResources = IResourceManager::create();
     if (!mResources) {
         LOG(ERROR) << "failed to create composer resources";
         return false;
     }

     mCommandEngine = std::make_unique<ComposerCommandEngine>(mHal, mResources.get());
     if (mCommandEngine == nullptr) {
         return false;
     }
     if (!mCommandEngine->init()) {
         mCommandEngine = nullptr;
         return false;
     }

     return true;
 }

 ComposerClient::~ComposerClient() {
     DEBUG_FUNC();
     // not initialized
     if (!mCommandEngine) {
         return;
     }

     LOG(DEBUG) << "destroying composer client";

     mHal->unregisterEventCallback();
     destroyResources();

     if (mOnClientDestroyed) {
         mOnClientDestroyed();
     }

     LOG(DEBUG) << "removed composer client";
 }

 // no need to check nullptr for output parameter, the aidl stub code won't pass nullptr
 ndk::ScopedAStatus ComposerClient::createLayer(int64_t display, int32_t bufferSlotCount,
                                                int64_t* layer) {
     DEBUG_FUNC();
     auto err = mHal->createLayer(display, layer);
     if (!err) {
         err = mResources->addLayer(display, *layer, bufferSlotCount);
         if (err) {
             layer = 0;
         }
     }
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::createVirtualDisplay(int32_t width, int32_t height,
                                                         AidlPixelFormat formatHint,
                                                         int32_t outputBufferSlotCount,
                                                         VirtualDisplay* display) {
     DEBUG_FUNC();
     auto err = mHal->createVirtualDisplay(width, height, formatHint, display);
     if (!err) {
         err = mResources->addVirtualDisplay(display->display, outputBufferSlotCount);
     }
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::destroyLayer(int64_t display, int64_t layer) {
     DEBUG_FUNC();
     auto err = mHal->destroyLayer(display, layer);
     if (!err) {
         err = mResources->removeLayer(display, layer);
     }
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::destroyVirtualDisplay(int64_t display) {
     DEBUG_FUNC();
     auto err = mHal->destroyVirtualDisplay(display);
     if (!err) {
         err = mResources->removeDisplay(display);
     }
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::executeCommands(const std::vector<DisplayCommand>& commands,
                                                    std::vector<CommandResultPayload>* results) {
     DEBUG_FUNC();
     auto err = mCommandEngine->execute(commands, results);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::getActiveConfig(int64_t display, int32_t* config) {
     DEBUG_FUNC();
     auto err = mHal->getActiveConfig(display, config);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::getColorModes(int64_t display,
                                                  std::vector<ColorMode>* colorModes) {
     DEBUG_FUNC();
     auto err = mHal->getColorModes(display, colorModes);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::getDataspaceSaturationMatrix(common::Dataspace dataspace,
                                                                 std::vector<float>* matrix) {
     DEBUG_FUNC();
     if (dataspace != common::Dataspace::SRGB_LINEAR) {
         return TO_BINDER_STATUS(EX_BAD_PARAMETER);
     }

     auto err = mHal->getDataspaceSaturationMatrix(dataspace, matrix);
     if (err) {
         constexpr std::array<float, 16> unit {
                 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
                 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
         };
         matrix->clear();
         matrix->insert(matrix->begin(), unit.begin(), unit.end());
     }
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::getDisplayAttribute(int64_t display, int32_t config,
                                                        DisplayAttribute attribute, int32_t* value) {
     DEBUG_FUNC();
     auto err = mHal->getDisplayAttribute(display, config, attribute, value);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::getDisplayCapabilities(int64_t display,
                                                           std::vector<DisplayCapability>* caps) {
     DEBUG_FUNC();
     auto err = mHal->getDisplayCapabilities(display, caps);
     if (err) {
         return TO_BINDER_STATUS(err);
     }

     bool support = false;
     err = mHal->getDisplayIdleTimerSupport(display, support);
     if (err != ::android::OK) {
         LOG(ERROR) << "failed to getDisplayIdleTimerSupport: " << err;
     }

     if (support) {
         caps->push_back(DisplayCapability::DISPLAY_IDLE_TIMER);
     }

     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::getDisplayConfigs(int64_t display,
                                                      std::vector<int32_t>* configs) {
     DEBUG_FUNC();
     auto err = mHal->getDisplayConfigs(display, configs);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::getDisplayConnectionType(int64_t display,
                                                             DisplayConnectionType* type) {
     DEBUG_FUNC();
     auto err = mHal->getDisplayConnectionType(display, type);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::getDisplayIdentificationData(int64_t display,
                                                                 DisplayIdentification* id) {
     DEBUG_FUNC();
     auto err = mHal->getDisplayIdentificationData(display, id);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::getDisplayName(int64_t display, std::string* name) {
     DEBUG_FUNC();
     auto err = mHal->getDisplayName(display, name);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::getDisplayVsyncPeriod(int64_t display, int32_t* vsyncPeriod) {
     DEBUG_FUNC();
     auto err = mHal->getDisplayVsyncPeriod(display, vsyncPeriod);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::getDisplayedContentSample(int64_t display, int64_t maxFrames,
                                                              int64_t timestamp,
                                                              DisplayContentSample* samples) {
     DEBUG_FUNC();
     auto err = mHal->getDisplayedContentSample(display, maxFrames, timestamp, samples);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::getDisplayedContentSamplingAttributes(
         int64_t display, DisplayContentSamplingAttributes* attrs) {
     DEBUG_FUNC();
     auto err = mHal->getDisplayedContentSamplingAttributes(display, attrs);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::getDisplayPhysicalOrientation(int64_t display,
                                                                  common::Transform* orientation) {
     DEBUG_FUNC();
     auto err = mHal->getDisplayPhysicalOrientation(display, orientation);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::getHdrCapabilities(int64_t display, HdrCapabilities* caps) {
     DEBUG_FUNC();
     auto err = mHal->getHdrCapabilities(display, caps);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::getMaxVirtualDisplayCount(int32_t* count) {
     DEBUG_FUNC();
     auto err = mHal->getMaxVirtualDisplayCount(count);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::getPerFrameMetadataKeys(int64_t display,
                                                            std::vector<PerFrameMetadataKey>* keys) {
     DEBUG_FUNC();
     auto err = mHal->getPerFrameMetadataKeys(display, keys);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::getReadbackBufferAttributes(int64_t display,
                                                                ReadbackBufferAttributes* attrs) {
     DEBUG_FUNC();
     auto err = mHal->getReadbackBufferAttributes(display, attrs);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::getReadbackBufferFence(int64_t display,
                                                           ndk::ScopedFileDescriptor* acquireFence) {
     DEBUG_FUNC();
     auto err = mHal->getReadbackBufferFence(display, acquireFence);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::getRenderIntents(int64_t display, ColorMode mode,
                                                     std::vector<RenderIntent>* intents) {
     DEBUG_FUNC();
     auto err = mHal->getRenderIntents(display, mode, intents);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::getSupportedContentTypes(int64_t display,
                                                             std::vector<ContentType>* types) {
     DEBUG_FUNC();
     auto err = mHal->getSupportedContentTypes(display, types);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::getDisplayDecorationSupport(
         int64_t display, std::optional<common::DisplayDecorationSupport>* supportStruct) {
     DEBUG_FUNC();
     bool support = false;
     auto err = mHal->getRCDLayerSupport(display, support);
     if (err != ::android::OK) {
         LOG(ERROR) << "failed to getRCDLayerSupport: " << err;
     }
     if (support) {
         // TODO (b/218499393): determine from mHal instead of hard coding.
         auto& s = supportStruct->emplace();
         s.format = common::PixelFormat::R_8;
         s.alphaInterpretation = common::AlphaInterpretation::COVERAGE;
     } else {
         supportStruct->reset();
     }
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::registerCallback(
         const std::shared_ptr<IComposerCallback>& callback) {
     DEBUG_FUNC();
     // no locking as we require this function to be called only once
     mHalEventCallback = std::make_unique<HalEventCallback>(mHal, mResources.get(), callback);
     mHal->registerEventCallback(mHalEventCallback.get());
     return ndk::ScopedAStatus::ok();
 }

 ndk::ScopedAStatus ComposerClient::setActiveConfig(int64_t display, int32_t config) {
     DEBUG_FUNC();
     auto err = mHal->setActiveConfig(display, config);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::setActiveConfigWithConstraints(
         int64_t display, int32_t config, const VsyncPeriodChangeConstraints& constraints,
         VsyncPeriodChangeTimeline* timeline) {
     DEBUG_FUNC();
     auto err = mHal->setActiveConfigWithConstraints(display, config, constraints, timeline);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::setBootDisplayConfig(int64_t display, int32_t config) {
     DEBUG_FUNC();
     auto err = mHal->setBootDisplayConfig(display, config);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::clearBootDisplayConfig(int64_t display) {
     DEBUG_FUNC();
     auto err = mHal->clearBootDisplayConfig(display);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::getPreferredBootDisplayConfig(int64_t display, int32_t* config) {
     DEBUG_FUNC();
     auto err = mHal->getPreferredBootDisplayConfig(display, config);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::setAutoLowLatencyMode(int64_t display, bool on) {
     DEBUG_FUNC();
     auto err = mHal->setAutoLowLatencyMode(display, on);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::setClientTargetSlotCount(int64_t display, int32_t count) {
     DEBUG_FUNC();
     auto err = mResources->setDisplayClientTargetCacheSize(display, count);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::setColorMode(int64_t display, ColorMode mode,
                                                 RenderIntent intent) {
     DEBUG_FUNC();
     auto err = mHal->setColorMode(display, mode, intent);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::setContentType(int64_t display, ContentType type) {
     DEBUG_FUNC();
     auto err = mHal->setContentType(display, type);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::setDisplayedContentSamplingEnabled(
         int64_t display, bool enable, FormatColorComponent componentMask, int64_t maxFrames) {
     DEBUG_FUNC();
     auto err = mHal->setDisplayedContentSamplingEnabled(display, enable, componentMask, maxFrames);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::setPowerMode(int64_t display, PowerMode mode) {
     DEBUG_FUNC();
     auto err = mHal->setPowerMode(display, mode);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::setReadbackBuffer(
         int64_t display, const AidlNativeHandle& aidlBuffer,
         const ndk::ScopedFileDescriptor& releaseFence) {
     DEBUG_FUNC();
     buffer_handle_t readbackBuffer;
     // Note ownership of the buffer is not passed to resource manager.
     buffer_handle_t buffer = ::android::makeFromAidl(aidlBuffer);
     auto bufReleaser = mResources->createReleaser(true /* isBuffer */);
     auto err = mResources->getDisplayReadbackBuffer(display, buffer,
                                                     readbackBuffer, bufReleaser.get());
     if (!err) {
         err = mHal->setReadbackBuffer(display, readbackBuffer, releaseFence);
     }
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::setVsyncEnabled(int64_t display, bool enabled) {
     DEBUG_FUNC();
     auto err = mHal->setVsyncEnabled(display, enabled);
     return TO_BINDER_STATUS(err);
 }

 ndk::ScopedAStatus ComposerClient::setIdleTimerEnabled(int64_t display, int32_t timeout) {
     DEBUG_FUNC();
     auto err = mHal->setIdleTimerEnabled(display, timeout);
     return TO_BINDER_STATUS(err);
 }

 void ComposerClient::HalEventCallback::onHotplug(int64_t display, bool connected) {
     DEBUG_FUNC();
     if (connected) {
         if (mResources->hasDisplay(display)) {
             // This is a subsequent hotplug "connected" for a display. This signals a
             // display change and thus the framework may want to reallocate buffers. We
             // need to free all cached handles, since they are holding a strong reference
             // to the underlying buffers.
             cleanDisplayResources(display);
             mResources->removeDisplay(display);
         }
         mResources->addPhysicalDisplay(display);
     } else {
         mResources->removeDisplay(display);
     }

     auto ret = mCallback->onHotplug(display, connected);
     if (!ret.isOk()) {
         LOG(ERROR) << "failed to send onHotplug:" << ret.getDescription();
     }
 }

 void ComposerClient::HalEventCallback::onRefresh(int64_t display) {
     DEBUG_FUNC();
     mResources->setDisplayMustValidateState(display, true);
     auto ret = mCallback->onRefresh(display);
     if (!ret.isOk()) {
         LOG(ERROR) << "failed to send onRefresh:" << ret.getDescription();
     }
 }

 void ComposerClient::HalEventCallback::onVsync(int64_t display, int64_t timestamp,
                                                int32_t vsyncPeriodNanos) {
     DEBUG_FUNC();
     auto ret = mCallback->onVsync(display, timestamp, vsyncPeriodNanos);
     if (!ret.isOk()) {
         LOG(ERROR) << "failed to send onVsync:" << ret.getDescription();
     }
 }

 void ComposerClient::HalEventCallback::onVsyncPeriodTimingChanged(
         int64_t display, const VsyncPeriodChangeTimeline& timeline) {
     DEBUG_FUNC();
     auto ret = mCallback->onVsyncPeriodTimingChanged(display, timeline);
     if (!ret.isOk()) {
         LOG(ERROR) << "failed to send onVsyncPeriodTimingChanged:" << ret.getDescription();
     }
 }

 void ComposerClient::HalEventCallback::onVsyncIdle(int64_t display) {
     DEBUG_FUNC();
     auto ret = mCallback->onVsyncIdle(display);
     if (!ret.isOk()) {
         LOG(ERROR) << "failed to send onVsyncIdle:" << ret.getDescription();
     }
 }

 void ComposerClient::HalEventCallback::onSeamlessPossible(int64_t display) {
     DEBUG_FUNC();
     auto ret = mCallback->onSeamlessPossible(display);
     if (!ret.isOk()) {
         LOG(ERROR) << "failed to send onSealmessPossible:" << ret.getDescription();
     }
 }

 void ComposerClient::HalEventCallback::cleanDisplayResources(int64_t display) {
     DEBUG_FUNC();
     size_t cacheSize;
     auto err = mResources->getDisplayClientTargetCacheSize(display, &cacheSize);
     if (!err) {
         for (int slot = 0; slot < cacheSize; slot++) {
             // Replace the buffer slots with NULLs. Keep the old handle until it is
             // replaced in ComposerHal, otherwise we risk leaving a dangling pointer.
             buffer_handle_t outHandle;
             auto bufReleaser = mResources->createReleaser(true /* isBuffer */);
             err = mResources->getDisplayClientTarget(display, slot, /*useCache*/ true,
                                                     /*rawHandle*/ nullptr, outHandle,
                                                     bufReleaser.get());
             if (err) {
                 continue;
             }
             const std::vector<common::Rect> damage;
             ndk::ScopedFileDescriptor fence; // empty fence
             common::Dataspace dataspace = common::Dataspace::UNKNOWN;
             err = mHal->setClientTarget(display, outHandle, fence, dataspace, damage);
             if (err) {
                 LOG(ERROR) << "Can't clean slot " << slot
                            << " of the client target buffer cache for display" << display;
             }
         }
     } else {
         LOG(ERROR) << "Can't clean client target cache for display " << display;
     }

     err = mResources->getDisplayOutputBufferCacheSize(display, &cacheSize);
     if (!err) {
         for (int slot = 0; slot < cacheSize; slot++) {
             // Replace the buffer slots with NULLs. Keep the old handle until it is
             // replaced in ComposerHal, otherwise we risk leaving a dangling pointer.
             buffer_handle_t outputBuffer;
             auto bufReleaser = mResources->createReleaser(true /* isBuffer */);
             err = mResources->getDisplayOutputBuffer(display, slot, /*useCache*/ true,
                                                     /*rawHandle*/ nullptr, outputBuffer,
                                                     bufReleaser.get());
             if (err) {
                 continue;
             }
             ndk::ScopedFileDescriptor emptyFd;
             err = mHal->setOutputBuffer(display, outputBuffer, /*fence*/ emptyFd);
             if (err) {
                 LOG(ERROR) << "Can't clean slot " << slot
                            << " of the output buffer cache for display " << display;
             }
         }
     } else {
         LOG(ERROR) << "Can't clean output buffer cache for display " << display;
     }
 }

 void ComposerClient::destroyResources() {
     DEBUG_FUNC();
     // We want to call hwc2_close here (and move hwc2_open to the
     // constructor), with the assumption that hwc2_close would
     //
     //  - clean up all resources owned by the client
     //  - make sure all displays are blank (since there is no layer)
     //
     // But since SF used to crash at this point, different hwcomposer2
     // implementations behave differently on hwc2_close.  Our only portable
     // choice really is to abort().  But that is not an option anymore
     // because we might also have VTS or VR as clients that can come and go.
     //
     // Below we manually clean all resources (layers and virtual
     // displays), and perform a presentDisplay afterwards.
     mResources->clear([this](int64_t display, bool isVirtual, const std::vector<int64_t> layers) {
         LOG(WARNING) << "destroying client resources for display " << display;
         for (auto layer : layers) {
             mHal->destroyLayer(display, layer);
         }

         if (isVirtual) {
             mHal->destroyVirtualDisplay(display);
         } else {
             LOG(WARNING) << "performing a final presentDisplay";
             std::vector<int64_t> changedLayers;
             std::vector<Composition> compositionTypes;
             uint32_t displayRequestMask = 0;
             std::vector<int64_t> requestedLayers;
             std::vector<int32_t> requestMasks;
             ClientTargetProperty clientTargetProperty;
             DimmingStage dimmingStage;
             mHal->validateDisplay(display, &changedLayers, &compositionTypes, &displayRequestMask,
                                   &requestedLayers, &requestMasks, &clientTargetProperty,
                                   &dimmingStage);
             mHal->acceptDisplayChanges(display);

             ndk::ScopedFileDescriptor presentFence;
             std::vector<int64_t> releasedLayers;
             std::vector<ndk::ScopedFileDescriptor> releaseFences;
             mHal->presentDisplay(display, presentFence, &releasedLayers, &releaseFences);
         }
     });
     mResources.reset();
 }

 ::ndk::SpAIBinder ComposerClient::createBinder() {
     auto binder = BnComposerClient::createBinder();
     AIBinder_setInheritRt(binder.get(), true);
     return binder;
 }

 } // namespace aidl::android::hardware::graphics::composer3::impl
	/*
	* Copyright (C) 2021 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.
	*/

	#define ATRACE_TAG (ATRACE_TAG_GRAPHICS \| ATRACE_TAG_HAL)

	#include "ComposerClient.h"

	#include <android-base/logging.h>
	#include <android/binder_ibinder_platform.h>

	#include "Util.h"

	namespace aidl::android::hardware::graphics::composer3::impl {

	bool ComposerClient::init() {
	DEBUG_FUNC();
	mResources = IResourceManager::create();
	if (!mResources) {
	LOG(ERROR) << "failed to create composer resources";
	return false;
	}

	mCommandEngine = std::make_unique<ComposerCommandEngine>(mHal, mResources.get());
	if (mCommandEngine == nullptr) {
	return false;
	}
	if (!mCommandEngine->init()) {
	mCommandEngine = nullptr;
	return false;
	}

	return true;
	}

	ComposerClient::~ComposerClient() {
	DEBUG_FUNC();
	// not initialized
	if (!mCommandEngine) {
	return;
	}

	LOG(DEBUG) << "destroying composer client";

	mHal->unregisterEventCallback();
	destroyResources();

	if (mOnClientDestroyed) {
	mOnClientDestroyed();
	}

	LOG(DEBUG) << "removed composer client";
	}

	// no need to check nullptr for output parameter, the aidl stub code won't pass nullptr
	ndk::ScopedAStatus ComposerClient::createLayer(int64_t display, int32_t bufferSlotCount,
	int64_t* layer) {
	DEBUG_FUNC();
	auto err = mHal->createLayer(display, layer);
	if (!err) {
	err = mResources->addLayer(display, *layer, bufferSlotCount);
	if (err) {
	layer = 0;
	}
	}
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::createVirtualDisplay(int32_t width, int32_t height,
	AidlPixelFormat formatHint,
	int32_t outputBufferSlotCount,
	VirtualDisplay* display) {
	DEBUG_FUNC();
	auto err = mHal->createVirtualDisplay(width, height, formatHint, display);
	if (!err) {
	err = mResources->addVirtualDisplay(display->display, outputBufferSlotCount);
	}
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::destroyLayer(int64_t display, int64_t layer) {
	DEBUG_FUNC();
	auto err = mHal->destroyLayer(display, layer);
	if (!err) {
	err = mResources->removeLayer(display, layer);
	}
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::destroyVirtualDisplay(int64_t display) {
	DEBUG_FUNC();
	auto err = mHal->destroyVirtualDisplay(display);
	if (!err) {
	err = mResources->removeDisplay(display);
	}
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::executeCommands(const std::vector<DisplayCommand>& commands,
	std::vector<CommandResultPayload>* results) {
	DEBUG_FUNC();
	auto err = mCommandEngine->execute(commands, results);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::getActiveConfig(int64_t display, int32_t* config) {
	DEBUG_FUNC();
	auto err = mHal->getActiveConfig(display, config);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::getColorModes(int64_t display,
	std::vector<ColorMode>* colorModes) {
	DEBUG_FUNC();
	auto err = mHal->getColorModes(display, colorModes);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::getDataspaceSaturationMatrix(common::Dataspace dataspace,
	std::vector<float>* matrix) {
	DEBUG_FUNC();
	if (dataspace != common::Dataspace::SRGB_LINEAR) {
	return TO_BINDER_STATUS(EX_BAD_PARAMETER);
	}

	auto err = mHal->getDataspaceSaturationMatrix(dataspace, matrix);
	if (err) {
	constexpr std::array<float, 16> unit {
	1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
	0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
	};
	matrix->clear();
	matrix->insert(matrix->begin(), unit.begin(), unit.end());
	}
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::getDisplayAttribute(int64_t display, int32_t config,
	DisplayAttribute attribute, int32_t* value) {
	DEBUG_FUNC();
	auto err = mHal->getDisplayAttribute(display, config, attribute, value);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::getDisplayCapabilities(int64_t display,
	std::vector<DisplayCapability>* caps) {
	DEBUG_FUNC();
	auto err = mHal->getDisplayCapabilities(display, caps);
	if (err) {
	return TO_BINDER_STATUS(err);
	}

	bool support = false;
	err = mHal->getDisplayIdleTimerSupport(display, support);
	if (err != ::android::OK) {
	LOG(ERROR) << "failed to getDisplayIdleTimerSupport: " << err;
	}

	if (support) {
	caps->push_back(DisplayCapability::DISPLAY_IDLE_TIMER);
	}

	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::getDisplayConfigs(int64_t display,
	std::vector<int32_t>* configs) {
	DEBUG_FUNC();
	auto err = mHal->getDisplayConfigs(display, configs);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::getDisplayConnectionType(int64_t display,
	DisplayConnectionType* type) {
	DEBUG_FUNC();
	auto err = mHal->getDisplayConnectionType(display, type);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::getDisplayIdentificationData(int64_t display,
	DisplayIdentification* id) {
	DEBUG_FUNC();
	auto err = mHal->getDisplayIdentificationData(display, id);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::getDisplayName(int64_t display, std::string* name) {
	DEBUG_FUNC();
	auto err = mHal->getDisplayName(display, name);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::getDisplayVsyncPeriod(int64_t display, int32_t* vsyncPeriod) {
	DEBUG_FUNC();
	auto err = mHal->getDisplayVsyncPeriod(display, vsyncPeriod);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::getDisplayedContentSample(int64_t display, int64_t maxFrames,
	int64_t timestamp,
	DisplayContentSample* samples) {
	DEBUG_FUNC();
	auto err = mHal->getDisplayedContentSample(display, maxFrames, timestamp, samples);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::getDisplayedContentSamplingAttributes(
	int64_t display, DisplayContentSamplingAttributes* attrs) {
	DEBUG_FUNC();
	auto err = mHal->getDisplayedContentSamplingAttributes(display, attrs);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::getDisplayPhysicalOrientation(int64_t display,
	common::Transform* orientation) {
	DEBUG_FUNC();
	auto err = mHal->getDisplayPhysicalOrientation(display, orientation);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::getHdrCapabilities(int64_t display, HdrCapabilities* caps) {
	DEBUG_FUNC();
	auto err = mHal->getHdrCapabilities(display, caps);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::getMaxVirtualDisplayCount(int32_t* count) {
	DEBUG_FUNC();
	auto err = mHal->getMaxVirtualDisplayCount(count);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::getPerFrameMetadataKeys(int64_t display,
	std::vector<PerFrameMetadataKey>* keys) {
	DEBUG_FUNC();
	auto err = mHal->getPerFrameMetadataKeys(display, keys);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::getReadbackBufferAttributes(int64_t display,
	ReadbackBufferAttributes* attrs) {
	DEBUG_FUNC();
	auto err = mHal->getReadbackBufferAttributes(display, attrs);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::getReadbackBufferFence(int64_t display,
	ndk::ScopedFileDescriptor* acquireFence) {
	DEBUG_FUNC();
	auto err = mHal->getReadbackBufferFence(display, acquireFence);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::getRenderIntents(int64_t display, ColorMode mode,
	std::vector<RenderIntent>* intents) {
	DEBUG_FUNC();
	auto err = mHal->getRenderIntents(display, mode, intents);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::getSupportedContentTypes(int64_t display,
	std::vector<ContentType>* types) {
	DEBUG_FUNC();
	auto err = mHal->getSupportedContentTypes(display, types);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::getDisplayDecorationSupport(
	int64_t display, std::optional<common::DisplayDecorationSupport>* supportStruct) {
	DEBUG_FUNC();
	bool support = false;
	auto err = mHal->getRCDLayerSupport(display, support);
	if (err != ::android::OK) {
	LOG(ERROR) << "failed to getRCDLayerSupport: " << err;
	}
	if (support) {
	// TODO (b/218499393): determine from mHal instead of hard coding.
	auto& s = supportStruct->emplace();
	s.format = common::PixelFormat::R_8;
	s.alphaInterpretation = common::AlphaInterpretation::COVERAGE;
	} else {
	supportStruct->reset();
	}
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::registerCallback(
	const std::shared_ptr<IComposerCallback>& callback) {
	DEBUG_FUNC();
	// no locking as we require this function to be called only once
	mHalEventCallback = std::make_unique<HalEventCallback>(mHal, mResources.get(), callback);
	mHal->registerEventCallback(mHalEventCallback.get());
	return ndk::ScopedAStatus::ok();
	}

	ndk::ScopedAStatus ComposerClient::setActiveConfig(int64_t display, int32_t config) {
	DEBUG_FUNC();
	auto err = mHal->setActiveConfig(display, config);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::setActiveConfigWithConstraints(
	int64_t display, int32_t config, const VsyncPeriodChangeConstraints& constraints,
	VsyncPeriodChangeTimeline* timeline) {
	DEBUG_FUNC();
	auto err = mHal->setActiveConfigWithConstraints(display, config, constraints, timeline);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::setBootDisplayConfig(int64_t display, int32_t config) {
	DEBUG_FUNC();
	auto err = mHal->setBootDisplayConfig(display, config);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::clearBootDisplayConfig(int64_t display) {
	DEBUG_FUNC();
	auto err = mHal->clearBootDisplayConfig(display);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::getPreferredBootDisplayConfig(int64_t display, int32_t* config) {
	DEBUG_FUNC();
	auto err = mHal->getPreferredBootDisplayConfig(display, config);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::setAutoLowLatencyMode(int64_t display, bool on) {
	DEBUG_FUNC();
	auto err = mHal->setAutoLowLatencyMode(display, on);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::setClientTargetSlotCount(int64_t display, int32_t count) {
	DEBUG_FUNC();
	auto err = mResources->setDisplayClientTargetCacheSize(display, count);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::setColorMode(int64_t display, ColorMode mode,
	RenderIntent intent) {
	DEBUG_FUNC();
	auto err = mHal->setColorMode(display, mode, intent);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::setContentType(int64_t display, ContentType type) {
	DEBUG_FUNC();
	auto err = mHal->setContentType(display, type);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::setDisplayedContentSamplingEnabled(
	int64_t display, bool enable, FormatColorComponent componentMask, int64_t maxFrames) {
	DEBUG_FUNC();
	auto err = mHal->setDisplayedContentSamplingEnabled(display, enable, componentMask, maxFrames);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::setPowerMode(int64_t display, PowerMode mode) {
	DEBUG_FUNC();
	auto err = mHal->setPowerMode(display, mode);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::setReadbackBuffer(
	int64_t display, const AidlNativeHandle& aidlBuffer,
	const ndk::ScopedFileDescriptor& releaseFence) {
	DEBUG_FUNC();
	buffer_handle_t readbackBuffer;
	// Note ownership of the buffer is not passed to resource manager.
	buffer_handle_t buffer = ::android::makeFromAidl(aidlBuffer);
	auto bufReleaser = mResources->createReleaser(true /* isBuffer */);
	auto err = mResources->getDisplayReadbackBuffer(display, buffer,
	readbackBuffer, bufReleaser.get());
	if (!err) {
	err = mHal->setReadbackBuffer(display, readbackBuffer, releaseFence);
	}
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::setVsyncEnabled(int64_t display, bool enabled) {
	DEBUG_FUNC();
	auto err = mHal->setVsyncEnabled(display, enabled);
	return TO_BINDER_STATUS(err);
	}

	ndk::ScopedAStatus ComposerClient::setIdleTimerEnabled(int64_t display, int32_t timeout) {
	DEBUG_FUNC();
	auto err = mHal->setIdleTimerEnabled(display, timeout);
	return TO_BINDER_STATUS(err);
	}

	void ComposerClient::HalEventCallback::onHotplug(int64_t display, bool connected) {
	DEBUG_FUNC();
	if (connected) {
	if (mResources->hasDisplay(display)) {
	// This is a subsequent hotplug "connected" for a display. This signals a
	// display change and thus the framework may want to reallocate buffers. We
	// need to free all cached handles, since they are holding a strong reference
	// to the underlying buffers.
	cleanDisplayResources(display);
	mResources->removeDisplay(display);
	}
	mResources->addPhysicalDisplay(display);
	} else {
	mResources->removeDisplay(display);
	}

	auto ret = mCallback->onHotplug(display, connected);
	if (!ret.isOk()) {
	LOG(ERROR) << "failed to send onHotplug:" << ret.getDescription();
	}
	}

	void ComposerClient::HalEventCallback::onRefresh(int64_t display) {
	DEBUG_FUNC();
	mResources->setDisplayMustValidateState(display, true);
	auto ret = mCallback->onRefresh(display);
	if (!ret.isOk()) {
	LOG(ERROR) << "failed to send onRefresh:" << ret.getDescription();
	}
	}

	void ComposerClient::HalEventCallback::onVsync(int64_t display, int64_t timestamp,
	int32_t vsyncPeriodNanos) {
	DEBUG_FUNC();
	auto ret = mCallback->onVsync(display, timestamp, vsyncPeriodNanos);
	if (!ret.isOk()) {
	LOG(ERROR) << "failed to send onVsync:" << ret.getDescription();
	}
	}

	void ComposerClient::HalEventCallback::onVsyncPeriodTimingChanged(
	int64_t display, const VsyncPeriodChangeTimeline& timeline) {
	DEBUG_FUNC();
	auto ret = mCallback->onVsyncPeriodTimingChanged(display, timeline);
	if (!ret.isOk()) {
	LOG(ERROR) << "failed to send onVsyncPeriodTimingChanged:" << ret.getDescription();
	}
	}

	void ComposerClient::HalEventCallback::onVsyncIdle(int64_t display) {
	DEBUG_FUNC();
	auto ret = mCallback->onVsyncIdle(display);
	if (!ret.isOk()) {
	LOG(ERROR) << "failed to send onVsyncIdle:" << ret.getDescription();
	}
	}

	void ComposerClient::HalEventCallback::onSeamlessPossible(int64_t display) {
	DEBUG_FUNC();
	auto ret = mCallback->onSeamlessPossible(display);
	if (!ret.isOk()) {
	LOG(ERROR) << "failed to send onSealmessPossible:" << ret.getDescription();
	}
	}

	void ComposerClient::HalEventCallback::cleanDisplayResources(int64_t display) {
	DEBUG_FUNC();
	size_t cacheSize;
	auto err = mResources->getDisplayClientTargetCacheSize(display, &cacheSize);
	if (!err) {
	for (int slot = 0; slot < cacheSize; slot++) {
	// Replace the buffer slots with NULLs. Keep the old handle until it is
	// replaced in ComposerHal, otherwise we risk leaving a dangling pointer.
	buffer_handle_t outHandle;
	auto bufReleaser = mResources->createReleaser(true /* isBuffer */);
	err = mResources->getDisplayClientTarget(display, slot, /useCache/ true,
	/rawHandle/ nullptr, outHandle,
	bufReleaser.get());
	if (err) {
	continue;
	}
	const std::vector<common::Rect> damage;
	ndk::ScopedFileDescriptor fence; // empty fence
	common::Dataspace dataspace = common::Dataspace::UNKNOWN;
	err = mHal->setClientTarget(display, outHandle, fence, dataspace, damage);
	if (err) {
	LOG(ERROR) << "Can't clean slot " << slot
	<< " of the client target buffer cache for display" << display;
	}
	}
	} else {
	LOG(ERROR) << "Can't clean client target cache for display " << display;
	}

	err = mResources->getDisplayOutputBufferCacheSize(display, &cacheSize);
	if (!err) {
	for (int slot = 0; slot < cacheSize; slot++) {
	// Replace the buffer slots with NULLs. Keep the old handle until it is
	// replaced in ComposerHal, otherwise we risk leaving a dangling pointer.
	buffer_handle_t outputBuffer;
	auto bufReleaser = mResources->createReleaser(true /* isBuffer */);
	err = mResources->getDisplayOutputBuffer(display, slot, /useCache/ true,
	/rawHandle/ nullptr, outputBuffer,
	bufReleaser.get());
	if (err) {
	continue;
	}
	ndk::ScopedFileDescriptor emptyFd;
	err = mHal->setOutputBuffer(display, outputBuffer, /fence/ emptyFd);
	if (err) {
	LOG(ERROR) << "Can't clean slot " << slot
	<< " of the output buffer cache for display " << display;
	}
	}
	} else {
	LOG(ERROR) << "Can't clean output buffer cache for display " << display;
	}
	}

	void ComposerClient::destroyResources() {
	DEBUG_FUNC();
	// We want to call hwc2_close here (and move hwc2_open to the
	// constructor), with the assumption that hwc2_close would
	//
	// - clean up all resources owned by the client
	// - make sure all displays are blank (since there is no layer)
	//
	// But since SF used to crash at this point, different hwcomposer2
	// implementations behave differently on hwc2_close. Our only portable
	// choice really is to abort(). But that is not an option anymore
	// because we might also have VTS or VR as clients that can come and go.
	//
	// Below we manually clean all resources (layers and virtual
	// displays), and perform a presentDisplay afterwards.
	mResources->clear([this](int64_t display, bool isVirtual, const std::vector<int64_t> layers) {
	LOG(WARNING) << "destroying client resources for display " << display;
	for (auto layer : layers) {
	mHal->destroyLayer(display, layer);
	}

	if (isVirtual) {
	mHal->destroyVirtualDisplay(display);
	} else {
	LOG(WARNING) << "performing a final presentDisplay";
	std::vector<int64_t> changedLayers;
	std::vector<Composition> compositionTypes;
	uint32_t displayRequestMask = 0;
	std::vector<int64_t> requestedLayers;
	std::vector<int32_t> requestMasks;
	ClientTargetProperty clientTargetProperty;
	DimmingStage dimmingStage;
	mHal->validateDisplay(display, &changedLayers, &compositionTypes, &displayRequestMask,
	&requestedLayers, &requestMasks, &clientTargetProperty,
	&dimmingStage);
	mHal->acceptDisplayChanges(display);

	ndk::ScopedFileDescriptor presentFence;
	std::vector<int64_t> releasedLayers;
	std::vector<ndk::ScopedFileDescriptor> releaseFences;
	mHal->presentDisplay(display, presentFence, &releasedLayers, &releaseFences);
	}
	});
	mResources.reset();
	}

	::ndk::SpAIBinder ComposerClient::createBinder() {
	auto binder = BnComposerClient::createBinder();
	AIBinder_setInheritRt(binder.get(), true);
	return binder;
	}

	} // namespace aidl::android::hardware::graphics::composer3::impl