blob: a6aee1f2f59a720483205bca02b727ad44b070b5 [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>
33#include <log/log.h>
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070034#include <ui/DebugUtils.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070035#include <ui/GraphicBuffer.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080036#include <utils/Errors.h>
37#include <utils/Trace.h>
Mathias Agopiana350ff92010-08-10 17:14:02 -070038
Lloyd Pique66d68602019-02-13 14:23:31 -080039#include "../Layer.h" // needed only for debugging
Marin Shalamanovf8c63722020-10-06 13:11:21 +020040#include "../SurfaceFlingerProperties.h"
Lloyd Pique66d68602019-02-13 14:23:31 -080041#include "ComposerHal.h"
42#include "HWC2.h"
Mathias Agopiana350ff92010-08-10 17:14:02 -070043
Dominik Laskowskic1f18f62018-06-13 15:17:55 -070044#define LOG_HWC_DISPLAY_ERROR(hwcDisplayId, msg) \
45 ALOGE("%s failed for HWC display %" PRIu64 ": %s", __FUNCTION__, hwcDisplayId, msg)
46
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070047#define LOG_DISPLAY_ERROR(displayId, msg) \
Dominik Laskowski34157762018-10-31 13:07:19 -070048 ALOGE("%s failed for display %s: %s", __FUNCTION__, to_string(displayId).c_str(), msg)
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070049
Dominik Laskowski34157762018-10-31 13:07:19 -070050#define LOG_HWC_ERROR(what, error, displayId) \
51 ALOGE("%s: %s failed for display %s: %s (%d)", __FUNCTION__, what, \
52 to_string(displayId).c_str(), to_string(error).c_str(), static_cast<int32_t>(error))
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070053
54#define RETURN_IF_INVALID_DISPLAY(displayId, ...) \
55 do { \
Dominik Laskowski075d3172018-05-24 15:50:06 -070056 if (mDisplayData.count(displayId) == 0) { \
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070057 LOG_DISPLAY_ERROR(displayId, "Invalid display"); \
58 return __VA_ARGS__; \
59 } \
60 } while (false)
61
62#define RETURN_IF_HWC_ERROR_FOR(what, error, displayId, ...) \
63 do { \
Peiyong Line9d809e2020-04-14 13:10:48 -070064 if (error != hal::Error::NONE) { \
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070065 LOG_HWC_ERROR(what, error, displayId); \
66 return __VA_ARGS__; \
67 } \
68 } while (false)
69
70#define RETURN_IF_HWC_ERROR(error, displayId, ...) \
71 RETURN_IF_HWC_ERROR_FOR(__FUNCTION__, error, displayId, __VA_ARGS__)
72
Ady Abrahamde549d42022-01-26 19:19:17 -080073using aidl::android::hardware::graphics::composer3::Capability;
74using aidl::android::hardware::graphics::composer3::DisplayCapability;
Peiyong Line9d809e2020-04-14 13:10:48 -070075namespace hal = android::hardware::graphics::composer::hal;
76
Marin Shalamanov6e840172020-12-14 22:13:28 +010077namespace android {
Peiyong Linbdd08cc2019-12-17 21:35:14 -080078
Lloyd Pique441d5042018-10-18 16:49:51 -070079HWComposer::~HWComposer() = default;
80
81namespace impl {
82
Marin Shalamanovf8c63722020-10-06 13:11:21 +020083HWComposer::HWComposer(std::unique_ptr<Hwc2::Composer> composer)
84 : mComposer(std::move(composer)),
Dominik Laskowski13948602021-03-08 20:48:28 -080085 mMaxVirtualDisplayDimension(static_cast<size_t>(sysprop::max_virtual_display_dimension(0))),
Marin Shalamanovf8c63722020-10-06 13:11:21 +020086 mUpdateDeviceProductInfoOnHotplugReconnect(
Dominik Laskowski13948602021-03-08 20:48:28 -080087 sysprop::update_device_product_info_on_hotplug_reconnect(false)) {}
Peiyong Linbdd08cc2019-12-17 21:35:14 -080088
89HWComposer::HWComposer(const std::string& composerServiceName)
Ady Abraham9fc28052021-10-14 17:21:38 -070090 : HWComposer(Hwc2::Composer::create(composerServiceName)) {}
Mathias Agopianbef42c52013-08-21 17:45:46 -070091
Dominik Laskowskib04f98a2018-11-07 21:07:16 -080092HWComposer::~HWComposer() {
93 mDisplayData.clear();
94}
Dan Stoza9e56aa02015-11-02 13:00:03 -080095
Yichi Chen3401b562022-01-17 15:42:35 +080096void HWComposer::setCallback(HWC2::ComposerCallback& callback) {
Lloyd Pique4603f3c2020-02-11 12:06:56 -080097 loadCapabilities();
98 loadLayerMetadataSupport();
99
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800100 if (mRegisteredCallback) {
101 ALOGW("Callback already registered. Ignored extra registration attempt.");
102 return;
103 }
104 mRegisteredCallback = true;
Dominik Laskowskiebc8d3a2021-04-16 23:18:31 -0700105
Yichi Chen3401b562022-01-17 15:42:35 +0800106 mComposer->registerCallback(callback);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800107}
108
Peiyong Line9d809e2020-04-14 13:10:48 -0700109bool HWComposer::getDisplayIdentificationData(hal::HWDisplayId hwcDisplayId, uint8_t* outPort,
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700110 DisplayIdentificationData* outData) const {
Peiyong Line9d809e2020-04-14 13:10:48 -0700111 const auto error = static_cast<hal::Error>(
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800112 mComposer->getDisplayIdentificationData(hwcDisplayId, outPort, outData));
Peiyong Line9d809e2020-04-14 13:10:48 -0700113 if (error != hal::Error::NONE) {
114 if (error != hal::Error::UNSUPPORTED) {
Chia-I Wud0aff9d2018-06-21 13:39:09 +0800115 LOG_HWC_DISPLAY_ERROR(hwcDisplayId, to_string(error).c_str());
116 }
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700117 return false;
118 }
119 return true;
120}
121
Ady Abrahamde549d42022-01-26 19:19:17 -0800122bool HWComposer::hasCapability(Capability capability) const {
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800123 return mCapabilities.count(capability) > 0;
Dan Stoza9f26a9c2016-06-22 14:51:09 -0700124}
125
Ady Abrahamde549d42022-01-26 19:19:17 -0800126bool HWComposer::hasDisplayCapability(HalDisplayId displayId, DisplayCapability capability) const {
Dominik Laskowski1162e472020-04-02 19:02:47 -0700127 RETURN_IF_INVALID_DISPLAY(displayId, false);
Ady Abraham27fbcc72021-09-20 14:54:57 -0700128 return mDisplayData.at(displayId).hwcDisplay->hasCapability(capability);
Peiyong Lined531a32018-10-26 18:27:56 -0700129}
130
Peiyong Line9d809e2020-04-14 13:10:48 -0700131std::optional<DisplayIdentificationInfo> HWComposer::onHotplug(hal::HWDisplayId hwcDisplayId,
132 hal::Connection connection) {
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100133 switch (connection) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700134 case hal::Connection::CONNECTED:
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100135 return onHotplugConnect(hwcDisplayId);
Peiyong Line9d809e2020-04-14 13:10:48 -0700136 case hal::Connection::DISCONNECTED:
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100137 return onHotplugDisconnect(hwcDisplayId);
Peiyong Line9d809e2020-04-14 13:10:48 -0700138 case hal::Connection::INVALID:
Dominik Laskowski075d3172018-05-24 15:50:06 -0700139 return {};
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700140 }
Andy McFaddenb0d1dd32012-09-10 14:08:09 -0700141}
142
Marin Shalamanovf8c63722020-10-06 13:11:21 +0200143bool HWComposer::updatesDeviceProductInfoOnHotplugReconnect() const {
144 return mUpdateDeviceProductInfoOnHotplugReconnect;
145}
146
Peiyong Line9d809e2020-04-14 13:10:48 -0700147bool HWComposer::onVsync(hal::HWDisplayId hwcDisplayId, int64_t timestamp) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700148 const auto displayId = toPhysicalDisplayId(hwcDisplayId);
149 if (!displayId) {
150 LOG_HWC_DISPLAY_ERROR(hwcDisplayId, "Invalid HWC display");
Steven Thomas94e35b92017-07-26 18:48:28 -0700151 return false;
Jesse Hall1bd20e02012-08-29 10:47:52 -0700152 }
Jesse Hall1bd20e02012-08-29 10:47:52 -0700153
Dominik Laskowski075d3172018-05-24 15:50:06 -0700154 RETURN_IF_INVALID_DISPLAY(*displayId, false);
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700155
Dominik Laskowski1af47932018-11-12 10:20:46 -0800156 auto& displayData = mDisplayData[*displayId];
Jesse Hall1bd20e02012-08-29 10:47:52 -0700157
Dan Stoza9e56aa02015-11-02 13:00:03 -0800158 {
Dan Stoza9e56aa02015-11-02 13:00:03 -0800159 // There have been reports of HWCs that signal several vsync events
160 // with the same timestamp when turning the display off and on. This
161 // is a bug in the HWC implementation, but filter the extra events
162 // out here so they don't cause havoc downstream.
Dominik Laskowski1af47932018-11-12 10:20:46 -0800163 if (timestamp == displayData.lastHwVsync) {
Dominik Laskowski34157762018-10-31 13:07:19 -0700164 ALOGW("Ignoring duplicate VSYNC event from HWC for display %s (t=%" PRId64 ")",
165 to_string(*displayId).c_str(), timestamp);
Steven Thomas94e35b92017-07-26 18:48:28 -0700166 return false;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800167 }
168
Dominik Laskowski1af47932018-11-12 10:20:46 -0800169 displayData.lastHwVsync = timestamp;
Jesse Hall1c569c42013-04-05 13:44:52 -0700170 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800171
Dominik Laskowski34157762018-10-31 13:07:19 -0700172 const auto tag = "HW_VSYNC_" + to_string(*displayId);
Dominik Laskowski1af47932018-11-12 10:20:46 -0800173 ATRACE_INT(tag.c_str(), displayData.vsyncTraceToggle);
174 displayData.vsyncTraceToggle = !displayData.vsyncTraceToggle;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800175
Steven Thomas94e35b92017-07-26 18:48:28 -0700176 return true;
Jesse Hall1c569c42013-04-05 13:44:52 -0700177}
178
Dominik Laskowski13948602021-03-08 20:48:28 -0800179size_t HWComposer::getMaxVirtualDisplayCount() const {
180 return mComposer->getMaxVirtualDisplayCount();
181}
182
183size_t HWComposer::getMaxVirtualDisplayDimension() const {
184 return mMaxVirtualDisplayDimension;
185}
186
187bool HWComposer::allocateVirtualDisplay(HalVirtualDisplayId displayId, ui::Size resolution,
Dominik Laskowski263eec42021-07-21 23:13:24 -0700188 ui::PixelFormat* format) {
Dominik Laskowski13948602021-03-08 20:48:28 -0800189 if (!resolution.isValid()) {
190 ALOGE("%s: Invalid resolution %dx%d", __func__, resolution.width, resolution.height);
191 return false;
Fabien Sanglarde29055f2017-03-08 11:36:46 -0800192 }
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200193
Dominik Laskowski13948602021-03-08 20:48:28 -0800194 const uint32_t width = static_cast<uint32_t>(resolution.width);
195 const uint32_t height = static_cast<uint32_t>(resolution.height);
196
197 if (mMaxVirtualDisplayDimension > 0 &&
198 (width > mMaxVirtualDisplayDimension || height > mMaxVirtualDisplayDimension)) {
199 ALOGE("%s: Resolution %ux%u exceeds maximum dimension %zu", __func__, width, height,
200 mMaxVirtualDisplayDimension);
201 return false;
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200202 }
203
Dominik Laskowski13948602021-03-08 20:48:28 -0800204 hal::HWDisplayId hwcDisplayId;
Peiyong Line9d809e2020-04-14 13:10:48 -0700205 const auto error = static_cast<hal::Error>(
Dominik Laskowski263eec42021-07-21 23:13:24 -0700206 mComposer->createVirtualDisplay(width, height, format, &hwcDisplayId));
Dominik Laskowski13948602021-03-08 20:48:28 -0800207 RETURN_IF_HWC_ERROR_FOR("createVirtualDisplay", error, displayId, false);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800208
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800209 auto display = std::make_unique<HWC2::impl::Display>(*mComposer.get(), mCapabilities,
Peiyong Line9d809e2020-04-14 13:10:48 -0700210 hwcDisplayId, hal::DisplayType::VIRTUAL);
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800211 display->setConnected(true);
Dominik Laskowski13948602021-03-08 20:48:28 -0800212 auto& displayData = mDisplayData[displayId];
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800213 displayData.hwcDisplay = std::move(display);
Dominik Laskowski13948602021-03-08 20:48:28 -0800214 return true;
Mathias Agopiane60b0682012-08-21 23:34:09 -0700215}
216
Marin Shalamanova524a092020-07-27 21:39:55 +0200217void HWComposer::allocatePhysicalDisplay(hal::HWDisplayId hwcDisplayId,
218 PhysicalDisplayId displayId) {
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100219 mPhysicalDisplayIdMap[hwcDisplayId] = displayId;
220
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700221 if (!mPrimaryHwcDisplayId) {
222 mPrimaryHwcDisplayId = hwcDisplayId;
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100223 }
224
225 auto& displayData = mDisplayData[displayId];
226 auto newDisplay =
227 std::make_unique<HWC2::impl::Display>(*mComposer.get(), mCapabilities, hwcDisplayId,
Peiyong Line9d809e2020-04-14 13:10:48 -0700228 hal::DisplayType::PHYSICAL);
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100229 newDisplay->setConnected(true);
230 displayData.hwcDisplay = std::move(newDisplay);
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100231}
232
233int32_t HWComposer::getAttribute(hal::HWDisplayId hwcDisplayId, hal::HWConfigId configId,
Marin Shalamanov045b7002021-01-07 16:56:24 +0100234 hal::Attribute attribute) const {
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100235 int32_t value = 0;
236 auto error = static_cast<hal::Error>(
237 mComposer->getDisplayAttribute(hwcDisplayId, configId, attribute, &value));
238
239 RETURN_IF_HWC_ERROR_FOR("getDisplayAttribute", error, *toPhysicalDisplayId(hwcDisplayId), -1);
240 return value;
241}
242
Lloyd Pique1b33fc32021-05-07 14:36:58 -0700243std::shared_ptr<HWC2::Layer> HWComposer::createLayer(HalDisplayId displayId) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700244 RETURN_IF_INVALID_DISPLAY(displayId, nullptr);
245
Lloyd Pique1b33fc32021-05-07 14:36:58 -0700246 auto expected = mDisplayData[displayId].hwcDisplay->createLayer();
247 if (!expected.has_value()) {
248 auto error = std::move(expected).error();
249 RETURN_IF_HWC_ERROR(error, displayId, nullptr);
250 }
251 return std::move(expected).value();
Steven Thomas94e35b92017-07-26 18:48:28 -0700252}
253
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200254bool HWComposer::isConnected(PhysicalDisplayId displayId) const {
Ady Abraham2e9c7032021-03-29 14:01:56 -0700255 if (mDisplayData.count(displayId)) {
256 return mDisplayData.at(displayId).hwcDisplay->isConnected();
257 }
258
259 return false;
Mathias Agopian9c6e2972011-09-20 17:21:56 -0700260}
261
Marin Shalamanov045b7002021-01-07 16:56:24 +0100262std::vector<HWComposer::HWCDisplayMode> HWComposer::getModes(PhysicalDisplayId displayId) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700263 RETURN_IF_INVALID_DISPLAY(displayId, {});
264
Marin Shalamanov045b7002021-01-07 16:56:24 +0100265 const auto hwcDisplayId = mDisplayData.at(displayId).hwcDisplay->getId();
266 std::vector<hal::HWConfigId> configIds;
267 auto error = static_cast<hal::Error>(mComposer->getDisplayConfigs(hwcDisplayId, &configIds));
268 RETURN_IF_HWC_ERROR_FOR("getDisplayConfigs", error, *toPhysicalDisplayId(hwcDisplayId), {});
269
270 std::vector<HWCDisplayMode> modes;
271 modes.reserve(configIds.size());
272 for (auto configId : configIds) {
273 modes.push_back(HWCDisplayMode{
274 .hwcId = configId,
275 .width = getAttribute(hwcDisplayId, configId, hal::Attribute::WIDTH),
276 .height = getAttribute(hwcDisplayId, configId, hal::Attribute::HEIGHT),
277 .vsyncPeriod = getAttribute(hwcDisplayId, configId, hal::Attribute::VSYNC_PERIOD),
278 .dpiX = getAttribute(hwcDisplayId, configId, hal::Attribute::DPI_X),
279 .dpiY = getAttribute(hwcDisplayId, configId, hal::Attribute::DPI_Y),
280 .configGroup = getAttribute(hwcDisplayId, configId, hal::Attribute::CONFIG_GROUP),
281 });
282 }
283
284 return modes;
Mathias Agopianda27af92012-09-13 18:17:13 -0700285}
286
Marin Shalamanov045b7002021-01-07 16:56:24 +0100287std::optional<hal::HWConfigId> HWComposer::getActiveMode(PhysicalDisplayId displayId) const {
288 RETURN_IF_INVALID_DISPLAY(displayId, std::nullopt);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700289
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100290 const auto hwcId = *fromPhysicalDisplayId(displayId);
291 ALOGV("[%" PRIu64 "] getActiveMode", hwcId);
292 hal::HWConfigId configId;
293 auto error = static_cast<hal::Error>(mComposer->getActiveConfig(hwcId, &configId));
294
Peiyong Line9d809e2020-04-14 13:10:48 -0700295 if (error == hal::Error::BAD_CONFIG) {
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100296 LOG_DISPLAY_ERROR(displayId, "No active mode");
Marin Shalamanov045b7002021-01-07 16:56:24 +0100297 return std::nullopt;
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700298 }
299
Marin Shalamanov045b7002021-01-07 16:56:24 +0100300 return configId;
Mathias Agopiana350ff92010-08-10 17:14:02 -0700301}
302
Ady Abraham3a77a7b2019-12-02 18:46:59 -0800303// Composer 2.4
304
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100305ui::DisplayConnectionType HWComposer::getDisplayConnectionType(PhysicalDisplayId displayId) const {
306 RETURN_IF_INVALID_DISPLAY(displayId, ui::DisplayConnectionType::Internal);
Dominik Laskowski55c85402020-01-21 16:25:47 -0800307 const auto& hwcDisplay = mDisplayData.at(displayId).hwcDisplay;
308
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100309 ui::DisplayConnectionType type;
Dominik Laskowski55c85402020-01-21 16:25:47 -0800310 const auto error = hwcDisplay->getConnectionType(&type);
311
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700312 const auto FALLBACK_TYPE = hwcDisplay->getId() == mPrimaryHwcDisplayId
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100313 ? ui::DisplayConnectionType::Internal
314 : ui::DisplayConnectionType::External;
Dominik Laskowski55c85402020-01-21 16:25:47 -0800315
316 RETURN_IF_HWC_ERROR(error, displayId, FALLBACK_TYPE);
317 return type;
318}
319
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200320bool HWComposer::isVsyncPeriodSwitchSupported(PhysicalDisplayId displayId) const {
Dominik Laskowski55c85402020-01-21 16:25:47 -0800321 RETURN_IF_INVALID_DISPLAY(displayId, false);
Ady Abraham3a77a7b2019-12-02 18:46:59 -0800322 return mDisplayData.at(displayId).hwcDisplay->isVsyncPeriodSwitchSupported();
323}
324
Marin Shalamanov045b7002021-01-07 16:56:24 +0100325status_t HWComposer::getDisplayVsyncPeriod(PhysicalDisplayId displayId,
326 nsecs_t* outVsyncPeriod) const {
Dominik Laskowski55c85402020-01-21 16:25:47 -0800327 RETURN_IF_INVALID_DISPLAY(displayId, 0);
328
Marin Shalamanov045b7002021-01-07 16:56:24 +0100329 if (!isVsyncPeriodSwitchSupported(displayId)) {
330 return INVALID_OPERATION;
Dominik Laskowskif3749f82018-06-13 15:49:25 -0700331 }
Marin Shalamanov045b7002021-01-07 16:56:24 +0100332 const auto hwcId = *fromPhysicalDisplayId(displayId);
333 Hwc2::VsyncPeriodNanos vsyncPeriodNanos = 0;
334 auto error =
335 static_cast<hal::Error>(mComposer->getDisplayVsyncPeriod(hwcId, &vsyncPeriodNanos));
336 RETURN_IF_HWC_ERROR(error, displayId, 0);
337 *outVsyncPeriod = static_cast<nsecs_t>(vsyncPeriodNanos);
338 return NO_ERROR;
Lloyd Pique3c085a02018-05-09 19:38:32 -0700339}
340
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200341std::vector<ui::ColorMode> HWComposer::getColorModes(PhysicalDisplayId displayId) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700342 RETURN_IF_INVALID_DISPLAY(displayId, {});
343
Peiyong Linfd997e02018-03-28 15:29:00 -0700344 std::vector<ui::ColorMode> modes;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700345 auto error = mDisplayData.at(displayId).hwcDisplay->getColorModes(&modes);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700346 RETURN_IF_HWC_ERROR(error, displayId, {});
Courtney Goeltzenleuchterfad9d8c2016-06-23 11:49:50 -0600347 return modes;
348}
349
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200350status_t HWComposer::setActiveColorMode(PhysicalDisplayId displayId, ui::ColorMode mode,
Dominik Laskowski075d3172018-05-24 15:50:06 -0700351 ui::RenderIntent renderIntent) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700352 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Michael Wright28f24d02016-07-12 13:30:53 -0700353
354 auto& displayData = mDisplayData[displayId];
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700355 auto error = displayData.hwcDisplay->setColorMode(mode, renderIntent);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700356 RETURN_IF_HWC_ERROR_FOR(("setColorMode(" + decodeColorMode(mode) + ", " +
357 decodeRenderIntent(renderIntent) + ")")
358 .c_str(),
359 error, displayId, UNKNOWN_ERROR);
Michael Wright28f24d02016-07-12 13:30:53 -0700360
361 return NO_ERROR;
362}
363
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200364void HWComposer::setVsyncEnabled(PhysicalDisplayId displayId, hal::Vsync enabled) {
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700365 RETURN_IF_INVALID_DISPLAY(displayId);
366 auto& displayData = mDisplayData[displayId];
367
Dan Stoza9e56aa02015-11-02 13:00:03 -0800368 // NOTE: we use our own internal lock here because we have to call
369 // into the HWC with the lock held, and we want to make sure
370 // that even if HWC blocks (which it shouldn't), it won't
371 // affect other threads.
Dominik Laskowski1af47932018-11-12 10:20:46 -0800372 std::lock_guard lock(displayData.vsyncEnabledLock);
373 if (enabled == displayData.vsyncEnabled) {
374 return;
Colin Cross10fbdb62012-07-12 17:56:34 -0700375 }
Dominik Laskowski1af47932018-11-12 10:20:46 -0800376
377 ATRACE_CALL();
378 auto error = displayData.hwcDisplay->setVsyncEnabled(enabled);
379 RETURN_IF_HWC_ERROR(error, displayId);
380
381 displayData.vsyncEnabled = enabled;
382
383 const auto tag = "HW_VSYNC_ON_" + to_string(displayId);
Peiyong Line9d809e2020-04-14 13:10:48 -0700384 ATRACE_INT(tag.c_str(), enabled == hal::Vsync::ENABLE ? 1 : 0);
Colin Cross10fbdb62012-07-12 17:56:34 -0700385}
386
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200387status_t HWComposer::setClientTarget(HalDisplayId displayId, uint32_t slot,
Dominik Laskowski075d3172018-05-24 15:50:06 -0700388 const sp<Fence>& acquireFence, const sp<GraphicBuffer>& target,
389 ui::Dataspace dataspace) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700390 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Jesse Hall851cfe82013-03-20 13:44:00 -0700391
Dominik Laskowski34157762018-10-31 13:07:19 -0700392 ALOGV("%s for display %s", __FUNCTION__, to_string(displayId).c_str());
Dan Stoza9e56aa02015-11-02 13:00:03 -0800393 auto& hwcDisplay = mDisplayData[displayId].hwcDisplay;
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400394 auto error = hwcDisplay->setClientTarget(slot, target, acquireFence, dataspace);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700395 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
Jesse Hall851cfe82013-03-20 13:44:00 -0700396 return NO_ERROR;
397}
398
Lloyd Pique66d68602019-02-13 14:23:31 -0800399status_t HWComposer::getDeviceCompositionChanges(
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200400 HalDisplayId displayId, bool frameUsesClientComposition,
Ady Abrahamb42cdc12021-05-11 14:31:26 -0700401 std::chrono::steady_clock::time_point earliestPresentTime,
Ady Abraham43065bd2021-12-10 17:22:15 -0800402 const std::shared_ptr<FenceTime>& previousPresentFence, nsecs_t expectedPresentTime,
Lloyd Pique66d68602019-02-13 14:23:31 -0800403 std::optional<android::HWComposer::DeviceRequestedChanges>* outChanges) {
Dan Stoza9e56aa02015-11-02 13:00:03 -0800404 ATRACE_CALL();
405
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700406 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800407
408 auto& displayData = mDisplayData[displayId];
409 auto& hwcDisplay = displayData.hwcDisplay;
410 if (!hwcDisplay->isConnected()) {
411 return NO_ERROR;
412 }
413
414 uint32_t numTypes = 0;
415 uint32_t numRequests = 0;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700416
Peiyong Line9d809e2020-04-14 13:10:48 -0700417 hal::Error error = hal::Error::NONE;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700418
Ady Abrahamec7aa8a2021-06-28 12:37:09 -0700419 // First try to skip validate altogether. We can do that when
420 // 1. The previous frame has not been presented yet or already passed the
421 // earliest time to present. Otherwise, we may present a frame too early.
422 // 2. There is no client composition. Otherwise, we first need to render the
Ady Abrahamb42cdc12021-05-11 14:31:26 -0700423 // client target buffer.
Ady Abraham43065bd2021-12-10 17:22:15 -0800424 const bool canSkipValidate = [&] {
425 // We must call validate if we have client composition
426 if (frameUsesClientComposition) {
427 return false;
428 }
429
430 // If composer supports getting the expected present time, we can skip
431 // as composer will make sure to prevent early presentation
432 if (mComposer->isSupported(Hwc2::Composer::OptionalFeature::ExpectedPresentTime)) {
433 return true;
434 }
435
436 // composer doesn't support getting the expected present time. We can only
437 // skip validate if we know that we are not going to present early.
438 return std::chrono::steady_clock::now() >= earliestPresentTime ||
439 previousPresentFence->getSignalTime() == Fence::SIGNAL_TIME_PENDING;
440 }();
441
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700442 displayData.validateWasSkipped = false;
Ady Abrahamb42cdc12021-05-11 14:31:26 -0700443 if (canSkipValidate) {
Dominik Laskowski1af47932018-11-12 10:20:46 -0800444 sp<Fence> outPresentFence;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700445 uint32_t state = UINT32_MAX;
Ady Abraham43065bd2021-12-10 17:22:15 -0800446 error = hwcDisplay->presentOrValidate(expectedPresentTime, &numTypes, &numRequests,
447 &outPresentFence, &state);
Peiyong Line9d809e2020-04-14 13:10:48 -0700448 if (!hasChangesError(error)) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700449 RETURN_IF_HWC_ERROR_FOR("presentOrValidate", error, displayId, UNKNOWN_ERROR);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700450 }
451 if (state == 1) { //Present Succeeded.
Steven Thomas94e35b92017-07-26 18:48:28 -0700452 std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700453 error = hwcDisplay->getReleaseFences(&releaseFences);
454 displayData.releaseFences = std::move(releaseFences);
455 displayData.lastPresentFence = outPresentFence;
456 displayData.validateWasSkipped = true;
457 displayData.presentError = error;
458 return NO_ERROR;
459 }
460 // Present failed but Validate ran.
461 } else {
Ady Abraham43065bd2021-12-10 17:22:15 -0800462 error = hwcDisplay->validate(expectedPresentTime, &numTypes, &numRequests);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700463 }
464 ALOGV("SkipValidate failed, Falling back to SLOW validate/present");
Peiyong Line9d809e2020-04-14 13:10:48 -0700465 if (!hasChangesError(error)) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700466 RETURN_IF_HWC_ERROR_FOR("validate", error, displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800467 }
468
Lloyd Pique66d68602019-02-13 14:23:31 -0800469 android::HWComposer::DeviceRequestedChanges::ChangedTypes changedTypes;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800470 changedTypes.reserve(numTypes);
471 error = hwcDisplay->getChangedCompositionTypes(&changedTypes);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700472 RETURN_IF_HWC_ERROR_FOR("getChangedCompositionTypes", error, displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800473
Peiyong Line9d809e2020-04-14 13:10:48 -0700474 auto displayRequests = static_cast<hal::DisplayRequest>(0);
Lloyd Pique66d68602019-02-13 14:23:31 -0800475 android::HWComposer::DeviceRequestedChanges::LayerRequests layerRequests;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800476 layerRequests.reserve(numRequests);
Lloyd Pique66d68602019-02-13 14:23:31 -0800477 error = hwcDisplay->getRequests(&displayRequests, &layerRequests);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700478 RETURN_IF_HWC_ERROR_FOR("getRequests", error, displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800479
Peiyong Lindfc3f7c2020-05-07 20:15:50 -0700480 DeviceRequestedChanges::ClientTargetProperty clientTargetProperty;
Alec Mouri85065692022-03-18 00:58:26 +0000481 error = hwcDisplay->getClientTargetProperty(&clientTargetProperty);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800482
Peiyong Lindfc3f7c2020-05-07 20:15:50 -0700483 outChanges->emplace(DeviceRequestedChanges{std::move(changedTypes), std::move(displayRequests),
484 std::move(layerRequests),
Alec Mouri85065692022-03-18 00:58:26 +0000485 std::move(clientTargetProperty)});
Dan Stoza9e56aa02015-11-02 13:00:03 -0800486 error = hwcDisplay->acceptChanges();
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700487 RETURN_IF_HWC_ERROR_FOR("acceptChanges", error, displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800488
489 return NO_ERROR;
490}
491
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200492sp<Fence> HWComposer::getPresentFence(HalDisplayId displayId) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700493 RETURN_IF_INVALID_DISPLAY(displayId, Fence::NO_FENCE);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700494 return mDisplayData.at(displayId).lastPresentFence;
Jesse Hall851cfe82013-03-20 13:44:00 -0700495}
496
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200497sp<Fence> HWComposer::getLayerReleaseFence(HalDisplayId displayId, HWC2::Layer* layer) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700498 RETURN_IF_INVALID_DISPLAY(displayId, Fence::NO_FENCE);
Tim Murray2d3f8b82019-12-04 16:24:17 -0800499 const auto& displayFences = mDisplayData.at(displayId).releaseFences;
500 auto fence = displayFences.find(layer);
501 if (fence == displayFences.end()) {
Dan Stoza9e56aa02015-11-02 13:00:03 -0800502 ALOGV("getLayerReleaseFence: Release fence not found");
503 return Fence::NO_FENCE;
Riley Andrews03414a12014-07-01 14:22:59 -0700504 }
Tim Murray2d3f8b82019-12-04 16:24:17 -0800505 return fence->second;
Riley Andrews03414a12014-07-01 14:22:59 -0700506}
507
Ady Abrahamb42cdc12021-05-11 14:31:26 -0700508status_t HWComposer::presentAndGetReleaseFences(
Ady Abrahamec7aa8a2021-06-28 12:37:09 -0700509 HalDisplayId displayId, std::chrono::steady_clock::time_point earliestPresentTime,
510 const std::shared_ptr<FenceTime>& previousPresentFence) {
Dan Stoza9e56aa02015-11-02 13:00:03 -0800511 ATRACE_CALL();
Mathias Agopian3e8b8532012-05-13 20:42:01 -0700512
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700513 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Pablo Ceballosd814cf22015-09-11 14:37:39 -0700514
Dan Stoza9e56aa02015-11-02 13:00:03 -0800515 auto& displayData = mDisplayData[displayId];
516 auto& hwcDisplay = displayData.hwcDisplay;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700517
518 if (displayData.validateWasSkipped) {
Chia-I Wuae5a6b82017-10-10 09:09:22 -0700519 // explicitly flush all pending commands
Peiyong Line9d809e2020-04-14 13:10:48 -0700520 auto error = static_cast<hal::Error>(mComposer->executeCommands());
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800521 RETURN_IF_HWC_ERROR_FOR("executeCommands", error, displayId, UNKNOWN_ERROR);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700522 RETURN_IF_HWC_ERROR_FOR("present", displayData.presentError, displayId, UNKNOWN_ERROR);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700523 return NO_ERROR;
524 }
525
Ady Abraham43065bd2021-12-10 17:22:15 -0800526 const bool waitForEarliestPresent =
527 !mComposer->isSupported(Hwc2::Composer::OptionalFeature::ExpectedPresentTime) &&
528 previousPresentFence->getSignalTime() != Fence::SIGNAL_TIME_PENDING;
529
530 if (waitForEarliestPresent) {
Ady Abrahamb42cdc12021-05-11 14:31:26 -0700531 ATRACE_NAME("wait for earliest present time");
532 std::this_thread::sleep_until(earliestPresentTime);
533 }
534
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800535 auto error = hwcDisplay->present(&displayData.lastPresentFence);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700536 RETURN_IF_HWC_ERROR_FOR("present", error, displayId, UNKNOWN_ERROR);
Mathias Agopian3e8b8532012-05-13 20:42:01 -0700537
Steven Thomas94e35b92017-07-26 18:48:28 -0700538 std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800539 error = hwcDisplay->getReleaseFences(&releaseFences);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700540 RETURN_IF_HWC_ERROR_FOR("getReleaseFences", error, displayId, UNKNOWN_ERROR);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800541
542 displayData.releaseFences = std::move(releaseFences);
543
544 return NO_ERROR;
Mathias Agopiana350ff92010-08-10 17:14:02 -0700545}
546
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200547status_t HWComposer::setPowerMode(PhysicalDisplayId displayId, hal::PowerMode mode) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700548 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
549
Peiyong Line9d809e2020-04-14 13:10:48 -0700550 if (mode == hal::PowerMode::OFF) {
551 setVsyncEnabled(displayId, hal::Vsync::DISABLE);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800552 }
553
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700554 const auto& displayData = mDisplayData[displayId];
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700555 auto& hwcDisplay = displayData.hwcDisplay;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800556 switch (mode) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700557 case hal::PowerMode::OFF:
558 case hal::PowerMode::ON:
Dan Stoza9e56aa02015-11-02 13:00:03 -0800559 ALOGV("setPowerMode: Calling HWC %s", to_string(mode).c_str());
560 {
561 auto error = hwcDisplay->setPowerMode(mode);
Peiyong Line9d809e2020-04-14 13:10:48 -0700562 if (error != hal::Error::NONE) {
563 LOG_HWC_ERROR(("setPowerMode(" + to_string(mode) + ")").c_str(), error,
564 displayId);
Peiyong Lin306e4992018-05-07 16:18:22 -0700565 }
Mathias Agopianda27af92012-09-13 18:17:13 -0700566 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800567 break;
Peiyong Line9d809e2020-04-14 13:10:48 -0700568 case hal::PowerMode::DOZE:
569 case hal::PowerMode::DOZE_SUSPEND:
Dan Stoza9e56aa02015-11-02 13:00:03 -0800570 ALOGV("setPowerMode: Calling HWC %s", to_string(mode).c_str());
571 {
572 bool supportsDoze = false;
573 auto error = hwcDisplay->supportsDoze(&supportsDoze);
Peiyong Line9d809e2020-04-14 13:10:48 -0700574 if (error != hal::Error::NONE) {
Peiyong Lin306e4992018-05-07 16:18:22 -0700575 LOG_HWC_ERROR("supportsDoze", error, displayId);
576 }
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700577
Dan Stoza9e56aa02015-11-02 13:00:03 -0800578 if (!supportsDoze) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700579 mode = hal::PowerMode::ON;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800580 }
581
582 error = hwcDisplay->setPowerMode(mode);
Peiyong Line9d809e2020-04-14 13:10:48 -0700583 if (error != hal::Error::NONE) {
584 LOG_HWC_ERROR(("setPowerMode(" + to_string(mode) + ")").c_str(), error,
585 displayId);
Peiyong Lin306e4992018-05-07 16:18:22 -0700586 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800587 }
588 break;
589 default:
590 ALOGV("setPowerMode: Not calling HWC");
591 break;
Mathias Agopianda27af92012-09-13 18:17:13 -0700592 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800593
594 return NO_ERROR;
595}
596
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100597status_t HWComposer::setActiveModeWithConstraints(
Marin Shalamanov12c9e5a2021-01-07 00:25:35 +0100598 PhysicalDisplayId displayId, hal::HWConfigId hwcModeId,
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200599 const hal::VsyncPeriodChangeConstraints& constraints,
Peiyong Line9d809e2020-04-14 13:10:48 -0700600 hal::VsyncPeriodChangeTimeline* outTimeline) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700601 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800602
Marin Shalamanov12c9e5a2021-01-07 00:25:35 +0100603 auto error = mDisplayData[displayId].hwcDisplay->setActiveConfigWithConstraints(hwcModeId,
604 constraints,
605 outTimeline);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700606 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800607 return NO_ERROR;
608}
609
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200610status_t HWComposer::setColorTransform(HalDisplayId displayId, const mat4& transform) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700611 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dan Stoza9f26a9c2016-06-22 14:51:09 -0700612
613 auto& displayData = mDisplayData[displayId];
Ady Abrahamdc011a92021-12-21 14:06:44 -0800614 auto error = displayData.hwcDisplay->setColorTransform(transform);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700615 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
Dan Stoza9f26a9c2016-06-22 14:51:09 -0700616 return NO_ERROR;
617}
618
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200619void HWComposer::disconnectDisplay(HalDisplayId displayId) {
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700620 RETURN_IF_INVALID_DISPLAY(displayId);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800621 auto& displayData = mDisplayData[displayId];
Dominik Laskowski7e045462018-05-30 13:02:02 -0700622 const auto hwcDisplayId = displayData.hwcDisplay->getId();
Dominik Laskowski075d3172018-05-24 15:50:06 -0700623
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800624 mPhysicalDisplayIdMap.erase(hwcDisplayId);
625 mDisplayData.erase(displayId);
Marin Shalamanov8b196592021-08-09 16:24:42 +0200626
627 // Reset the primary display ID if we're disconnecting it.
628 // This way isHeadless() will return false, which is necessary
629 // because getPrimaryDisplayId() will crash.
630 if (mPrimaryHwcDisplayId == hwcDisplayId) {
631 mPrimaryHwcDisplayId.reset();
632 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800633}
634
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200635status_t HWComposer::setOutputBuffer(HalVirtualDisplayId displayId, const sp<Fence>& acquireFence,
Dominik Laskowski075d3172018-05-24 15:50:06 -0700636 const sp<GraphicBuffer>& buffer) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700637 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700638 const auto& displayData = mDisplayData[displayId];
Dan Stoza9e56aa02015-11-02 13:00:03 -0800639
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700640 auto error = displayData.hwcDisplay->setOutputBuffer(buffer, acquireFence);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700641 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800642 return NO_ERROR;
643}
644
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200645void HWComposer::clearReleaseFences(HalDisplayId displayId) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700646 RETURN_IF_INVALID_DISPLAY(displayId);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800647 mDisplayData[displayId].releaseFences.clear();
Mathias Agopian3e8b8532012-05-13 20:42:01 -0700648}
649
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200650status_t HWComposer::getHdrCapabilities(HalDisplayId displayId, HdrCapabilities* outCapabilities) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700651 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dan Stozac4f471e2016-03-24 09:31:08 -0700652
653 auto& hwcDisplay = mDisplayData[displayId].hwcDisplay;
Peiyong Lin62665892018-04-16 11:07:44 -0700654 auto error = hwcDisplay->getHdrCapabilities(outCapabilities);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700655 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
Peiyong Lin62665892018-04-16 11:07:44 -0700656 return NO_ERROR;
Dan Stozac4f471e2016-03-24 09:31:08 -0700657}
658
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200659int32_t HWComposer::getSupportedPerFrameMetadata(HalDisplayId displayId) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700660 RETURN_IF_INVALID_DISPLAY(displayId, 0);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700661 return mDisplayData.at(displayId).hwcDisplay->getSupportedPerFrameMetadata();
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700662}
663
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200664std::vector<ui::RenderIntent> HWComposer::getRenderIntents(HalDisplayId displayId,
Dominik Laskowski075d3172018-05-24 15:50:06 -0700665 ui::ColorMode colorMode) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700666 RETURN_IF_INVALID_DISPLAY(displayId, {});
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700667
668 std::vector<ui::RenderIntent> renderIntents;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700669 auto error = mDisplayData.at(displayId).hwcDisplay->getRenderIntents(colorMode, &renderIntents);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700670 RETURN_IF_HWC_ERROR(error, displayId, {});
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700671 return renderIntents;
672}
673
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200674mat4 HWComposer::getDataspaceSaturationMatrix(HalDisplayId displayId, ui::Dataspace dataspace) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700675 RETURN_IF_INVALID_DISPLAY(displayId, {});
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700676
677 mat4 matrix;
678 auto error = mDisplayData[displayId].hwcDisplay->getDataspaceSaturationMatrix(dataspace,
679 &matrix);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700680 RETURN_IF_HWC_ERROR(error, displayId, {});
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700681 return matrix;
682}
683
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200684status_t HWComposer::getDisplayedContentSamplingAttributes(HalDisplayId displayId,
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700685 ui::PixelFormat* outFormat,
686 ui::Dataspace* outDataspace,
687 uint8_t* outComponentMask) {
688 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
689 const auto error =
690 mDisplayData[displayId]
691 .hwcDisplay->getDisplayedContentSamplingAttributes(outFormat, outDataspace,
692 outComponentMask);
Peiyong Line9d809e2020-04-14 13:10:48 -0700693 if (error == hal::Error::UNSUPPORTED) RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700694 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
695 return NO_ERROR;
696}
697
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200698status_t HWComposer::setDisplayContentSamplingEnabled(HalDisplayId displayId, bool enabled,
Kevin DuBois74e53772018-11-19 10:52:38 -0800699 uint8_t componentMask, uint64_t maxFrames) {
700 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
701 const auto error =
702 mDisplayData[displayId].hwcDisplay->setDisplayContentSamplingEnabled(enabled,
703 componentMask,
704 maxFrames);
705
Peiyong Line9d809e2020-04-14 13:10:48 -0700706 if (error == hal::Error::UNSUPPORTED) RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
707 if (error == hal::Error::BAD_PARAMETER) RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
Kevin DuBois74e53772018-11-19 10:52:38 -0800708 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
709 return NO_ERROR;
710}
711
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200712status_t HWComposer::getDisplayedContentSample(HalDisplayId displayId, uint64_t maxFrames,
Kevin DuBois1d4249a2018-08-29 10:45:14 -0700713 uint64_t timestamp, DisplayedFrameStats* outStats) {
714 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
715 const auto error =
716 mDisplayData[displayId].hwcDisplay->getDisplayedContentSample(maxFrames, timestamp,
717 outStats);
718 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
719 return NO_ERROR;
720}
721
Dominik Laskowskib17c6212022-05-09 09:36:19 -0700722ftl::Future<status_t> HWComposer::setDisplayBrightness(
Alec Mouri4d8a05d2022-03-23 18:14:26 +0000723 PhysicalDisplayId displayId, float brightness, float brightnessNits,
Alec Mouricdf16792021-12-10 13:16:06 -0800724 const Hwc2::Composer::DisplayBrightnessOptions& options) {
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -0800725 RETURN_IF_INVALID_DISPLAY(displayId, ftl::yield<status_t>(BAD_INDEX));
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700726 auto& display = mDisplayData[displayId].hwcDisplay;
727
Dominik Laskowskib17c6212022-05-09 09:36:19 -0700728 return display->setDisplayBrightness(brightness, brightnessNits, options)
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700729 .then([displayId](hal::Error error) -> status_t {
730 if (error == hal::Error::UNSUPPORTED) {
731 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
732 }
733 if (error == hal::Error::BAD_PARAMETER) {
734 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
735 }
736 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
737 return NO_ERROR;
738 });
Dan Gittik57e63c52019-01-18 16:37:54 +0000739}
740
Matt Buckley50c44062022-01-17 20:48:10 +0000741bool HWComposer::getValidateSkipped(HalDisplayId displayId) const {
742 if (mDisplayData.count(displayId) == 0) {
743 return false;
744 }
745 return mDisplayData.at(displayId).validateWasSkipped;
746}
747
Kriti Dang7defaf32021-11-15 11:55:43 +0100748status_t HWComposer::setBootDisplayMode(PhysicalDisplayId displayId,
749 hal::HWConfigId displayModeId) {
750 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
751 const auto error = mDisplayData[displayId].hwcDisplay->setBootDisplayConfig(displayModeId);
752 if (error == hal::Error::UNSUPPORTED) {
753 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
754 }
755 if (error == hal::Error::BAD_PARAMETER) {
756 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
757 }
758 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
759 return NO_ERROR;
760}
761
762status_t HWComposer::clearBootDisplayMode(PhysicalDisplayId displayId) {
763 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
764 const auto error = mDisplayData[displayId].hwcDisplay->clearBootDisplayConfig();
765 if (error == hal::Error::UNSUPPORTED) {
766 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
767 }
768 if (error == hal::Error::BAD_PARAMETER) {
769 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
770 }
771 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
772 return NO_ERROR;
773}
774
Kriti Dang16ca2972022-02-01 20:07:03 +0100775std::optional<hal::HWConfigId> HWComposer::getPreferredBootDisplayMode(
776 PhysicalDisplayId displayId) {
777 RETURN_IF_INVALID_DISPLAY(displayId, std::nullopt);
778 hal::HWConfigId displayModeId;
Kriti Dang7defaf32021-11-15 11:55:43 +0100779 const auto error =
780 mDisplayData[displayId].hwcDisplay->getPreferredBootDisplayConfig(&displayModeId);
Kriti Dang16ca2972022-02-01 20:07:03 +0100781 if (error != hal::Error::NONE) {
782 LOG_DISPLAY_ERROR(displayId, to_string(error).c_str());
783 return std::nullopt;
Kriti Dang7defaf32021-11-15 11:55:43 +0100784 }
Kriti Dang7defaf32021-11-15 11:55:43 +0100785 return displayModeId;
786}
787
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500788status_t HWComposer::getDisplayDecorationSupport(
789 PhysicalDisplayId displayId,
790 std::optional<aidl::android::hardware::graphics::common::DisplayDecorationSupport>*
791 support) {
792 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
793 const auto error = mDisplayData[displayId].hwcDisplay->getDisplayDecorationSupport(support);
794 if (error == hal::Error::UNSUPPORTED) {
795 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
796 }
797 if (error == hal::Error::BAD_PARAMETER) {
798 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
799 }
800 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
801 return NO_ERROR;
802}
803
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200804status_t HWComposer::setAutoLowLatencyMode(PhysicalDisplayId displayId, bool on) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100805 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
806 const auto error = mDisplayData[displayId].hwcDisplay->setAutoLowLatencyMode(on);
Peiyong Line9d809e2020-04-14 13:10:48 -0700807 if (error == hal::Error::UNSUPPORTED) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100808 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
809 }
Peiyong Line9d809e2020-04-14 13:10:48 -0700810 if (error == hal::Error::BAD_PARAMETER) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100811 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
812 }
813 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
814 return NO_ERROR;
815}
816
817status_t HWComposer::getSupportedContentTypes(
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -0800818 PhysicalDisplayId displayId,
819 std::vector<hal::ContentType>* outSupportedContentTypes) const {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100820 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -0800821 const auto error = mDisplayData.at(displayId).hwcDisplay->getSupportedContentTypes(
822 outSupportedContentTypes);
Galia Peycheva5492cb52019-10-30 14:13:16 +0100823
824 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
825
826 return NO_ERROR;
827}
828
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200829status_t HWComposer::setContentType(PhysicalDisplayId displayId, hal::ContentType contentType) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100830 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
831 const auto error = mDisplayData[displayId].hwcDisplay->setContentType(contentType);
Peiyong Line9d809e2020-04-14 13:10:48 -0700832 if (error == hal::Error::UNSUPPORTED) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100833 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
834 }
Peiyong Line9d809e2020-04-14 13:10:48 -0700835 if (error == hal::Error::BAD_PARAMETER) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100836 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
837 }
838 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
839
840 return NO_ERROR;
841}
842
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800843const std::unordered_map<std::string, bool>& HWComposer::getSupportedLayerGenericMetadata() const {
844 return mSupportedLayerGenericMetadata;
845}
846
Yiwei Zhang5434a782018-12-05 18:06:32 -0800847void HWComposer::dump(std::string& result) const {
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800848 result.append(mComposer->dumpDebugInfo());
Mathias Agopian83727852010-09-23 18:13:21 -0700849}
850
Marin Shalamanova524a092020-07-27 21:39:55 +0200851std::optional<PhysicalDisplayId> HWComposer::toPhysicalDisplayId(
852 hal::HWDisplayId hwcDisplayId) const {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700853 if (const auto it = mPhysicalDisplayIdMap.find(hwcDisplayId);
854 it != mPhysicalDisplayIdMap.end()) {
855 return it->second;
856 }
857 return {};
858}
859
Marin Shalamanova524a092020-07-27 21:39:55 +0200860std::optional<hal::HWDisplayId> HWComposer::fromPhysicalDisplayId(
861 PhysicalDisplayId displayId) const {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700862 if (const auto it = mDisplayData.find(displayId); it != mDisplayData.end()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700863 return it->second.hwcDisplay->getId();
864 }
865 return {};
866}
867
Peiyong Line9d809e2020-04-14 13:10:48 -0700868bool HWComposer::shouldIgnoreHotplugConnect(hal::HWDisplayId hwcDisplayId,
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100869 bool hasDisplayIdentificationData) const {
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100870 if (mHasMultiDisplaySupport && !hasDisplayIdentificationData) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700871 ALOGE("Ignoring connection of display %" PRIu64 " without identification data",
872 hwcDisplayId);
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100873 return true;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700874 }
875
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700876 // Legacy mode only supports IDs LEGACY_DISPLAY_TYPE_PRIMARY and LEGACY_DISPLAY_TYPE_EXTERNAL.
877 if (!mHasMultiDisplaySupport && mPhysicalDisplayIdMap.size() == 2) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700878 ALOGE("Ignoring connection of tertiary display %" PRIu64, hwcDisplayId);
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100879 return true;
880 }
881
882 return false;
883}
884
Peiyong Line9d809e2020-04-14 13:10:48 -0700885std::optional<DisplayIdentificationInfo> HWComposer::onHotplugConnect(
886 hal::HWDisplayId hwcDisplayId) {
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100887 std::optional<DisplayIdentificationInfo> info;
888 if (const auto displayId = toPhysicalDisplayId(hwcDisplayId)) {
889 info = DisplayIdentificationInfo{.id = *displayId,
890 .name = std::string(),
891 .deviceProductInfo = std::nullopt};
Marin Shalamanovf8c63722020-10-06 13:11:21 +0200892 if (mUpdateDeviceProductInfoOnHotplugReconnect) {
893 uint8_t port;
894 DisplayIdentificationData data;
895 getDisplayIdentificationData(hwcDisplayId, &port, &data);
896 if (auto newInfo = parseDisplayIdentificationData(port, data)) {
897 info->deviceProductInfo = std::move(newInfo->deviceProductInfo);
898 } else {
899 ALOGE("Failed to parse identification data for display %" PRIu64, hwcDisplayId);
900 }
901 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700902 } else {
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100903 uint8_t port;
904 DisplayIdentificationData data;
905 const bool hasDisplayIdentificationData =
906 getDisplayIdentificationData(hwcDisplayId, &port, &data);
907 if (mPhysicalDisplayIdMap.empty()) {
908 mHasMultiDisplaySupport = hasDisplayIdentificationData;
909 ALOGI("Switching to %s multi-display mode",
910 mHasMultiDisplaySupport ? "generalized" : "legacy");
911 }
912
913 if (shouldIgnoreHotplugConnect(hwcDisplayId, hasDisplayIdentificationData)) {
914 return {};
915 }
916
917 info = [this, hwcDisplayId, &port, &data, hasDisplayIdentificationData] {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700918 const bool isPrimary = !mPrimaryHwcDisplayId;
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100919 if (mHasMultiDisplaySupport) {
920 if (const auto info = parseDisplayIdentificationData(port, data)) {
921 return *info;
922 }
923 ALOGE("Failed to parse identification data for display %" PRIu64, hwcDisplayId);
924 } else {
925 ALOGW_IF(hasDisplayIdentificationData,
926 "Ignoring identification data for display %" PRIu64, hwcDisplayId);
Peiyong Lin65248e02020-04-18 21:15:07 -0700927 port = isPrimary ? LEGACY_DISPLAY_TYPE_PRIMARY : LEGACY_DISPLAY_TYPE_EXTERNAL;
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100928 }
929
Marin Shalamanova524a092020-07-27 21:39:55 +0200930 return DisplayIdentificationInfo{.id = PhysicalDisplayId::fromPort(port),
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700931 .name = isPrimary ? "Primary display"
932 : "Secondary display",
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100933 .deviceProductInfo = std::nullopt};
934 }();
Dominik Laskowski075d3172018-05-24 15:50:06 -0700935 }
936
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100937 if (!isConnected(info->id)) {
938 allocatePhysicalDisplay(hwcDisplayId, info->id);
939 }
940 return info;
941}
942
943std::optional<DisplayIdentificationInfo> HWComposer::onHotplugDisconnect(
Peiyong Line9d809e2020-04-14 13:10:48 -0700944 hal::HWDisplayId hwcDisplayId) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700945 LOG_ALWAYS_FATAL_IF(hwcDisplayId == mPrimaryHwcDisplayId,
946 "Primary display cannot be disconnected.");
947
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100948 const auto displayId = toPhysicalDisplayId(hwcDisplayId);
949 if (!displayId) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700950 LOG_HWC_DISPLAY_ERROR(hwcDisplayId, "Invalid HWC display");
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100951 return {};
Dominik Laskowski075d3172018-05-24 15:50:06 -0700952 }
953
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100954 // The display will later be destroyed by a call to
955 // destroyDisplay(). For now we just mark it disconnected.
956 if (isConnected(*displayId)) {
957 mDisplayData[*displayId].hwcDisplay->setConnected(false);
958 } else {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700959 LOG_HWC_DISPLAY_ERROR(hwcDisplayId, "Already disconnected");
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100960 }
961 // The cleanup of Disconnect is handled through HWComposer::disconnectDisplay
962 // via SurfaceFlinger's onHotplugReceived callback handling
963 return DisplayIdentificationInfo{.id = *displayId,
964 .name = std::string(),
Marin Shalamanovf5de90d2019-10-08 10:57:25 +0200965 .deviceProductInfo = std::nullopt};
Steven Thomas6e8f7062017-11-22 14:15:29 -0800966}
967
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800968void HWComposer::loadCapabilities() {
Peiyong Line9d809e2020-04-14 13:10:48 -0700969 static_assert(sizeof(hal::Capability) == sizeof(int32_t), "Capability size has changed");
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800970 auto capabilities = mComposer->getCapabilities();
971 for (auto capability : capabilities) {
Ady Abrahamde549d42022-01-26 19:19:17 -0800972 mCapabilities.emplace(capability);
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800973 }
974}
975
ramindani32cf0602022-03-02 02:30:29 +0000976status_t HWComposer::setIdleTimerEnabled(PhysicalDisplayId displayId,
977 std::chrono::milliseconds timeout) {
978 ATRACE_CALL();
979 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
980 const auto error = mDisplayData[displayId].hwcDisplay->setIdleTimerEnabled(timeout);
981 if (error == hal::Error::UNSUPPORTED) {
982 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
983 }
984 if (error == hal::Error::BAD_PARAMETER) {
985 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
986 }
987 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
988 return NO_ERROR;
989}
990
ramindani06e518e2022-03-14 18:47:53 +0000991bool HWComposer::hasDisplayIdleTimerCapability(PhysicalDisplayId displayId) const {
ramindani32cf0602022-03-02 02:30:29 +0000992 RETURN_IF_INVALID_DISPLAY(displayId, false);
ramindani06e518e2022-03-14 18:47:53 +0000993 return mDisplayData.at(displayId).hwcDisplay->hasDisplayIdleTimerCapability();
994}
995
996Hwc2::AidlTransform HWComposer::getPhysicalDisplayOrientation(PhysicalDisplayId displayId) const {
997 ATRACE_CALL();
998 RETURN_IF_INVALID_DISPLAY(displayId, Hwc2::AidlTransform::NONE);
999 Hwc2::AidlTransform outTransform;
1000 const auto& hwcDisplay = mDisplayData.at(displayId).hwcDisplay;
1001 const auto error = hwcDisplay->getPhysicalDisplayOrientation(&outTransform);
1002 RETURN_IF_HWC_ERROR(error, displayId, Hwc2::AidlTransform::NONE);
1003 return outTransform;
ramindani32cf0602022-03-02 02:30:29 +00001004}
1005
Lloyd Pique4603f3c2020-02-11 12:06:56 -08001006void HWComposer::loadLayerMetadataSupport() {
1007 mSupportedLayerGenericMetadata.clear();
1008
1009 std::vector<Hwc2::IComposerClient::LayerGenericMetadataKey> supportedMetadataKeyInfo;
1010 const auto error = mComposer->getLayerGenericMetadataKeys(&supportedMetadataKeyInfo);
1011 if (error != hardware::graphics::composer::V2_4::Error::NONE) {
Ady Abraham3891cbe2021-03-29 11:29:31 -07001012 if (error != hardware::graphics::composer::V2_4::Error::UNSUPPORTED) {
1013 ALOGE("%s: %s failed: %s (%d)", __FUNCTION__, "getLayerGenericMetadataKeys",
1014 toString(error).c_str(), static_cast<int32_t>(error));
1015 }
Lloyd Pique4603f3c2020-02-11 12:06:56 -08001016 return;
1017 }
1018
1019 for (const auto& [name, mandatory] : supportedMetadataKeyInfo) {
1020 mSupportedLayerGenericMetadata.emplace(name, mandatory);
1021 }
1022}
1023
Lloyd Pique441d5042018-10-18 16:49:51 -07001024} // namespace impl
Dominik Laskowskif9750f22018-06-06 12:24:53 -07001025} // namespace android
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08001026
1027// TODO(b/129481165): remove the #pragma below and fix conversion issues
1028#pragma clang diagnostic pop // ignored "-Wconversion"