blob: 79e4c753933d785a614af4e789e8b5f0206438b3 [file] [log] [blame]
Mathias Agopiana350ff92010-08-10 17:14:02 -07001/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -080017// TODO(b/129481165): remove the #pragma below and fix conversion issues
18#pragma clang diagnostic push
19#pragma clang diagnostic ignored "-Wconversion"
20
Dan Stoza9e56aa02015-11-02 13:00:03 -080021// #define LOG_NDEBUG 0
22
23#undef LOG_TAG
24#define LOG_TAG "HWComposer"
Mathias Agopian2965b262012-04-08 15:13:32 -070025#define ATRACE_TAG ATRACE_TAG_GRAPHICS
26
Lloyd Pique66d68602019-02-13 14:23:31 -080027#include "HWComposer.h"
28
Marin Shalamanovf8c63722020-10-06 13:11:21 +020029#include <android-base/properties.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080030#include <compositionengine/Output.h>
31#include <compositionengine/OutputLayer.h>
32#include <compositionengine/impl/OutputLayerCompositionState.h>
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -080033#include <ftl/future.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080034#include <log/log.h>
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070035#include <ui/DebugUtils.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070036#include <ui/GraphicBuffer.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080037#include <utils/Errors.h>
38#include <utils/Trace.h>
Mathias Agopiana350ff92010-08-10 17:14:02 -070039
Lloyd Pique66d68602019-02-13 14:23:31 -080040#include "../Layer.h" // needed only for debugging
Marin Shalamanovf8c63722020-10-06 13:11:21 +020041#include "../SurfaceFlingerProperties.h"
Lloyd Pique66d68602019-02-13 14:23:31 -080042#include "ComposerHal.h"
43#include "HWC2.h"
Mathias Agopiana350ff92010-08-10 17:14:02 -070044
Dominik Laskowskic1f18f62018-06-13 15:17:55 -070045#define LOG_HWC_DISPLAY_ERROR(hwcDisplayId, msg) \
46 ALOGE("%s failed for HWC display %" PRIu64 ": %s", __FUNCTION__, hwcDisplayId, msg)
47
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070048#define LOG_DISPLAY_ERROR(displayId, msg) \
Dominik Laskowski34157762018-10-31 13:07:19 -070049 ALOGE("%s failed for display %s: %s", __FUNCTION__, to_string(displayId).c_str(), msg)
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070050
Dominik Laskowski34157762018-10-31 13:07:19 -070051#define LOG_HWC_ERROR(what, error, displayId) \
52 ALOGE("%s: %s failed for display %s: %s (%d)", __FUNCTION__, what, \
53 to_string(displayId).c_str(), to_string(error).c_str(), static_cast<int32_t>(error))
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070054
55#define RETURN_IF_INVALID_DISPLAY(displayId, ...) \
56 do { \
Dominik Laskowski075d3172018-05-24 15:50:06 -070057 if (mDisplayData.count(displayId) == 0) { \
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070058 LOG_DISPLAY_ERROR(displayId, "Invalid display"); \
59 return __VA_ARGS__; \
60 } \
61 } while (false)
62
63#define RETURN_IF_HWC_ERROR_FOR(what, error, displayId, ...) \
64 do { \
Peiyong Line9d809e2020-04-14 13:10:48 -070065 if (error != hal::Error::NONE) { \
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070066 LOG_HWC_ERROR(what, error, displayId); \
67 return __VA_ARGS__; \
68 } \
69 } while (false)
70
71#define RETURN_IF_HWC_ERROR(error, displayId, ...) \
72 RETURN_IF_HWC_ERROR_FOR(__FUNCTION__, error, displayId, __VA_ARGS__)
73
Ady Abrahamde549d42022-01-26 19:19:17 -080074using aidl::android::hardware::graphics::composer3::Capability;
75using aidl::android::hardware::graphics::composer3::DisplayCapability;
Peiyong Line9d809e2020-04-14 13:10:48 -070076namespace hal = android::hardware::graphics::composer::hal;
77
Marin Shalamanov6e840172020-12-14 22:13:28 +010078namespace android {
Peiyong Linbdd08cc2019-12-17 21:35:14 -080079
Lloyd Pique441d5042018-10-18 16:49:51 -070080HWComposer::~HWComposer() = default;
81
82namespace impl {
83
Marin Shalamanovf8c63722020-10-06 13:11:21 +020084HWComposer::HWComposer(std::unique_ptr<Hwc2::Composer> composer)
85 : mComposer(std::move(composer)),
Dominik Laskowski13948602021-03-08 20:48:28 -080086 mMaxVirtualDisplayDimension(static_cast<size_t>(sysprop::max_virtual_display_dimension(0))),
Marin Shalamanovf8c63722020-10-06 13:11:21 +020087 mUpdateDeviceProductInfoOnHotplugReconnect(
Dominik Laskowski13948602021-03-08 20:48:28 -080088 sysprop::update_device_product_info_on_hotplug_reconnect(false)) {}
Peiyong Linbdd08cc2019-12-17 21:35:14 -080089
90HWComposer::HWComposer(const std::string& composerServiceName)
Ady Abraham9fc28052021-10-14 17:21:38 -070091 : HWComposer(Hwc2::Composer::create(composerServiceName)) {}
Mathias Agopianbef42c52013-08-21 17:45:46 -070092
Dominik Laskowskib04f98a2018-11-07 21:07:16 -080093HWComposer::~HWComposer() {
94 mDisplayData.clear();
95}
Dan Stoza9e56aa02015-11-02 13:00:03 -080096
Yichi Chen3401b562022-01-17 15:42:35 +080097void HWComposer::setCallback(HWC2::ComposerCallback& callback) {
Lloyd Pique4603f3c2020-02-11 12:06:56 -080098 loadCapabilities();
99 loadLayerMetadataSupport();
100
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800101 if (mRegisteredCallback) {
102 ALOGW("Callback already registered. Ignored extra registration attempt.");
103 return;
104 }
105 mRegisteredCallback = true;
Dominik Laskowskiebc8d3a2021-04-16 23:18:31 -0700106
Yichi Chen3401b562022-01-17 15:42:35 +0800107 mComposer->registerCallback(callback);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800108}
109
Peiyong Line9d809e2020-04-14 13:10:48 -0700110bool HWComposer::getDisplayIdentificationData(hal::HWDisplayId hwcDisplayId, uint8_t* outPort,
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700111 DisplayIdentificationData* outData) const {
Peiyong Line9d809e2020-04-14 13:10:48 -0700112 const auto error = static_cast<hal::Error>(
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800113 mComposer->getDisplayIdentificationData(hwcDisplayId, outPort, outData));
Peiyong Line9d809e2020-04-14 13:10:48 -0700114 if (error != hal::Error::NONE) {
115 if (error != hal::Error::UNSUPPORTED) {
Chia-I Wud0aff9d2018-06-21 13:39:09 +0800116 LOG_HWC_DISPLAY_ERROR(hwcDisplayId, to_string(error).c_str());
117 }
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700118 return false;
119 }
120 return true;
121}
122
Ady Abrahamde549d42022-01-26 19:19:17 -0800123bool HWComposer::hasCapability(Capability capability) const {
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800124 return mCapabilities.count(capability) > 0;
Dan Stoza9f26a9c2016-06-22 14:51:09 -0700125}
126
Ady Abrahamde549d42022-01-26 19:19:17 -0800127bool HWComposer::hasDisplayCapability(HalDisplayId displayId, DisplayCapability capability) const {
Dominik Laskowski1162e472020-04-02 19:02:47 -0700128 RETURN_IF_INVALID_DISPLAY(displayId, false);
Ady Abraham27fbcc72021-09-20 14:54:57 -0700129 return mDisplayData.at(displayId).hwcDisplay->hasCapability(capability);
Peiyong Lined531a32018-10-26 18:27:56 -0700130}
131
Peiyong Line9d809e2020-04-14 13:10:48 -0700132std::optional<DisplayIdentificationInfo> HWComposer::onHotplug(hal::HWDisplayId hwcDisplayId,
133 hal::Connection connection) {
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100134 switch (connection) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700135 case hal::Connection::CONNECTED:
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100136 return onHotplugConnect(hwcDisplayId);
Peiyong Line9d809e2020-04-14 13:10:48 -0700137 case hal::Connection::DISCONNECTED:
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100138 return onHotplugDisconnect(hwcDisplayId);
Peiyong Line9d809e2020-04-14 13:10:48 -0700139 case hal::Connection::INVALID:
Dominik Laskowski075d3172018-05-24 15:50:06 -0700140 return {};
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700141 }
Andy McFaddenb0d1dd32012-09-10 14:08:09 -0700142}
143
Marin Shalamanovf8c63722020-10-06 13:11:21 +0200144bool HWComposer::updatesDeviceProductInfoOnHotplugReconnect() const {
145 return mUpdateDeviceProductInfoOnHotplugReconnect;
146}
147
Peiyong Line9d809e2020-04-14 13:10:48 -0700148bool HWComposer::onVsync(hal::HWDisplayId hwcDisplayId, int64_t timestamp) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700149 const auto displayId = toPhysicalDisplayId(hwcDisplayId);
150 if (!displayId) {
151 LOG_HWC_DISPLAY_ERROR(hwcDisplayId, "Invalid HWC display");
Steven Thomas94e35b92017-07-26 18:48:28 -0700152 return false;
Jesse Hall1bd20e02012-08-29 10:47:52 -0700153 }
Jesse Hall1bd20e02012-08-29 10:47:52 -0700154
Dominik Laskowski075d3172018-05-24 15:50:06 -0700155 RETURN_IF_INVALID_DISPLAY(*displayId, false);
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700156
Dominik Laskowski1af47932018-11-12 10:20:46 -0800157 auto& displayData = mDisplayData[*displayId];
Jesse Hall1bd20e02012-08-29 10:47:52 -0700158
Dan Stoza9e56aa02015-11-02 13:00:03 -0800159 {
Dan Stoza9e56aa02015-11-02 13:00:03 -0800160 // There have been reports of HWCs that signal several vsync events
161 // with the same timestamp when turning the display off and on. This
162 // is a bug in the HWC implementation, but filter the extra events
163 // out here so they don't cause havoc downstream.
Dominik Laskowski1af47932018-11-12 10:20:46 -0800164 if (timestamp == displayData.lastHwVsync) {
Dominik Laskowski34157762018-10-31 13:07:19 -0700165 ALOGW("Ignoring duplicate VSYNC event from HWC for display %s (t=%" PRId64 ")",
166 to_string(*displayId).c_str(), timestamp);
Steven Thomas94e35b92017-07-26 18:48:28 -0700167 return false;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800168 }
169
Dominik Laskowski1af47932018-11-12 10:20:46 -0800170 displayData.lastHwVsync = timestamp;
Jesse Hall1c569c42013-04-05 13:44:52 -0700171 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800172
Dominik Laskowski34157762018-10-31 13:07:19 -0700173 const auto tag = "HW_VSYNC_" + to_string(*displayId);
Dominik Laskowski1af47932018-11-12 10:20:46 -0800174 ATRACE_INT(tag.c_str(), displayData.vsyncTraceToggle);
175 displayData.vsyncTraceToggle = !displayData.vsyncTraceToggle;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800176
Steven Thomas94e35b92017-07-26 18:48:28 -0700177 return true;
Jesse Hall1c569c42013-04-05 13:44:52 -0700178}
179
Dominik Laskowski13948602021-03-08 20:48:28 -0800180size_t HWComposer::getMaxVirtualDisplayCount() const {
181 return mComposer->getMaxVirtualDisplayCount();
182}
183
184size_t HWComposer::getMaxVirtualDisplayDimension() const {
185 return mMaxVirtualDisplayDimension;
186}
187
188bool HWComposer::allocateVirtualDisplay(HalVirtualDisplayId displayId, ui::Size resolution,
Dominik Laskowski263eec42021-07-21 23:13:24 -0700189 ui::PixelFormat* format) {
Dominik Laskowski13948602021-03-08 20:48:28 -0800190 if (!resolution.isValid()) {
191 ALOGE("%s: Invalid resolution %dx%d", __func__, resolution.width, resolution.height);
192 return false;
Fabien Sanglarde29055f2017-03-08 11:36:46 -0800193 }
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200194
Dominik Laskowski13948602021-03-08 20:48:28 -0800195 const uint32_t width = static_cast<uint32_t>(resolution.width);
196 const uint32_t height = static_cast<uint32_t>(resolution.height);
197
198 if (mMaxVirtualDisplayDimension > 0 &&
199 (width > mMaxVirtualDisplayDimension || height > mMaxVirtualDisplayDimension)) {
200 ALOGE("%s: Resolution %ux%u exceeds maximum dimension %zu", __func__, width, height,
201 mMaxVirtualDisplayDimension);
202 return false;
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200203 }
204
Dominik Laskowski13948602021-03-08 20:48:28 -0800205 hal::HWDisplayId hwcDisplayId;
Peiyong Line9d809e2020-04-14 13:10:48 -0700206 const auto error = static_cast<hal::Error>(
Dominik Laskowski263eec42021-07-21 23:13:24 -0700207 mComposer->createVirtualDisplay(width, height, format, &hwcDisplayId));
Dominik Laskowski13948602021-03-08 20:48:28 -0800208 RETURN_IF_HWC_ERROR_FOR("createVirtualDisplay", error, displayId, false);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800209
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800210 auto display = std::make_unique<HWC2::impl::Display>(*mComposer.get(), mCapabilities,
Peiyong Line9d809e2020-04-14 13:10:48 -0700211 hwcDisplayId, hal::DisplayType::VIRTUAL);
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800212 display->setConnected(true);
Dominik Laskowski13948602021-03-08 20:48:28 -0800213 auto& displayData = mDisplayData[displayId];
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800214 displayData.hwcDisplay = std::move(display);
Dominik Laskowski13948602021-03-08 20:48:28 -0800215 return true;
Mathias Agopiane60b0682012-08-21 23:34:09 -0700216}
217
Marin Shalamanova524a092020-07-27 21:39:55 +0200218void HWComposer::allocatePhysicalDisplay(hal::HWDisplayId hwcDisplayId,
219 PhysicalDisplayId displayId) {
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100220 mPhysicalDisplayIdMap[hwcDisplayId] = displayId;
221
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700222 if (!mPrimaryHwcDisplayId) {
223 mPrimaryHwcDisplayId = hwcDisplayId;
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100224 }
225
226 auto& displayData = mDisplayData[displayId];
227 auto newDisplay =
228 std::make_unique<HWC2::impl::Display>(*mComposer.get(), mCapabilities, hwcDisplayId,
Peiyong Line9d809e2020-04-14 13:10:48 -0700229 hal::DisplayType::PHYSICAL);
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100230 newDisplay->setConnected(true);
231 displayData.hwcDisplay = std::move(newDisplay);
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100232}
233
234int32_t HWComposer::getAttribute(hal::HWDisplayId hwcDisplayId, hal::HWConfigId configId,
Marin Shalamanov045b7002021-01-07 16:56:24 +0100235 hal::Attribute attribute) const {
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100236 int32_t value = 0;
237 auto error = static_cast<hal::Error>(
238 mComposer->getDisplayAttribute(hwcDisplayId, configId, attribute, &value));
239
240 RETURN_IF_HWC_ERROR_FOR("getDisplayAttribute", error, *toPhysicalDisplayId(hwcDisplayId), -1);
241 return value;
242}
243
Lloyd Pique1b33fc32021-05-07 14:36:58 -0700244std::shared_ptr<HWC2::Layer> HWComposer::createLayer(HalDisplayId displayId) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700245 RETURN_IF_INVALID_DISPLAY(displayId, nullptr);
246
Lloyd Pique1b33fc32021-05-07 14:36:58 -0700247 auto expected = mDisplayData[displayId].hwcDisplay->createLayer();
248 if (!expected.has_value()) {
249 auto error = std::move(expected).error();
250 RETURN_IF_HWC_ERROR(error, displayId, nullptr);
251 }
252 return std::move(expected).value();
Steven Thomas94e35b92017-07-26 18:48:28 -0700253}
254
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200255bool HWComposer::isConnected(PhysicalDisplayId displayId) const {
Ady Abraham2e9c7032021-03-29 14:01:56 -0700256 if (mDisplayData.count(displayId)) {
257 return mDisplayData.at(displayId).hwcDisplay->isConnected();
258 }
259
260 return false;
Mathias Agopian9c6e2972011-09-20 17:21:56 -0700261}
262
Marin Shalamanov045b7002021-01-07 16:56:24 +0100263std::vector<HWComposer::HWCDisplayMode> HWComposer::getModes(PhysicalDisplayId displayId) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700264 RETURN_IF_INVALID_DISPLAY(displayId, {});
265
Marin Shalamanov045b7002021-01-07 16:56:24 +0100266 const auto hwcDisplayId = mDisplayData.at(displayId).hwcDisplay->getId();
267 std::vector<hal::HWConfigId> configIds;
268 auto error = static_cast<hal::Error>(mComposer->getDisplayConfigs(hwcDisplayId, &configIds));
269 RETURN_IF_HWC_ERROR_FOR("getDisplayConfigs", error, *toPhysicalDisplayId(hwcDisplayId), {});
270
271 std::vector<HWCDisplayMode> modes;
272 modes.reserve(configIds.size());
273 for (auto configId : configIds) {
274 modes.push_back(HWCDisplayMode{
275 .hwcId = configId,
276 .width = getAttribute(hwcDisplayId, configId, hal::Attribute::WIDTH),
277 .height = getAttribute(hwcDisplayId, configId, hal::Attribute::HEIGHT),
278 .vsyncPeriod = getAttribute(hwcDisplayId, configId, hal::Attribute::VSYNC_PERIOD),
279 .dpiX = getAttribute(hwcDisplayId, configId, hal::Attribute::DPI_X),
280 .dpiY = getAttribute(hwcDisplayId, configId, hal::Attribute::DPI_Y),
281 .configGroup = getAttribute(hwcDisplayId, configId, hal::Attribute::CONFIG_GROUP),
282 });
283 }
284
285 return modes;
Mathias Agopianda27af92012-09-13 18:17:13 -0700286}
287
Marin Shalamanov045b7002021-01-07 16:56:24 +0100288std::optional<hal::HWConfigId> HWComposer::getActiveMode(PhysicalDisplayId displayId) const {
289 RETURN_IF_INVALID_DISPLAY(displayId, std::nullopt);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700290
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100291 const auto hwcId = *fromPhysicalDisplayId(displayId);
292 ALOGV("[%" PRIu64 "] getActiveMode", hwcId);
293 hal::HWConfigId configId;
294 auto error = static_cast<hal::Error>(mComposer->getActiveConfig(hwcId, &configId));
295
Peiyong Line9d809e2020-04-14 13:10:48 -0700296 if (error == hal::Error::BAD_CONFIG) {
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100297 LOG_DISPLAY_ERROR(displayId, "No active mode");
Marin Shalamanov045b7002021-01-07 16:56:24 +0100298 return std::nullopt;
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700299 }
300
Marin Shalamanov045b7002021-01-07 16:56:24 +0100301 return configId;
Mathias Agopiana350ff92010-08-10 17:14:02 -0700302}
303
Ady Abraham3a77a7b2019-12-02 18:46:59 -0800304// Composer 2.4
305
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100306ui::DisplayConnectionType HWComposer::getDisplayConnectionType(PhysicalDisplayId displayId) const {
307 RETURN_IF_INVALID_DISPLAY(displayId, ui::DisplayConnectionType::Internal);
Dominik Laskowski55c85402020-01-21 16:25:47 -0800308 const auto& hwcDisplay = mDisplayData.at(displayId).hwcDisplay;
309
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100310 ui::DisplayConnectionType type;
Dominik Laskowski55c85402020-01-21 16:25:47 -0800311 const auto error = hwcDisplay->getConnectionType(&type);
312
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700313 const auto FALLBACK_TYPE = hwcDisplay->getId() == mPrimaryHwcDisplayId
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100314 ? ui::DisplayConnectionType::Internal
315 : ui::DisplayConnectionType::External;
Dominik Laskowski55c85402020-01-21 16:25:47 -0800316
317 RETURN_IF_HWC_ERROR(error, displayId, FALLBACK_TYPE);
318 return type;
319}
320
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200321bool HWComposer::isVsyncPeriodSwitchSupported(PhysicalDisplayId displayId) const {
Dominik Laskowski55c85402020-01-21 16:25:47 -0800322 RETURN_IF_INVALID_DISPLAY(displayId, false);
Ady Abraham3a77a7b2019-12-02 18:46:59 -0800323 return mDisplayData.at(displayId).hwcDisplay->isVsyncPeriodSwitchSupported();
324}
325
Marin Shalamanov045b7002021-01-07 16:56:24 +0100326status_t HWComposer::getDisplayVsyncPeriod(PhysicalDisplayId displayId,
327 nsecs_t* outVsyncPeriod) const {
Dominik Laskowski55c85402020-01-21 16:25:47 -0800328 RETURN_IF_INVALID_DISPLAY(displayId, 0);
329
Marin Shalamanov045b7002021-01-07 16:56:24 +0100330 if (!isVsyncPeriodSwitchSupported(displayId)) {
331 return INVALID_OPERATION;
Dominik Laskowskif3749f82018-06-13 15:49:25 -0700332 }
Marin Shalamanov045b7002021-01-07 16:56:24 +0100333 const auto hwcId = *fromPhysicalDisplayId(displayId);
334 Hwc2::VsyncPeriodNanos vsyncPeriodNanos = 0;
335 auto error =
336 static_cast<hal::Error>(mComposer->getDisplayVsyncPeriod(hwcId, &vsyncPeriodNanos));
337 RETURN_IF_HWC_ERROR(error, displayId, 0);
338 *outVsyncPeriod = static_cast<nsecs_t>(vsyncPeriodNanos);
339 return NO_ERROR;
Lloyd Pique3c085a02018-05-09 19:38:32 -0700340}
341
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200342std::vector<ui::ColorMode> HWComposer::getColorModes(PhysicalDisplayId displayId) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700343 RETURN_IF_INVALID_DISPLAY(displayId, {});
344
Peiyong Linfd997e02018-03-28 15:29:00 -0700345 std::vector<ui::ColorMode> modes;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700346 auto error = mDisplayData.at(displayId).hwcDisplay->getColorModes(&modes);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700347 RETURN_IF_HWC_ERROR(error, displayId, {});
Courtney Goeltzenleuchterfad9d8c2016-06-23 11:49:50 -0600348 return modes;
349}
350
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200351status_t HWComposer::setActiveColorMode(PhysicalDisplayId displayId, ui::ColorMode mode,
Dominik Laskowski075d3172018-05-24 15:50:06 -0700352 ui::RenderIntent renderIntent) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700353 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Michael Wright28f24d02016-07-12 13:30:53 -0700354
355 auto& displayData = mDisplayData[displayId];
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700356 auto error = displayData.hwcDisplay->setColorMode(mode, renderIntent);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700357 RETURN_IF_HWC_ERROR_FOR(("setColorMode(" + decodeColorMode(mode) + ", " +
358 decodeRenderIntent(renderIntent) + ")")
359 .c_str(),
360 error, displayId, UNKNOWN_ERROR);
Michael Wright28f24d02016-07-12 13:30:53 -0700361
362 return NO_ERROR;
363}
364
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200365void HWComposer::setVsyncEnabled(PhysicalDisplayId displayId, hal::Vsync enabled) {
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700366 RETURN_IF_INVALID_DISPLAY(displayId);
367 auto& displayData = mDisplayData[displayId];
368
Dan Stoza9e56aa02015-11-02 13:00:03 -0800369 // NOTE: we use our own internal lock here because we have to call
370 // into the HWC with the lock held, and we want to make sure
371 // that even if HWC blocks (which it shouldn't), it won't
372 // affect other threads.
Dominik Laskowski1af47932018-11-12 10:20:46 -0800373 std::lock_guard lock(displayData.vsyncEnabledLock);
374 if (enabled == displayData.vsyncEnabled) {
375 return;
Colin Cross10fbdb62012-07-12 17:56:34 -0700376 }
Dominik Laskowski1af47932018-11-12 10:20:46 -0800377
378 ATRACE_CALL();
379 auto error = displayData.hwcDisplay->setVsyncEnabled(enabled);
380 RETURN_IF_HWC_ERROR(error, displayId);
381
382 displayData.vsyncEnabled = enabled;
383
384 const auto tag = "HW_VSYNC_ON_" + to_string(displayId);
Peiyong Line9d809e2020-04-14 13:10:48 -0700385 ATRACE_INT(tag.c_str(), enabled == hal::Vsync::ENABLE ? 1 : 0);
Colin Cross10fbdb62012-07-12 17:56:34 -0700386}
387
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200388status_t HWComposer::setClientTarget(HalDisplayId displayId, uint32_t slot,
Dominik Laskowski075d3172018-05-24 15:50:06 -0700389 const sp<Fence>& acquireFence, const sp<GraphicBuffer>& target,
390 ui::Dataspace dataspace) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700391 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Jesse Hall851cfe82013-03-20 13:44:00 -0700392
Dominik Laskowski34157762018-10-31 13:07:19 -0700393 ALOGV("%s for display %s", __FUNCTION__, to_string(displayId).c_str());
Dan Stoza9e56aa02015-11-02 13:00:03 -0800394 auto& hwcDisplay = mDisplayData[displayId].hwcDisplay;
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400395 auto error = hwcDisplay->setClientTarget(slot, target, acquireFence, dataspace);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700396 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
Jesse Hall851cfe82013-03-20 13:44:00 -0700397 return NO_ERROR;
398}
399
Lloyd Pique66d68602019-02-13 14:23:31 -0800400status_t HWComposer::getDeviceCompositionChanges(
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200401 HalDisplayId displayId, bool frameUsesClientComposition,
Ady Abrahamb42cdc12021-05-11 14:31:26 -0700402 std::chrono::steady_clock::time_point earliestPresentTime,
Ady Abraham43065bd2021-12-10 17:22:15 -0800403 const std::shared_ptr<FenceTime>& previousPresentFence, nsecs_t expectedPresentTime,
Lloyd Pique66d68602019-02-13 14:23:31 -0800404 std::optional<android::HWComposer::DeviceRequestedChanges>* outChanges) {
Dan Stoza9e56aa02015-11-02 13:00:03 -0800405 ATRACE_CALL();
406
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700407 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800408
409 auto& displayData = mDisplayData[displayId];
410 auto& hwcDisplay = displayData.hwcDisplay;
411 if (!hwcDisplay->isConnected()) {
412 return NO_ERROR;
413 }
414
415 uint32_t numTypes = 0;
416 uint32_t numRequests = 0;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700417
Peiyong Line9d809e2020-04-14 13:10:48 -0700418 hal::Error error = hal::Error::NONE;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700419
Ady Abrahamec7aa8a2021-06-28 12:37:09 -0700420 // First try to skip validate altogether. We can do that when
421 // 1. The previous frame has not been presented yet or already passed the
422 // earliest time to present. Otherwise, we may present a frame too early.
423 // 2. There is no client composition. Otherwise, we first need to render the
Ady Abrahamb42cdc12021-05-11 14:31:26 -0700424 // client target buffer.
Ady Abraham43065bd2021-12-10 17:22:15 -0800425 const bool canSkipValidate = [&] {
426 // We must call validate if we have client composition
427 if (frameUsesClientComposition) {
428 return false;
429 }
430
431 // If composer supports getting the expected present time, we can skip
432 // as composer will make sure to prevent early presentation
433 if (mComposer->isSupported(Hwc2::Composer::OptionalFeature::ExpectedPresentTime)) {
434 return true;
435 }
436
437 // composer doesn't support getting the expected present time. We can only
438 // skip validate if we know that we are not going to present early.
439 return std::chrono::steady_clock::now() >= earliestPresentTime ||
440 previousPresentFence->getSignalTime() == Fence::SIGNAL_TIME_PENDING;
441 }();
442
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700443 displayData.validateWasSkipped = false;
Ady Abrahamb42cdc12021-05-11 14:31:26 -0700444 if (canSkipValidate) {
Dominik Laskowski1af47932018-11-12 10:20:46 -0800445 sp<Fence> outPresentFence;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700446 uint32_t state = UINT32_MAX;
Ady Abraham43065bd2021-12-10 17:22:15 -0800447 error = hwcDisplay->presentOrValidate(expectedPresentTime, &numTypes, &numRequests,
448 &outPresentFence, &state);
Peiyong Line9d809e2020-04-14 13:10:48 -0700449 if (!hasChangesError(error)) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700450 RETURN_IF_HWC_ERROR_FOR("presentOrValidate", error, displayId, UNKNOWN_ERROR);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700451 }
452 if (state == 1) { //Present Succeeded.
Steven Thomas94e35b92017-07-26 18:48:28 -0700453 std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700454 error = hwcDisplay->getReleaseFences(&releaseFences);
455 displayData.releaseFences = std::move(releaseFences);
456 displayData.lastPresentFence = outPresentFence;
457 displayData.validateWasSkipped = true;
458 displayData.presentError = error;
459 return NO_ERROR;
460 }
461 // Present failed but Validate ran.
462 } else {
Ady Abraham43065bd2021-12-10 17:22:15 -0800463 error = hwcDisplay->validate(expectedPresentTime, &numTypes, &numRequests);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700464 }
465 ALOGV("SkipValidate failed, Falling back to SLOW validate/present");
Peiyong Line9d809e2020-04-14 13:10:48 -0700466 if (!hasChangesError(error)) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700467 RETURN_IF_HWC_ERROR_FOR("validate", error, displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800468 }
469
Lloyd Pique66d68602019-02-13 14:23:31 -0800470 android::HWComposer::DeviceRequestedChanges::ChangedTypes changedTypes;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800471 changedTypes.reserve(numTypes);
472 error = hwcDisplay->getChangedCompositionTypes(&changedTypes);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700473 RETURN_IF_HWC_ERROR_FOR("getChangedCompositionTypes", error, displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800474
Peiyong Line9d809e2020-04-14 13:10:48 -0700475 auto displayRequests = static_cast<hal::DisplayRequest>(0);
Lloyd Pique66d68602019-02-13 14:23:31 -0800476 android::HWComposer::DeviceRequestedChanges::LayerRequests layerRequests;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800477 layerRequests.reserve(numRequests);
Lloyd Pique66d68602019-02-13 14:23:31 -0800478 error = hwcDisplay->getRequests(&displayRequests, &layerRequests);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700479 RETURN_IF_HWC_ERROR_FOR("getRequests", error, displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800480
Peiyong Lindfc3f7c2020-05-07 20:15:50 -0700481 DeviceRequestedChanges::ClientTargetProperty clientTargetProperty;
Alec Mouri85065692022-03-18 00:58:26 +0000482 error = hwcDisplay->getClientTargetProperty(&clientTargetProperty);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800483
Peiyong Lindfc3f7c2020-05-07 20:15:50 -0700484 outChanges->emplace(DeviceRequestedChanges{std::move(changedTypes), std::move(displayRequests),
485 std::move(layerRequests),
Alec Mouri85065692022-03-18 00:58:26 +0000486 std::move(clientTargetProperty)});
Dan Stoza9e56aa02015-11-02 13:00:03 -0800487 error = hwcDisplay->acceptChanges();
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700488 RETURN_IF_HWC_ERROR_FOR("acceptChanges", error, displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800489
490 return NO_ERROR;
491}
492
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200493sp<Fence> HWComposer::getPresentFence(HalDisplayId displayId) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700494 RETURN_IF_INVALID_DISPLAY(displayId, Fence::NO_FENCE);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700495 return mDisplayData.at(displayId).lastPresentFence;
Jesse Hall851cfe82013-03-20 13:44:00 -0700496}
497
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200498sp<Fence> HWComposer::getLayerReleaseFence(HalDisplayId displayId, HWC2::Layer* layer) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700499 RETURN_IF_INVALID_DISPLAY(displayId, Fence::NO_FENCE);
Tim Murray2d3f8b82019-12-04 16:24:17 -0800500 const auto& displayFences = mDisplayData.at(displayId).releaseFences;
501 auto fence = displayFences.find(layer);
502 if (fence == displayFences.end()) {
Dan Stoza9e56aa02015-11-02 13:00:03 -0800503 ALOGV("getLayerReleaseFence: Release fence not found");
504 return Fence::NO_FENCE;
Riley Andrews03414a12014-07-01 14:22:59 -0700505 }
Tim Murray2d3f8b82019-12-04 16:24:17 -0800506 return fence->second;
Riley Andrews03414a12014-07-01 14:22:59 -0700507}
508
Ady Abrahamb42cdc12021-05-11 14:31:26 -0700509status_t HWComposer::presentAndGetReleaseFences(
Ady Abrahamec7aa8a2021-06-28 12:37:09 -0700510 HalDisplayId displayId, std::chrono::steady_clock::time_point earliestPresentTime,
511 const std::shared_ptr<FenceTime>& previousPresentFence) {
Dan Stoza9e56aa02015-11-02 13:00:03 -0800512 ATRACE_CALL();
Mathias Agopian3e8b8532012-05-13 20:42:01 -0700513
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700514 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Pablo Ceballosd814cf22015-09-11 14:37:39 -0700515
Dan Stoza9e56aa02015-11-02 13:00:03 -0800516 auto& displayData = mDisplayData[displayId];
517 auto& hwcDisplay = displayData.hwcDisplay;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700518
519 if (displayData.validateWasSkipped) {
Chia-I Wuae5a6b82017-10-10 09:09:22 -0700520 // explicitly flush all pending commands
Peiyong Line9d809e2020-04-14 13:10:48 -0700521 auto error = static_cast<hal::Error>(mComposer->executeCommands());
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800522 RETURN_IF_HWC_ERROR_FOR("executeCommands", error, displayId, UNKNOWN_ERROR);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700523 RETURN_IF_HWC_ERROR_FOR("present", displayData.presentError, displayId, UNKNOWN_ERROR);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700524 return NO_ERROR;
525 }
526
Ady Abraham43065bd2021-12-10 17:22:15 -0800527 const bool waitForEarliestPresent =
528 !mComposer->isSupported(Hwc2::Composer::OptionalFeature::ExpectedPresentTime) &&
529 previousPresentFence->getSignalTime() != Fence::SIGNAL_TIME_PENDING;
530
531 if (waitForEarliestPresent) {
Ady Abrahamb42cdc12021-05-11 14:31:26 -0700532 ATRACE_NAME("wait for earliest present time");
533 std::this_thread::sleep_until(earliestPresentTime);
534 }
535
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800536 auto error = hwcDisplay->present(&displayData.lastPresentFence);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700537 RETURN_IF_HWC_ERROR_FOR("present", error, displayId, UNKNOWN_ERROR);
Mathias Agopian3e8b8532012-05-13 20:42:01 -0700538
Steven Thomas94e35b92017-07-26 18:48:28 -0700539 std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800540 error = hwcDisplay->getReleaseFences(&releaseFences);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700541 RETURN_IF_HWC_ERROR_FOR("getReleaseFences", error, displayId, UNKNOWN_ERROR);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800542
543 displayData.releaseFences = std::move(releaseFences);
544
545 return NO_ERROR;
Mathias Agopiana350ff92010-08-10 17:14:02 -0700546}
547
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200548status_t HWComposer::setPowerMode(PhysicalDisplayId displayId, hal::PowerMode mode) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700549 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
550
Peiyong Line9d809e2020-04-14 13:10:48 -0700551 if (mode == hal::PowerMode::OFF) {
552 setVsyncEnabled(displayId, hal::Vsync::DISABLE);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800553 }
554
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700555 const auto& displayData = mDisplayData[displayId];
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700556 auto& hwcDisplay = displayData.hwcDisplay;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800557 switch (mode) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700558 case hal::PowerMode::OFF:
559 case hal::PowerMode::ON:
Dan Stoza9e56aa02015-11-02 13:00:03 -0800560 ALOGV("setPowerMode: Calling HWC %s", to_string(mode).c_str());
561 {
562 auto error = hwcDisplay->setPowerMode(mode);
Peiyong Line9d809e2020-04-14 13:10:48 -0700563 if (error != hal::Error::NONE) {
564 LOG_HWC_ERROR(("setPowerMode(" + to_string(mode) + ")").c_str(), error,
565 displayId);
Peiyong Lin306e4992018-05-07 16:18:22 -0700566 }
Mathias Agopianda27af92012-09-13 18:17:13 -0700567 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800568 break;
Peiyong Line9d809e2020-04-14 13:10:48 -0700569 case hal::PowerMode::DOZE:
570 case hal::PowerMode::DOZE_SUSPEND:
Dan Stoza9e56aa02015-11-02 13:00:03 -0800571 ALOGV("setPowerMode: Calling HWC %s", to_string(mode).c_str());
572 {
573 bool supportsDoze = false;
574 auto error = hwcDisplay->supportsDoze(&supportsDoze);
Peiyong Line9d809e2020-04-14 13:10:48 -0700575 if (error != hal::Error::NONE) {
Peiyong Lin306e4992018-05-07 16:18:22 -0700576 LOG_HWC_ERROR("supportsDoze", error, displayId);
577 }
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700578
Dan Stoza9e56aa02015-11-02 13:00:03 -0800579 if (!supportsDoze) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700580 mode = hal::PowerMode::ON;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800581 }
582
583 error = hwcDisplay->setPowerMode(mode);
Peiyong Line9d809e2020-04-14 13:10:48 -0700584 if (error != hal::Error::NONE) {
585 LOG_HWC_ERROR(("setPowerMode(" + to_string(mode) + ")").c_str(), error,
586 displayId);
Peiyong Lin306e4992018-05-07 16:18:22 -0700587 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800588 }
589 break;
590 default:
591 ALOGV("setPowerMode: Not calling HWC");
592 break;
Mathias Agopianda27af92012-09-13 18:17:13 -0700593 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800594
595 return NO_ERROR;
596}
597
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100598status_t HWComposer::setActiveModeWithConstraints(
Marin Shalamanov12c9e5a2021-01-07 00:25:35 +0100599 PhysicalDisplayId displayId, hal::HWConfigId hwcModeId,
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200600 const hal::VsyncPeriodChangeConstraints& constraints,
Peiyong Line9d809e2020-04-14 13:10:48 -0700601 hal::VsyncPeriodChangeTimeline* outTimeline) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700602 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800603
Marin Shalamanov12c9e5a2021-01-07 00:25:35 +0100604 auto error = mDisplayData[displayId].hwcDisplay->setActiveConfigWithConstraints(hwcModeId,
605 constraints,
606 outTimeline);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700607 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800608 return NO_ERROR;
609}
610
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200611status_t HWComposer::setColorTransform(HalDisplayId displayId, const mat4& transform) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700612 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dan Stoza9f26a9c2016-06-22 14:51:09 -0700613
614 auto& displayData = mDisplayData[displayId];
Ady Abrahamdc011a92021-12-21 14:06:44 -0800615 auto error = displayData.hwcDisplay->setColorTransform(transform);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700616 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
Dan Stoza9f26a9c2016-06-22 14:51:09 -0700617 return NO_ERROR;
618}
619
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200620void HWComposer::disconnectDisplay(HalDisplayId displayId) {
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700621 RETURN_IF_INVALID_DISPLAY(displayId);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800622 auto& displayData = mDisplayData[displayId];
Dominik Laskowski7e045462018-05-30 13:02:02 -0700623 const auto hwcDisplayId = displayData.hwcDisplay->getId();
Dominik Laskowski075d3172018-05-24 15:50:06 -0700624
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800625 mPhysicalDisplayIdMap.erase(hwcDisplayId);
626 mDisplayData.erase(displayId);
Marin Shalamanov8b196592021-08-09 16:24:42 +0200627
628 // Reset the primary display ID if we're disconnecting it.
629 // This way isHeadless() will return false, which is necessary
630 // because getPrimaryDisplayId() will crash.
631 if (mPrimaryHwcDisplayId == hwcDisplayId) {
632 mPrimaryHwcDisplayId.reset();
633 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800634}
635
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200636status_t HWComposer::setOutputBuffer(HalVirtualDisplayId displayId, const sp<Fence>& acquireFence,
Dominik Laskowski075d3172018-05-24 15:50:06 -0700637 const sp<GraphicBuffer>& buffer) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700638 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700639 const auto& displayData = mDisplayData[displayId];
Dan Stoza9e56aa02015-11-02 13:00:03 -0800640
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700641 auto error = displayData.hwcDisplay->setOutputBuffer(buffer, acquireFence);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700642 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800643 return NO_ERROR;
644}
645
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200646void HWComposer::clearReleaseFences(HalDisplayId displayId) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700647 RETURN_IF_INVALID_DISPLAY(displayId);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800648 mDisplayData[displayId].releaseFences.clear();
Mathias Agopian3e8b8532012-05-13 20:42:01 -0700649}
650
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200651status_t HWComposer::getHdrCapabilities(HalDisplayId displayId, HdrCapabilities* outCapabilities) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700652 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dan Stozac4f471e2016-03-24 09:31:08 -0700653
654 auto& hwcDisplay = mDisplayData[displayId].hwcDisplay;
Peiyong Lin62665892018-04-16 11:07:44 -0700655 auto error = hwcDisplay->getHdrCapabilities(outCapabilities);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700656 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
Peiyong Lin62665892018-04-16 11:07:44 -0700657 return NO_ERROR;
Dan Stozac4f471e2016-03-24 09:31:08 -0700658}
659
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200660int32_t HWComposer::getSupportedPerFrameMetadata(HalDisplayId displayId) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700661 RETURN_IF_INVALID_DISPLAY(displayId, 0);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700662 return mDisplayData.at(displayId).hwcDisplay->getSupportedPerFrameMetadata();
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700663}
664
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200665std::vector<ui::RenderIntent> HWComposer::getRenderIntents(HalDisplayId displayId,
Dominik Laskowski075d3172018-05-24 15:50:06 -0700666 ui::ColorMode colorMode) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700667 RETURN_IF_INVALID_DISPLAY(displayId, {});
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700668
669 std::vector<ui::RenderIntent> renderIntents;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700670 auto error = mDisplayData.at(displayId).hwcDisplay->getRenderIntents(colorMode, &renderIntents);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700671 RETURN_IF_HWC_ERROR(error, displayId, {});
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700672 return renderIntents;
673}
674
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200675mat4 HWComposer::getDataspaceSaturationMatrix(HalDisplayId displayId, ui::Dataspace dataspace) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700676 RETURN_IF_INVALID_DISPLAY(displayId, {});
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700677
678 mat4 matrix;
679 auto error = mDisplayData[displayId].hwcDisplay->getDataspaceSaturationMatrix(dataspace,
680 &matrix);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700681 RETURN_IF_HWC_ERROR(error, displayId, {});
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700682 return matrix;
683}
684
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200685status_t HWComposer::getDisplayedContentSamplingAttributes(HalDisplayId displayId,
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700686 ui::PixelFormat* outFormat,
687 ui::Dataspace* outDataspace,
688 uint8_t* outComponentMask) {
689 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
690 const auto error =
691 mDisplayData[displayId]
692 .hwcDisplay->getDisplayedContentSamplingAttributes(outFormat, outDataspace,
693 outComponentMask);
Peiyong Line9d809e2020-04-14 13:10:48 -0700694 if (error == hal::Error::UNSUPPORTED) RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700695 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
696 return NO_ERROR;
697}
698
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200699status_t HWComposer::setDisplayContentSamplingEnabled(HalDisplayId displayId, bool enabled,
Kevin DuBois74e53772018-11-19 10:52:38 -0800700 uint8_t componentMask, uint64_t maxFrames) {
701 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
702 const auto error =
703 mDisplayData[displayId].hwcDisplay->setDisplayContentSamplingEnabled(enabled,
704 componentMask,
705 maxFrames);
706
Peiyong Line9d809e2020-04-14 13:10:48 -0700707 if (error == hal::Error::UNSUPPORTED) RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
708 if (error == hal::Error::BAD_PARAMETER) RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
Kevin DuBois74e53772018-11-19 10:52:38 -0800709 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
710 return NO_ERROR;
711}
712
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200713status_t HWComposer::getDisplayedContentSample(HalDisplayId displayId, uint64_t maxFrames,
Kevin DuBois1d4249a2018-08-29 10:45:14 -0700714 uint64_t timestamp, DisplayedFrameStats* outStats) {
715 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
716 const auto error =
717 mDisplayData[displayId].hwcDisplay->getDisplayedContentSample(maxFrames, timestamp,
718 outStats);
719 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
720 return NO_ERROR;
721}
722
Alec Mouricdf16792021-12-10 13:16:06 -0800723std::future<status_t> HWComposer::setDisplayBrightness(
Alec Mouri4d8a05d2022-03-23 18:14:26 +0000724 PhysicalDisplayId displayId, float brightness, float brightnessNits,
Alec Mouricdf16792021-12-10 13:16:06 -0800725 const Hwc2::Composer::DisplayBrightnessOptions& options) {
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -0800726 RETURN_IF_INVALID_DISPLAY(displayId, ftl::yield<status_t>(BAD_INDEX));
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700727 auto& display = mDisplayData[displayId].hwcDisplay;
728
Alec Mouri4d8a05d2022-03-23 18:14:26 +0000729 return ftl::chain(display->setDisplayBrightness(brightness, brightnessNits, options))
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700730 .then([displayId](hal::Error error) -> status_t {
731 if (error == hal::Error::UNSUPPORTED) {
732 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
733 }
734 if (error == hal::Error::BAD_PARAMETER) {
735 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
736 }
737 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
738 return NO_ERROR;
739 });
Dan Gittik57e63c52019-01-18 16:37:54 +0000740}
741
Kriti Dang7defaf32021-11-15 11:55:43 +0100742status_t HWComposer::setBootDisplayMode(PhysicalDisplayId displayId,
743 hal::HWConfigId displayModeId) {
744 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
745 const auto error = mDisplayData[displayId].hwcDisplay->setBootDisplayConfig(displayModeId);
746 if (error == hal::Error::UNSUPPORTED) {
747 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
748 }
749 if (error == hal::Error::BAD_PARAMETER) {
750 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
751 }
752 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
753 return NO_ERROR;
754}
755
756status_t HWComposer::clearBootDisplayMode(PhysicalDisplayId displayId) {
757 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
758 const auto error = mDisplayData[displayId].hwcDisplay->clearBootDisplayConfig();
759 if (error == hal::Error::UNSUPPORTED) {
760 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
761 }
762 if (error == hal::Error::BAD_PARAMETER) {
763 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
764 }
765 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
766 return NO_ERROR;
767}
768
Kriti Dang16ca2972022-02-01 20:07:03 +0100769std::optional<hal::HWConfigId> HWComposer::getPreferredBootDisplayMode(
770 PhysicalDisplayId displayId) {
771 RETURN_IF_INVALID_DISPLAY(displayId, std::nullopt);
772 hal::HWConfigId displayModeId;
Kriti Dang7defaf32021-11-15 11:55:43 +0100773 const auto error =
774 mDisplayData[displayId].hwcDisplay->getPreferredBootDisplayConfig(&displayModeId);
Kriti Dang16ca2972022-02-01 20:07:03 +0100775 if (error != hal::Error::NONE) {
776 LOG_DISPLAY_ERROR(displayId, to_string(error).c_str());
777 return std::nullopt;
Kriti Dang7defaf32021-11-15 11:55:43 +0100778 }
Kriti Dang7defaf32021-11-15 11:55:43 +0100779 return displayModeId;
780}
781
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500782status_t HWComposer::getDisplayDecorationSupport(
783 PhysicalDisplayId displayId,
784 std::optional<aidl::android::hardware::graphics::common::DisplayDecorationSupport>*
785 support) {
786 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
787 const auto error = mDisplayData[displayId].hwcDisplay->getDisplayDecorationSupport(support);
788 if (error == hal::Error::UNSUPPORTED) {
789 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
790 }
791 if (error == hal::Error::BAD_PARAMETER) {
792 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
793 }
794 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
795 return NO_ERROR;
796}
797
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200798status_t HWComposer::setAutoLowLatencyMode(PhysicalDisplayId displayId, bool on) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100799 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
800 const auto error = mDisplayData[displayId].hwcDisplay->setAutoLowLatencyMode(on);
Peiyong Line9d809e2020-04-14 13:10:48 -0700801 if (error == hal::Error::UNSUPPORTED) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100802 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
803 }
Peiyong Line9d809e2020-04-14 13:10:48 -0700804 if (error == hal::Error::BAD_PARAMETER) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100805 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
806 }
807 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
808 return NO_ERROR;
809}
810
811status_t HWComposer::getSupportedContentTypes(
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -0800812 PhysicalDisplayId displayId,
813 std::vector<hal::ContentType>* outSupportedContentTypes) const {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100814 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -0800815 const auto error = mDisplayData.at(displayId).hwcDisplay->getSupportedContentTypes(
816 outSupportedContentTypes);
Galia Peycheva5492cb52019-10-30 14:13:16 +0100817
818 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
819
820 return NO_ERROR;
821}
822
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200823status_t HWComposer::setContentType(PhysicalDisplayId displayId, hal::ContentType contentType) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100824 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
825 const auto error = mDisplayData[displayId].hwcDisplay->setContentType(contentType);
Peiyong Line9d809e2020-04-14 13:10:48 -0700826 if (error == hal::Error::UNSUPPORTED) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100827 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
828 }
Peiyong Line9d809e2020-04-14 13:10:48 -0700829 if (error == hal::Error::BAD_PARAMETER) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100830 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
831 }
832 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
833
834 return NO_ERROR;
835}
836
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800837const std::unordered_map<std::string, bool>& HWComposer::getSupportedLayerGenericMetadata() const {
838 return mSupportedLayerGenericMetadata;
839}
840
Yiwei Zhang5434a782018-12-05 18:06:32 -0800841void HWComposer::dump(std::string& result) const {
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800842 result.append(mComposer->dumpDebugInfo());
Mathias Agopian83727852010-09-23 18:13:21 -0700843}
844
Marin Shalamanova524a092020-07-27 21:39:55 +0200845std::optional<PhysicalDisplayId> HWComposer::toPhysicalDisplayId(
846 hal::HWDisplayId hwcDisplayId) const {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700847 if (const auto it = mPhysicalDisplayIdMap.find(hwcDisplayId);
848 it != mPhysicalDisplayIdMap.end()) {
849 return it->second;
850 }
851 return {};
852}
853
Marin Shalamanova524a092020-07-27 21:39:55 +0200854std::optional<hal::HWDisplayId> HWComposer::fromPhysicalDisplayId(
855 PhysicalDisplayId displayId) const {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700856 if (const auto it = mDisplayData.find(displayId); it != mDisplayData.end()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700857 return it->second.hwcDisplay->getId();
858 }
859 return {};
860}
861
Peiyong Line9d809e2020-04-14 13:10:48 -0700862bool HWComposer::shouldIgnoreHotplugConnect(hal::HWDisplayId hwcDisplayId,
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100863 bool hasDisplayIdentificationData) const {
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100864 if (mHasMultiDisplaySupport && !hasDisplayIdentificationData) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700865 ALOGE("Ignoring connection of display %" PRIu64 " without identification data",
866 hwcDisplayId);
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100867 return true;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700868 }
869
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700870 // Legacy mode only supports IDs LEGACY_DISPLAY_TYPE_PRIMARY and LEGACY_DISPLAY_TYPE_EXTERNAL.
871 if (!mHasMultiDisplaySupport && mPhysicalDisplayIdMap.size() == 2) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700872 ALOGE("Ignoring connection of tertiary display %" PRIu64, hwcDisplayId);
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100873 return true;
874 }
875
876 return false;
877}
878
Peiyong Line9d809e2020-04-14 13:10:48 -0700879std::optional<DisplayIdentificationInfo> HWComposer::onHotplugConnect(
880 hal::HWDisplayId hwcDisplayId) {
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100881 std::optional<DisplayIdentificationInfo> info;
882 if (const auto displayId = toPhysicalDisplayId(hwcDisplayId)) {
883 info = DisplayIdentificationInfo{.id = *displayId,
884 .name = std::string(),
885 .deviceProductInfo = std::nullopt};
Marin Shalamanovf8c63722020-10-06 13:11:21 +0200886 if (mUpdateDeviceProductInfoOnHotplugReconnect) {
887 uint8_t port;
888 DisplayIdentificationData data;
889 getDisplayIdentificationData(hwcDisplayId, &port, &data);
890 if (auto newInfo = parseDisplayIdentificationData(port, data)) {
891 info->deviceProductInfo = std::move(newInfo->deviceProductInfo);
892 } else {
893 ALOGE("Failed to parse identification data for display %" PRIu64, hwcDisplayId);
894 }
895 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700896 } else {
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100897 uint8_t port;
898 DisplayIdentificationData data;
899 const bool hasDisplayIdentificationData =
900 getDisplayIdentificationData(hwcDisplayId, &port, &data);
901 if (mPhysicalDisplayIdMap.empty()) {
902 mHasMultiDisplaySupport = hasDisplayIdentificationData;
903 ALOGI("Switching to %s multi-display mode",
904 mHasMultiDisplaySupport ? "generalized" : "legacy");
905 }
906
907 if (shouldIgnoreHotplugConnect(hwcDisplayId, hasDisplayIdentificationData)) {
908 return {};
909 }
910
911 info = [this, hwcDisplayId, &port, &data, hasDisplayIdentificationData] {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700912 const bool isPrimary = !mPrimaryHwcDisplayId;
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100913 if (mHasMultiDisplaySupport) {
914 if (const auto info = parseDisplayIdentificationData(port, data)) {
915 return *info;
916 }
917 ALOGE("Failed to parse identification data for display %" PRIu64, hwcDisplayId);
918 } else {
919 ALOGW_IF(hasDisplayIdentificationData,
920 "Ignoring identification data for display %" PRIu64, hwcDisplayId);
Peiyong Lin65248e02020-04-18 21:15:07 -0700921 port = isPrimary ? LEGACY_DISPLAY_TYPE_PRIMARY : LEGACY_DISPLAY_TYPE_EXTERNAL;
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100922 }
923
Marin Shalamanova524a092020-07-27 21:39:55 +0200924 return DisplayIdentificationInfo{.id = PhysicalDisplayId::fromPort(port),
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700925 .name = isPrimary ? "Primary display"
926 : "Secondary display",
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100927 .deviceProductInfo = std::nullopt};
928 }();
Dominik Laskowski075d3172018-05-24 15:50:06 -0700929 }
930
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100931 if (!isConnected(info->id)) {
932 allocatePhysicalDisplay(hwcDisplayId, info->id);
933 }
934 return info;
935}
936
937std::optional<DisplayIdentificationInfo> HWComposer::onHotplugDisconnect(
Peiyong Line9d809e2020-04-14 13:10:48 -0700938 hal::HWDisplayId hwcDisplayId) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700939 LOG_ALWAYS_FATAL_IF(hwcDisplayId == mPrimaryHwcDisplayId,
940 "Primary display cannot be disconnected.");
941
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100942 const auto displayId = toPhysicalDisplayId(hwcDisplayId);
943 if (!displayId) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700944 LOG_HWC_DISPLAY_ERROR(hwcDisplayId, "Invalid HWC display");
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100945 return {};
Dominik Laskowski075d3172018-05-24 15:50:06 -0700946 }
947
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100948 // The display will later be destroyed by a call to
949 // destroyDisplay(). For now we just mark it disconnected.
950 if (isConnected(*displayId)) {
951 mDisplayData[*displayId].hwcDisplay->setConnected(false);
952 } else {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700953 LOG_HWC_DISPLAY_ERROR(hwcDisplayId, "Already disconnected");
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100954 }
955 // The cleanup of Disconnect is handled through HWComposer::disconnectDisplay
956 // via SurfaceFlinger's onHotplugReceived callback handling
957 return DisplayIdentificationInfo{.id = *displayId,
958 .name = std::string(),
Marin Shalamanovf5de90d2019-10-08 10:57:25 +0200959 .deviceProductInfo = std::nullopt};
Steven Thomas6e8f7062017-11-22 14:15:29 -0800960}
961
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800962void HWComposer::loadCapabilities() {
Peiyong Line9d809e2020-04-14 13:10:48 -0700963 static_assert(sizeof(hal::Capability) == sizeof(int32_t), "Capability size has changed");
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800964 auto capabilities = mComposer->getCapabilities();
965 for (auto capability : capabilities) {
Ady Abrahamde549d42022-01-26 19:19:17 -0800966 mCapabilities.emplace(capability);
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800967 }
968}
969
ramindani32cf0602022-03-02 02:30:29 +0000970status_t HWComposer::setIdleTimerEnabled(PhysicalDisplayId displayId,
971 std::chrono::milliseconds timeout) {
972 ATRACE_CALL();
973 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
974 const auto error = mDisplayData[displayId].hwcDisplay->setIdleTimerEnabled(timeout);
975 if (error == hal::Error::UNSUPPORTED) {
976 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
977 }
978 if (error == hal::Error::BAD_PARAMETER) {
979 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
980 }
981 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
982 return NO_ERROR;
983}
984
ramindani06e518e2022-03-14 18:47:53 +0000985bool HWComposer::hasDisplayIdleTimerCapability(PhysicalDisplayId displayId) const {
ramindani32cf0602022-03-02 02:30:29 +0000986 RETURN_IF_INVALID_DISPLAY(displayId, false);
ramindani06e518e2022-03-14 18:47:53 +0000987 return mDisplayData.at(displayId).hwcDisplay->hasDisplayIdleTimerCapability();
988}
989
990Hwc2::AidlTransform HWComposer::getPhysicalDisplayOrientation(PhysicalDisplayId displayId) const {
991 ATRACE_CALL();
992 RETURN_IF_INVALID_DISPLAY(displayId, Hwc2::AidlTransform::NONE);
993 Hwc2::AidlTransform outTransform;
994 const auto& hwcDisplay = mDisplayData.at(displayId).hwcDisplay;
995 const auto error = hwcDisplay->getPhysicalDisplayOrientation(&outTransform);
996 RETURN_IF_HWC_ERROR(error, displayId, Hwc2::AidlTransform::NONE);
997 return outTransform;
ramindani32cf0602022-03-02 02:30:29 +0000998}
999
Lloyd Pique4603f3c2020-02-11 12:06:56 -08001000void HWComposer::loadLayerMetadataSupport() {
1001 mSupportedLayerGenericMetadata.clear();
1002
1003 std::vector<Hwc2::IComposerClient::LayerGenericMetadataKey> supportedMetadataKeyInfo;
1004 const auto error = mComposer->getLayerGenericMetadataKeys(&supportedMetadataKeyInfo);
1005 if (error != hardware::graphics::composer::V2_4::Error::NONE) {
Ady Abraham3891cbe2021-03-29 11:29:31 -07001006 if (error != hardware::graphics::composer::V2_4::Error::UNSUPPORTED) {
1007 ALOGE("%s: %s failed: %s (%d)", __FUNCTION__, "getLayerGenericMetadataKeys",
1008 toString(error).c_str(), static_cast<int32_t>(error));
1009 }
Lloyd Pique4603f3c2020-02-11 12:06:56 -08001010 return;
1011 }
1012
1013 for (const auto& [name, mandatory] : supportedMetadataKeyInfo) {
1014 mSupportedLayerGenericMetadata.emplace(name, mandatory);
1015 }
1016}
1017
Lloyd Pique441d5042018-10-18 16:49:51 -07001018} // namespace impl
Dominik Laskowskif9750f22018-06-06 12:24:53 -07001019} // namespace android
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08001020
1021// TODO(b/129481165): remove the #pragma below and fix conversion issues
1022#pragma clang diagnostic pop // ignored "-Wconversion"