Merge "Add additional parameters for the captureLayer functions."
diff --git a/cmds/dumpstate/DumpstateUtil.cpp b/cmds/dumpstate/DumpstateUtil.cpp
index ede4254..85eb464 100644
--- a/cmds/dumpstate/DumpstateUtil.cpp
+++ b/cmds/dumpstate/DumpstateUtil.cpp
@@ -43,7 +43,7 @@
static constexpr const char* kSuPath = "/system/xbin/su";
-static bool waitpid_with_timeout(pid_t pid, int timeout_seconds, int* status) {
+static bool waitpid_with_timeout(pid_t pid, int timeout_ms, int* status) {
sigset_t child_mask, old_mask;
sigemptyset(&child_mask);
sigaddset(&child_mask, SIGCHLD);
@@ -54,10 +54,11 @@
}
timespec ts;
- ts.tv_sec = timeout_seconds;
- ts.tv_nsec = 0;
+ ts.tv_sec = MSEC_TO_SEC(timeout_ms);
+ ts.tv_nsec = (timeout_ms % 1000) * 1000000;
int ret = TEMP_FAILURE_RETRY(sigtimedwait(&child_mask, NULL, &ts));
int saved_errno = errno;
+
// Set the signals back the way they were.
if (sigprocmask(SIG_SETMASK, &old_mask, NULL) == -1) {
printf("*** sigprocmask failed: %s\n", strerror(errno));
@@ -91,7 +92,7 @@
CommandOptions CommandOptions::DEFAULT = CommandOptions::WithTimeout(10).Build();
CommandOptions CommandOptions::AS_ROOT = CommandOptions::WithTimeout(10).AsRoot().Build();
-CommandOptions::CommandOptionsBuilder::CommandOptionsBuilder(int64_t timeout) : values(timeout) {
+CommandOptions::CommandOptionsBuilder::CommandOptionsBuilder(int64_t timeout_ms) : values(timeout_ms) {
}
CommandOptions::CommandOptionsBuilder& CommandOptions::CommandOptionsBuilder::Always() {
@@ -130,8 +131,8 @@
return CommandOptions(values);
}
-CommandOptions::CommandOptionsValues::CommandOptionsValues(int64_t timeout)
- : timeout_(timeout),
+CommandOptions::CommandOptionsValues::CommandOptionsValues(int64_t timeout_ms)
+ : timeout_ms_(timeout_ms),
always_(false),
account_mode_(DONT_DROP_ROOT),
output_mode_(NORMAL_OUTPUT),
@@ -142,7 +143,11 @@
}
int64_t CommandOptions::Timeout() const {
- return values.timeout_;
+ return MSEC_TO_SEC(values.timeout_ms_);
+}
+
+int64_t CommandOptions::TimeoutInMs() const {
+ return values.timeout_ms_;
}
bool CommandOptions::Always() const {
@@ -161,8 +166,12 @@
return values.logging_message_;
}
-CommandOptions::CommandOptionsBuilder CommandOptions::WithTimeout(int64_t timeout) {
- return CommandOptions::CommandOptionsBuilder(timeout);
+CommandOptions::CommandOptionsBuilder CommandOptions::WithTimeout(int64_t timeout_sec) {
+ return CommandOptions::CommandOptionsBuilder(SEC_TO_MSEC(timeout_sec));
+}
+
+CommandOptions::CommandOptionsBuilder CommandOptions::WithTimeoutInMs(int64_t timeout_ms) {
+ return CommandOptions::CommandOptionsBuilder(timeout_ms);
}
std::string PropertiesHelper::build_type_ = "";
@@ -314,7 +323,7 @@
/* handle parent case */
int status;
- bool ret = waitpid_with_timeout(pid, options.Timeout(), &status);
+ bool ret = waitpid_with_timeout(pid, options.TimeoutInMs(), &status);
fsync(fd);
uint64_t elapsed = Nanotime() - start;
@@ -333,9 +342,9 @@
static_cast<float>(elapsed) / NANOS_PER_SEC, pid);
}
kill(pid, SIGTERM);
- if (!waitpid_with_timeout(pid, 5, nullptr)) {
+ if (!waitpid_with_timeout(pid, 5000, nullptr)) {
kill(pid, SIGKILL);
- if (!waitpid_with_timeout(pid, 5, nullptr)) {
+ if (!waitpid_with_timeout(pid, 5000, nullptr)) {
if (!silent)
dprintf(fd, "could not kill command '%s' (pid %d) even with SIGKILL.\n",
command, pid);
diff --git a/cmds/dumpstate/DumpstateUtil.h b/cmds/dumpstate/DumpstateUtil.h
index 698ceff..8342099 100644
--- a/cmds/dumpstate/DumpstateUtil.h
+++ b/cmds/dumpstate/DumpstateUtil.h
@@ -19,6 +19,16 @@
#include <cstdint>
#include <string>
+/*
+ * Converts seconds to milliseconds.
+ */
+#define SEC_TO_MSEC(second) (second * 1000)
+
+/*
+ * Converts milliseconds to seconds.
+ */
+#define MSEC_TO_SEC(millisecond) (millisecond / 1000)
+
namespace android {
namespace os {
namespace dumpstate {
@@ -66,9 +76,9 @@
private:
class CommandOptionsValues {
private:
- CommandOptionsValues(int64_t timeout);
+ CommandOptionsValues(int64_t timeout_ms);
- int64_t timeout_;
+ int64_t timeout_ms_;
bool always_;
PrivilegeMode account_mode_;
OutputMode output_mode_;
@@ -102,13 +112,15 @@
CommandOptions Build();
private:
- CommandOptionsBuilder(int64_t timeout);
+ CommandOptionsBuilder(int64_t timeout_ms);
CommandOptionsValues values;
friend class CommandOptions;
};
- /** Gets the command timeout, in seconds. */
+ /** Gets the command timeout in seconds. */
int64_t Timeout() const;
+ /** Gets the command timeout in milliseconds. */
+ int64_t TimeoutInMs() const;
/* Checks whether the command should always be run, even on dry-run mode. */
bool Always() const;
/** Gets the PrivilegeMode of the command. */
@@ -118,8 +130,11 @@
/** Gets the logging message header, it any. */
std::string LoggingMessage() const;
- /** Creates a builder with the requied timeout. */
- static CommandOptionsBuilder WithTimeout(int64_t timeout);
+ /** Creates a builder with the requied timeout in seconds. */
+ static CommandOptionsBuilder WithTimeout(int64_t timeout_sec);
+
+ /** Creates a builder with the requied timeout in milliseconds. */
+ static CommandOptionsBuilder WithTimeoutInMs(int64_t timeout_ms);
// Common options.
static CommandOptions DEFAULT;
diff --git a/cmds/dumpstate/dumpstate.cpp b/cmds/dumpstate/dumpstate.cpp
index 364ead0..aba08d9 100644
--- a/cmds/dumpstate/dumpstate.cpp
+++ b/cmds/dumpstate/dumpstate.cpp
@@ -113,8 +113,8 @@
}
static void RunDumpsys(const std::string& title, const std::vector<std::string>& dumpsysArgs,
const CommandOptions& options = Dumpstate::DEFAULT_DUMPSYS,
- long dumpsysTimeout = 0) {
- return ds.RunDumpsys(title, dumpsysArgs, options, dumpsysTimeout);
+ long dumpsysTimeoutMs = 0) {
+ return ds.RunDumpsys(title, dumpsysArgs, options, dumpsysTimeoutMs);
}
static int DumpFile(const std::string& title, const std::string& path) {
return ds.DumpFile(title, path);
@@ -830,33 +830,32 @@
}
static void DoLogcat() {
- unsigned long timeout;
+ unsigned long timeout_ms;
// DumpFile("EVENT LOG TAGS", "/etc/event-log-tags");
// calculate timeout
- timeout = logcat_timeout("main") + logcat_timeout("system") + logcat_timeout("crash");
- if (timeout < 20000) {
- timeout = 20000;
+ timeout_ms = logcat_timeout("main") + logcat_timeout("system") + logcat_timeout("crash");
+ if (timeout_ms < 20000) {
+ timeout_ms = 20000;
}
RunCommand("SYSTEM LOG",
- {"logcat", "-v", "threadtime", "-v", "printable", "-v", "uid",
- "-d", "*:v"},
- CommandOptions::WithTimeout(timeout / 1000).Build());
- timeout = logcat_timeout("events");
- if (timeout < 20000) {
- timeout = 20000;
+ {"logcat", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v"},
+ CommandOptions::WithTimeoutInMs(timeout_ms).Build());
+ timeout_ms = logcat_timeout("events");
+ if (timeout_ms < 20000) {
+ timeout_ms = 20000;
}
RunCommand("EVENT LOG",
{"logcat", "-b", "events", "-v", "threadtime", "-v", "printable", "-v", "uid",
"-d", "*:v"},
- CommandOptions::WithTimeout(timeout / 1000).Build());
- timeout = logcat_timeout("radio");
- if (timeout < 20000) {
- timeout = 20000;
+ CommandOptions::WithTimeoutInMs(timeout_ms).Build());
+ timeout_ms = logcat_timeout("radio");
+ if (timeout_ms < 20000) {
+ timeout_ms = 20000;
}
RunCommand("RADIO LOG",
{"logcat", "-b", "radio", "-v", "threadtime", "-v", "printable", "-v", "uid",
"-d", "*:v"},
- CommandOptions::WithTimeout(timeout / 1000).Build());
+ CommandOptions::WithTimeoutInMs(timeout_ms).Build());
RunCommand("LOG STATISTICS", {"logcat", "-b", "all", "-S"});
diff --git a/cmds/dumpstate/dumpstate.h b/cmds/dumpstate/dumpstate.h
index 1bfafba..8db23a9 100644
--- a/cmds/dumpstate/dumpstate.h
+++ b/cmds/dumpstate/dumpstate.h
@@ -196,19 +196,19 @@
/*
* Runs `dumpsys` with the given arguments, automatically setting its timeout
- * (`-t` argument)
+ * (`-T` argument)
* according to the command options.
*
* |title| description of the command printed on `stdout` (or empty to skip
* description).
* |dumpsys_args| `dumpsys` arguments (except `-t`).
* |options| optional argument defining the command's behavior.
- * |dumpsys_timeout| when > 0, defines the value passed to `dumpsys -t` (otherwise it uses the
+ * |dumpsys_timeout| when > 0, defines the value passed to `dumpsys -T` (otherwise it uses the
* timeout from `options`)
*/
void RunDumpsys(const std::string& title, const std::vector<std::string>& dumpsys_args,
const android::os::dumpstate::CommandOptions& options = DEFAULT_DUMPSYS,
- long dumpsys_timeout = 0);
+ long dumpsys_timeout_ms = 0);
/*
* Prints the contents of a file.
diff --git a/cmds/dumpstate/tests/dumpstate_test.cpp b/cmds/dumpstate/tests/dumpstate_test.cpp
index 92b0c0d..a2e9453 100644
--- a/cmds/dumpstate/tests/dumpstate_test.cpp
+++ b/cmds/dumpstate/tests/dumpstate_test.cpp
@@ -1001,7 +1001,7 @@
err, StartsWith("stderr\n*** command '" + kSimpleCommand + " --crash' failed: exit code"));
}
-TEST_F(DumpstateUtilTest, RunCommandTimesout) {
+TEST_F(DumpstateUtilTest, RunCommandTimesoutWithSec) {
CreateFd("RunCommandTimesout.txt");
EXPECT_EQ(-1, RunCommand("", {kSimpleCommand, "--sleep", "2"},
CommandOptions::WithTimeout(1).Build()));
@@ -1011,6 +1011,17 @@
" --sleep 2' timed out after 1"));
}
+TEST_F(DumpstateUtilTest, RunCommandTimesoutWithMsec) {
+ CreateFd("RunCommandTimesout.txt");
+ EXPECT_EQ(-1, RunCommand("", {kSimpleCommand, "--sleep", "2"},
+ CommandOptions::WithTimeoutInMs(1000).Build()));
+ EXPECT_THAT(out, StartsWith("stdout line1\n*** command '" + kSimpleCommand +
+ " --sleep 2' timed out after 1"));
+ EXPECT_THAT(err, StartsWith("sleeping for 2s\n*** command '" + kSimpleCommand +
+ " --sleep 2' timed out after 1"));
+}
+
+
TEST_F(DumpstateUtilTest, RunCommandIsKilled) {
CreateFd("RunCommandIsKilled.txt");
CaptureStderr();
diff --git a/cmds/dumpstate/utils.cpp b/cmds/dumpstate/utils.cpp
index 6ff0dae..ac48041 100644
--- a/cmds/dumpstate/utils.cpp
+++ b/cmds/dumpstate/utils.cpp
@@ -215,10 +215,10 @@
return progress_;
}
-bool Progress::Inc(int32_t delta) {
+bool Progress::Inc(int32_t delta_sec) {
bool changed = false;
- if (delta >= 0) {
- progress_ += delta;
+ if (delta_sec >= 0) {
+ progress_ += delta_sec;
if (progress_ > max_) {
int32_t old_max = max_;
max_ = floor((float)progress_ * growth_factor_);
@@ -723,9 +723,9 @@
}
void Dumpstate::RunDumpsys(const std::string& title, const std::vector<std::string>& dumpsys_args,
- const CommandOptions& options, long dumpsysTimeout) {
- long timeout = dumpsysTimeout > 0 ? dumpsysTimeout : options.Timeout();
- std::vector<std::string> dumpsys = {"/system/bin/dumpsys", "-t", std::to_string(timeout)};
+ const CommandOptions& options, long dumpsysTimeoutMs) {
+ long timeout_ms = dumpsysTimeoutMs > 0 ? dumpsysTimeoutMs : options.TimeoutInMs();
+ std::vector<std::string> dumpsys = {"/system/bin/dumpsys", "-T", std::to_string(timeout_ms)};
dumpsys.insert(dumpsys.end(), dumpsys_args.begin(), dumpsys_args.end());
RunCommand(title, dumpsys, options);
}
@@ -1165,14 +1165,14 @@
}
// TODO: make this function thread safe if sections are generated in parallel.
-void Dumpstate::UpdateProgress(int32_t delta) {
+void Dumpstate::UpdateProgress(int32_t delta_sec) {
if (progress_ == nullptr) {
MYLOGE("UpdateProgress: progress_ not set\n");
return;
}
// Always update progess so stats can be tuned...
- bool max_changed = progress_->Inc(delta);
+ bool max_changed = progress_->Inc(delta_sec);
// ...but only notifiy listeners when necessary.
if (!update_progress_) return;
diff --git a/cmds/dumpsys/dumpsys.cpp b/cmds/dumpsys/dumpsys.cpp
index c36ab08..0862a40 100644
--- a/cmds/dumpsys/dumpsys.cpp
+++ b/cmds/dumpsys/dumpsys.cpp
@@ -61,7 +61,8 @@
"SERVICE [ARGS]]\n"
" --help: shows this help\n"
" -l: only list services, do not dump them\n"
- " -t TIMEOUT: TIMEOUT to use in seconds instead of default 10 seconds\n"
+ " -t TIMEOUT_SEC: TIMEOUT to use in seconds instead of default 10 seconds\n"
+ " -T TIMEOUT_MS: TIMEOUT to use in milliseconds instead of default 10 seconds\n"
" --proto: filter services that support dumping data in proto format. Dumps"
" will be in proto format.\n"
" --priority LEVEL: filter services based on specified priority\n"
@@ -104,7 +105,7 @@
bool showListOnly = false;
bool skipServices = false;
bool filterByProto = false;
- int timeoutArg = 10;
+ int timeoutArgMs = 10000;
int dumpPriorityFlags = IServiceManager::DUMP_FLAG_PRIORITY_ALL;
static struct option longOptions[] = {{"priority", required_argument, 0, 0},
{"proto", no_argument, 0, 0},
@@ -119,7 +120,7 @@
int c;
int optionIndex = 0;
- c = getopt_long(argc, argv, "+t:l", longOptions, &optionIndex);
+ c = getopt_long(argc, argv, "+t:T:l", longOptions, &optionIndex);
if (c == -1) {
break;
@@ -146,10 +147,22 @@
case 't':
{
- char *endptr;
- timeoutArg = strtol(optarg, &endptr, 10);
- if (*endptr != '\0' || timeoutArg <= 0) {
- fprintf(stderr, "Error: invalid timeout number: '%s'\n", optarg);
+ char* endptr;
+ timeoutArgMs = strtol(optarg, &endptr, 10);
+ timeoutArgMs = timeoutArgMs * 1000;
+ if (*endptr != '\0' || timeoutArgMs <= 0) {
+ fprintf(stderr, "Error: invalid timeout(seconds) number: '%s'\n", optarg);
+ return -1;
+ }
+ }
+ break;
+
+ case 'T':
+ {
+ char* endptr;
+ timeoutArgMs = strtol(optarg, &endptr, 10);
+ if (*endptr != '\0' || timeoutArgMs <= 0) {
+ fprintf(stderr, "Error: invalid timeout(milliseconds) number: '%s'\n", optarg);
return -1;
}
}
@@ -269,7 +282,7 @@
}
});
- auto timeout = std::chrono::seconds(timeoutArg);
+ auto timeout = std::chrono::milliseconds(timeoutArgMs);
auto start = std::chrono::steady_clock::now();
auto end = start + timeout;
@@ -321,8 +334,8 @@
if (timed_out) {
aout << endl
- << "*** SERVICE '" << service_name << "' DUMP TIMEOUT (" << timeoutArg
- << "s) EXPIRED ***" << endl
+ << "*** SERVICE '" << service_name << "' DUMP TIMEOUT (" << timeoutArgMs
+ << "ms) EXPIRED ***" << endl
<< endl;
}
diff --git a/cmds/dumpsys/tests/dumpsys_test.cpp b/cmds/dumpsys/tests/dumpsys_test.cpp
index 18a4da9..bdb0a9a 100644
--- a/cmds/dumpsys/tests/dumpsys_test.cpp
+++ b/cmds/dumpsys/tests/dumpsys_test.cpp
@@ -299,12 +299,25 @@
}
// Tests 'dumpsys -t 1 service_name' on a service that times out after 2s
-TEST_F(DumpsysTest, DumpRunningServiceTimeout) {
+TEST_F(DumpsysTest, DumpRunningServiceTimeoutInSec) {
sp<BinderMock> binder_mock = ExpectDumpAndHang("Valet", 2, "Here's your car");
CallMain({"-t", "1", "Valet"});
- AssertOutputContains("SERVICE 'Valet' DUMP TIMEOUT (1s) EXPIRED");
+ AssertOutputContains("SERVICE 'Valet' DUMP TIMEOUT (1000ms) EXPIRED");
+ AssertNotDumped("Here's your car");
+
+ // TODO(b/65056227): BinderMock is not destructed because thread is detached on dumpsys.cpp
+ Mock::AllowLeak(binder_mock.get());
+}
+
+// Tests 'dumpsys -T 500 service_name' on a service that times out after 2s
+TEST_F(DumpsysTest, DumpRunningServiceTimeoutInMs) {
+ sp<BinderMock> binder_mock = ExpectDumpAndHang("Valet", 2, "Here's your car");
+
+ CallMain({"-T", "500", "Valet"});
+
+ AssertOutputContains("SERVICE 'Valet' DUMP TIMEOUT (500ms) EXPIRED");
AssertNotDumped("Here's your car");
// TODO(b/65056227): BinderMock is not destructed because thread is detached on dumpsys.cpp
diff --git a/libs/vr/libvrflinger/display_service.cpp b/libs/vr/libvrflinger/display_service.cpp
index ac68a5e..a18ff1a 100644
--- a/libs/vr/libvrflinger/display_service.cpp
+++ b/libs/vr/libvrflinger/display_service.cpp
@@ -38,10 +38,12 @@
namespace dvr {
DisplayService::DisplayService(Hwc2::Composer* hidl,
+ hwc2_display_t primary_display_id,
RequestDisplayCallback request_display_callback)
: BASE("DisplayService",
Endpoint::Create(display::DisplayProtocol::kClientPath)) {
- hardware_composer_.Initialize(hidl, request_display_callback);
+ hardware_composer_.Initialize(
+ hidl, primary_display_id, request_display_callback);
}
bool DisplayService::IsInitialized() const {
diff --git a/libs/vr/libvrflinger/display_service.h b/libs/vr/libvrflinger/display_service.h
index 55e33ab..a3ee7bb 100644
--- a/libs/vr/libvrflinger/display_service.h
+++ b/libs/vr/libvrflinger/display_service.h
@@ -81,6 +81,7 @@
using RequestDisplayCallback = std::function<void(bool)>;
DisplayService(android::Hwc2::Composer* hidl,
+ hwc2_display_t primary_display_id,
RequestDisplayCallback request_display_callback);
pdx::Status<BorrowedNativeBufferHandle> OnGetGlobalBuffer(
diff --git a/libs/vr/libvrflinger/hardware_composer.cpp b/libs/vr/libvrflinger/hardware_composer.cpp
index 44be0ab..be17ecf 100644
--- a/libs/vr/libvrflinger/hardware_composer.cpp
+++ b/libs/vr/libvrflinger/hardware_composer.cpp
@@ -121,7 +121,8 @@
}
bool HardwareComposer::Initialize(
- Hwc2::Composer* composer, RequestDisplayCallback request_display_callback) {
+ Hwc2::Composer* composer, hwc2_display_t primary_display_id,
+ RequestDisplayCallback request_display_callback) {
if (initialized_) {
ALOGE("HardwareComposer::Initialize: already initialized.");
return false;
@@ -134,7 +135,7 @@
HWC::Error error = HWC::Error::None;
Hwc2::Config config;
- error = composer->getActiveConfig(HWC_DISPLAY_PRIMARY, &config);
+ error = composer->getActiveConfig(primary_display_id, &config);
if (error != HWC::Error::None) {
ALOGE("HardwareComposer: Failed to get current display config : %d",
@@ -142,7 +143,7 @@
return false;
}
- error = GetDisplayMetrics(composer, HWC_DISPLAY_PRIMARY, config,
+ error = GetDisplayMetrics(composer, primary_display_id, config,
&native_display_metrics_);
if (error != HWC::Error::None) {
@@ -233,7 +234,10 @@
composer_.reset(new Hwc2::Composer("default"));
composer_callback_ = new ComposerCallback;
composer_->registerCallback(composer_callback_);
+ LOG_ALWAYS_FATAL_IF(!composer_callback_->HasDisplayId(),
+ "Registered composer callback but didn't get primary display");
Layer::SetComposer(composer_.get());
+ Layer::SetDisplayId(composer_callback_->GetDisplayId());
} else {
SetPowerMode(true);
}
@@ -263,6 +267,7 @@
composer_callback_ = nullptr;
composer_.reset(nullptr);
Layer::SetComposer(nullptr);
+ Layer::SetDisplayId(0);
} else {
SetPowerMode(false);
}
@@ -290,7 +295,7 @@
HWC::Error HardwareComposer::EnableVsync(bool enabled) {
return composer_->setVsyncEnabled(
- HWC_DISPLAY_PRIMARY,
+ composer_callback_->GetDisplayId(),
(Hwc2::IComposerClient::Vsync)(enabled ? HWC2_VSYNC_ENABLE
: HWC2_VSYNC_DISABLE));
}
@@ -298,7 +303,8 @@
HWC::Error HardwareComposer::SetPowerMode(bool active) {
HWC::PowerMode power_mode = active ? HWC::PowerMode::On : HWC::PowerMode::Off;
return composer_->setPowerMode(
- HWC_DISPLAY_PRIMARY, power_mode.cast<Hwc2::IComposerClient::PowerMode>());
+ composer_callback_->GetDisplayId(),
+ power_mode.cast<Hwc2::IComposerClient::PowerMode>());
}
HWC::Error HardwareComposer::Present(hwc2_display_t display) {
@@ -419,7 +425,7 @@
layer.Prepare();
}
- HWC::Error error = Validate(HWC_DISPLAY_PRIMARY);
+ HWC::Error error = Validate(composer_callback_->GetDisplayId());
if (error != HWC::Error::None) {
ALOGE("HardwareComposer::PostLayers: Validate failed: %s",
error.to_string().c_str());
@@ -466,7 +472,7 @@
}
#endif
- error = Present(HWC_DISPLAY_PRIMARY);
+ error = Present(composer_callback_->GetDisplayId());
if (error != HWC::Error::None) {
ALOGE("HardwareComposer::PostLayers: Present failed: %s",
error.to_string().c_str());
@@ -475,8 +481,8 @@
std::vector<Hwc2::Layer> out_layers;
std::vector<int> out_fences;
- error = composer_->getReleaseFences(HWC_DISPLAY_PRIMARY, &out_layers,
- &out_fences);
+ error = composer_->getReleaseFences(composer_callback_->GetDisplayId(),
+ &out_layers, &out_fences);
ALOGE_IF(error != HWC::Error::None,
"HardwareComposer::PostLayers: Failed to get release fences: %s",
error.to_string().c_str());
@@ -615,14 +621,6 @@
}
}
-Status<int64_t> HardwareComposer::GetVSyncTime() {
- auto status = composer_callback_->GetVsyncTime(HWC_DISPLAY_PRIMARY);
- ALOGE_IF(!status,
- "HardwareComposer::GetVSyncTime: Failed to get vsync timestamp: %s",
- status.GetErrorMessage().c_str());
- return status;
-}
-
// Waits for the next vsync and returns the timestamp of the vsync event. If
// vsync already passed since the last call, returns the latest vsync timestamp
// instead of blocking.
@@ -795,8 +793,7 @@
// Signal all of the vsync clients. Because absolute time is used for the
// wakeup time below, this can take a little time if necessary.
if (vsync_callback_)
- vsync_callback_(HWC_DISPLAY_PRIMARY, vsync_timestamp,
- /*frame_time_estimate*/ 0, vsync_count_);
+ vsync_callback_(vsync_timestamp, /*frame_time_estimate*/ 0, vsync_count_);
{
// Sleep until shortly before vsync.
@@ -819,7 +816,7 @@
// If the layer config changed we need to validateDisplay() even if
// we're going to drop the frame, to flush the Composer object's
// internal command buffer and apply our layer changes.
- Validate(HWC_DISPLAY_PRIMARY);
+ Validate(composer_callback_->GetDisplayId());
}
continue;
}
@@ -827,7 +824,7 @@
}
{
- auto status = GetVSyncTime();
+ auto status = composer_callback_->GetVsyncTime();
if (!status) {
ALOGE("HardwareComposer::PostThread: Failed to get VSYNC time: %s",
status.GetErrorMessage().c_str());
@@ -946,10 +943,17 @@
}
Return<void> HardwareComposer::ComposerCallback::onHotplug(
- Hwc2::Display display, IComposerCallback::Connection /*conn*/) {
- // See if the driver supports the vsync_event node in sysfs.
- if (display < HWC_NUM_PHYSICAL_DISPLAY_TYPES &&
- !displays_[display].driver_vsync_event_fd) {
+ Hwc2::Display display, IComposerCallback::Connection conn) {
+ // Our first onHotplug callback is always for the primary display.
+ //
+ // Ignore any other hotplug callbacks since the primary display is never
+ // disconnected and we don't care about other displays.
+ if (!has_display_id_) {
+ LOG_ALWAYS_FATAL_IF(conn != IComposerCallback::Connection::CONNECTED,
+ "Initial onHotplug callback should be primary display connected");
+ has_display_id_ = true;
+ display_id_ = display;
+
std::array<char, 1024> buffer;
snprintf(buffer.data(), buffer.size(),
"/sys/class/graphics/fb%" PRIu64 "/vsync_event", display);
@@ -958,7 +962,7 @@
"HardwareComposer::ComposerCallback::onHotplug: Driver supports "
"vsync_event node for display %" PRIu64,
display);
- displays_[display].driver_vsync_event_fd = std::move(handle);
+ driver_vsync_event_fd_ = std::move(handle);
} else {
ALOGI(
"HardwareComposer::ComposerCallback::onHotplug: Driver does not "
@@ -977,36 +981,23 @@
Return<void> HardwareComposer::ComposerCallback::onVsync(Hwc2::Display display,
int64_t timestamp) {
- TRACE_FORMAT("vsync_callback|display=%" PRIu64 ";timestamp=%" PRId64 "|",
- display, timestamp);
- if (display < HWC_NUM_PHYSICAL_DISPLAY_TYPES) {
- displays_[display].callback_vsync_timestamp = timestamp;
- } else {
- ALOGW(
- "HardwareComposer::ComposerCallback::onVsync: Received vsync on "
- "non-physical display: display=%" PRId64,
- display);
+ // Ignore any onVsync callbacks for the non-primary display.
+ if (has_display_id_ && display == display_id_) {
+ TRACE_FORMAT("vsync_callback|display=%" PRIu64 ";timestamp=%" PRId64 "|",
+ display, timestamp);
+ callback_vsync_timestamp_ = timestamp;
}
return Void();
}
-Status<int64_t> HardwareComposer::ComposerCallback::GetVsyncTime(
- Hwc2::Display display) {
- if (display >= HWC_NUM_PHYSICAL_DISPLAY_TYPES) {
- ALOGE(
- "HardwareComposer::ComposerCallback::GetVsyncTime: Invalid physical "
- "display requested: display=%" PRIu64,
- display);
- return ErrorStatus(EINVAL);
- }
-
+Status<int64_t> HardwareComposer::ComposerCallback::GetVsyncTime() {
// See if the driver supports direct vsync events.
- LocalHandle& event_fd = displays_[display].driver_vsync_event_fd;
+ LocalHandle& event_fd = driver_vsync_event_fd_;
if (!event_fd) {
// Fall back to returning the last timestamp returned by the vsync
// callback.
std::lock_guard<std::mutex> autolock(vsync_mutex_);
- return displays_[display].callback_vsync_timestamp;
+ return callback_vsync_timestamp_;
}
// When the driver supports the vsync_event sysfs node we can use it to
@@ -1056,10 +1047,11 @@
Hwc2::Composer* Layer::composer_{nullptr};
HWCDisplayMetrics Layer::display_metrics_{0, 0, {0, 0}, 0};
+hwc2_display_t Layer::display_id_{0};
void Layer::Reset() {
if (hardware_composer_layer_) {
- composer_->destroyLayer(HWC_DISPLAY_PRIMARY, hardware_composer_layer_);
+ composer_->destroyLayer(display_id_, hardware_composer_layer_);
hardware_composer_layer_ = 0;
}
@@ -1154,17 +1146,16 @@
pending_visibility_settings_ = false;
HWC::Error error;
- hwc2_display_t display = HWC_DISPLAY_PRIMARY;
error = composer_->setLayerBlendMode(
- display, hardware_composer_layer_,
+ display_id_, hardware_composer_layer_,
blending_.cast<Hwc2::IComposerClient::BlendMode>());
ALOGE_IF(error != HWC::Error::None,
"Layer::UpdateLayerSettings: Error setting layer blend mode: %s",
error.to_string().c_str());
- error =
- composer_->setLayerZOrder(display, hardware_composer_layer_, z_order_);
+ error = composer_->setLayerZOrder(display_id_, hardware_composer_layer_,
+ z_order_);
ALOGE_IF(error != HWC::Error::None,
"Layer::UpdateLayerSettings: Error setting z_ order: %s",
error.to_string().c_str());
@@ -1173,36 +1164,35 @@
void Layer::UpdateLayerSettings() {
HWC::Error error;
- hwc2_display_t display = HWC_DISPLAY_PRIMARY;
UpdateVisibilitySettings();
// TODO(eieio): Use surface attributes or some other mechanism to control
// the layer display frame.
error = composer_->setLayerDisplayFrame(
- display, hardware_composer_layer_,
+ display_id_, hardware_composer_layer_,
{0, 0, display_metrics_.width, display_metrics_.height});
ALOGE_IF(error != HWC::Error::None,
"Layer::UpdateLayerSettings: Error setting layer display frame: %s",
error.to_string().c_str());
error = composer_->setLayerVisibleRegion(
- display, hardware_composer_layer_,
+ display_id_, hardware_composer_layer_,
{{0, 0, display_metrics_.width, display_metrics_.height}});
ALOGE_IF(error != HWC::Error::None,
"Layer::UpdateLayerSettings: Error setting layer visible region: %s",
error.to_string().c_str());
- error =
- composer_->setLayerPlaneAlpha(display, hardware_composer_layer_, 1.0f);
+ error = composer_->setLayerPlaneAlpha(display_id_, hardware_composer_layer_,
+ 1.0f);
ALOGE_IF(error != HWC::Error::None,
"Layer::UpdateLayerSettings: Error setting layer plane alpha: %s",
error.to_string().c_str());
}
void Layer::CommonLayerSetup() {
- HWC::Error error =
- composer_->createLayer(HWC_DISPLAY_PRIMARY, &hardware_composer_layer_);
+ HWC::Error error = composer_->createLayer(display_id_,
+ &hardware_composer_layer_);
ALOGE_IF(error != HWC::Error::None,
"Layer::CommonLayerSetup: Failed to create layer on primary "
"display: %s",
@@ -1246,10 +1236,10 @@
if (composition_type_ == HWC::Composition::Invalid) {
composition_type_ = HWC::Composition::SolidColor;
composer_->setLayerCompositionType(
- HWC_DISPLAY_PRIMARY, hardware_composer_layer_,
+ display_id_, hardware_composer_layer_,
composition_type_.cast<Hwc2::IComposerClient::Composition>());
Hwc2::IComposerClient::Color layer_color = {0, 0, 0, 0};
- composer_->setLayerColor(HWC_DISPLAY_PRIMARY, hardware_composer_layer_,
+ composer_->setLayerColor(display_id_, hardware_composer_layer_,
layer_color);
} else {
// The composition type is already set. Nothing else to do until a
@@ -1259,7 +1249,7 @@
if (composition_type_ != target_composition_type_) {
composition_type_ = target_composition_type_;
composer_->setLayerCompositionType(
- HWC_DISPLAY_PRIMARY, hardware_composer_layer_,
+ display_id_, hardware_composer_layer_,
composition_type_.cast<Hwc2::IComposerClient::Composition>());
}
@@ -1270,7 +1260,7 @@
HWC::Error error{HWC::Error::None};
error =
- composer_->setLayerBuffer(HWC_DISPLAY_PRIMARY, hardware_composer_layer_,
+ composer_->setLayerBuffer(display_id_, hardware_composer_layer_,
slot, handle, acquire_fence_.Get());
ALOGE_IF(error != HWC::Error::None,
@@ -1280,7 +1270,7 @@
if (!surface_rect_functions_applied_) {
const float float_right = right;
const float float_bottom = bottom;
- error = composer_->setLayerSourceCrop(HWC_DISPLAY_PRIMARY,
+ error = composer_->setLayerSourceCrop(display_id_,
hardware_composer_layer_,
{0, 0, float_right, float_bottom});
diff --git a/libs/vr/libvrflinger/hardware_composer.h b/libs/vr/libvrflinger/hardware_composer.h
index 7010db9..9ed4b22 100644
--- a/libs/vr/libvrflinger/hardware_composer.h
+++ b/libs/vr/libvrflinger/hardware_composer.h
@@ -152,6 +152,11 @@
display_metrics_ = display_metrics;
}
+ // Sets the display id used by all Layer instances.
+ static void SetDisplayId(hwc2_display_t display_id) {
+ display_id_ = display_id;
+ }
+
private:
void CommonLayerSetup();
@@ -180,6 +185,11 @@
// thereafter.
static HWCDisplayMetrics display_metrics_;
+ // Id of the primary display. Shared by all instances of Layer. This must be
+ // set whenever the primary display id changes. This can be left unset as long
+ // as there are no instances of Layer that might need to use it.
+ static hwc2_display_t display_id_;
+
// The hardware composer layer and metrics to use during the prepare cycle.
hwc2_layer_t hardware_composer_layer_ = 0;
@@ -298,13 +308,14 @@
class HardwareComposer {
public:
// Type for vsync callback.
- using VSyncCallback = std::function<void(int, int64_t, int64_t, uint32_t)>;
+ using VSyncCallback = std::function<void(int64_t, int64_t, uint32_t)>;
using RequestDisplayCallback = std::function<void(bool)>;
HardwareComposer();
~HardwareComposer();
bool Initialize(Hwc2::Composer* composer,
+ hwc2_display_t primary_display_id,
RequestDisplayCallback request_display_callback);
bool IsInitialized() const { return initialized_; }
@@ -362,16 +373,16 @@
hardware::Return<void> onVsync(Hwc2::Display display,
int64_t timestamp) override;
- pdx::Status<int64_t> GetVsyncTime(Hwc2::Display display);
+ bool HasDisplayId() { return has_display_id_; }
+ hwc2_display_t GetDisplayId() { return display_id_; }
+ pdx::Status<int64_t> GetVsyncTime();
private:
std::mutex vsync_mutex_;
-
- struct Display {
- pdx::LocalHandle driver_vsync_event_fd;
- int64_t callback_vsync_timestamp{0};
- };
- std::array<Display, HWC_NUM_PHYSICAL_DISPLAY_TYPES> displays_;
+ bool has_display_id_ = false;
+ hwc2_display_t display_id_;
+ pdx::LocalHandle driver_vsync_event_fd_;
+ int64_t callback_vsync_timestamp_{0};
};
HWC::Error Validate(hwc2_display_t display);
@@ -412,7 +423,6 @@
// kPostThreadInterrupted.
int ReadWaitPPState();
pdx::Status<int64_t> WaitForVSync();
- pdx::Status<int64_t> GetVSyncTime();
int SleepUntil(int64_t wakeup_timestamp);
// Reconfigures the layer stack if the display surfaces changed since the last
diff --git a/libs/vr/libvrflinger/include/dvr/vr_flinger.h b/libs/vr/libvrflinger/include/dvr/vr_flinger.h
index 33cbc84..c740dde 100644
--- a/libs/vr/libvrflinger/include/dvr/vr_flinger.h
+++ b/libs/vr/libvrflinger/include/dvr/vr_flinger.h
@@ -4,6 +4,12 @@
#include <thread>
#include <memory>
+#define HWC2_INCLUDE_STRINGIFICATION
+#define HWC2_USE_CPP11
+#include <hardware/hwcomposer2.h>
+#undef HWC2_INCLUDE_STRINGIFICATION
+#undef HWC2_USE_CPP11
+
#include <pdx/service_dispatcher.h>
#include <vr/vr_manager/vr_manager.h>
@@ -21,7 +27,9 @@
public:
using RequestDisplayCallback = std::function<void(bool)>;
static std::unique_ptr<VrFlinger> Create(
- Hwc2::Composer* hidl, RequestDisplayCallback request_display_callback);
+ Hwc2::Composer* hidl,
+ hwc2_display_t primary_display_id,
+ RequestDisplayCallback request_display_callback);
~VrFlinger();
// These functions are all called on surface flinger's main thread.
@@ -35,6 +43,7 @@
private:
VrFlinger();
bool Init(Hwc2::Composer* hidl,
+ hwc2_display_t primary_display_id,
RequestDisplayCallback request_display_callback);
// Needs to be a separate class for binder's ref counting
diff --git a/libs/vr/libvrflinger/vr_flinger.cpp b/libs/vr/libvrflinger/vr_flinger.cpp
index 85dc586..5e7abd7 100644
--- a/libs/vr/libvrflinger/vr_flinger.cpp
+++ b/libs/vr/libvrflinger/vr_flinger.cpp
@@ -29,9 +29,10 @@
namespace dvr {
std::unique_ptr<VrFlinger> VrFlinger::Create(
- Hwc2::Composer* hidl, RequestDisplayCallback request_display_callback) {
+ Hwc2::Composer* hidl, hwc2_display_t primary_display_id,
+ RequestDisplayCallback request_display_callback) {
std::unique_ptr<VrFlinger> vr_flinger(new VrFlinger);
- if (vr_flinger->Init(hidl, request_display_callback))
+ if (vr_flinger->Init(hidl, primary_display_id, request_display_callback))
return vr_flinger;
else
return nullptr;
@@ -56,6 +57,7 @@
}
bool VrFlinger::Init(Hwc2::Composer* hidl,
+ hwc2_display_t primary_display_id,
RequestDisplayCallback request_display_callback) {
if (!hidl || !request_display_callback)
return false;
@@ -74,8 +76,8 @@
dispatcher_ = android::pdx::ServiceDispatcher::Create();
CHECK_ERROR(!dispatcher_, error, "Failed to create service dispatcher.");
- display_service_ =
- android::dvr::DisplayService::Create(hidl, request_display_callback);
+ display_service_ = android::dvr::DisplayService::Create(
+ hidl, primary_display_id, request_display_callback);
CHECK_ERROR(!display_service_, error, "Failed to create display service.");
dispatcher_->AddService(display_service_);
@@ -91,7 +93,7 @@
std::bind(&android::dvr::VSyncService::VSyncEvent,
std::static_pointer_cast<android::dvr::VSyncService>(service),
std::placeholders::_1, std::placeholders::_2,
- std::placeholders::_3, std::placeholders::_4));
+ std::placeholders::_3));
dispatcher_thread_ = std::thread([this]() {
prctl(PR_SET_NAME, reinterpret_cast<unsigned long>("VrDispatch"), 0, 0, 0);
diff --git a/libs/vr/libvrflinger/vsync_service.cpp b/libs/vr/libvrflinger/vsync_service.cpp
index fdeb899..b8d8b08 100644
--- a/libs/vr/libvrflinger/vsync_service.cpp
+++ b/libs/vr/libvrflinger/vsync_service.cpp
@@ -32,21 +32,19 @@
VSyncService::~VSyncService() {}
-void VSyncService::VSyncEvent(int display, int64_t timestamp_ns,
+void VSyncService::VSyncEvent(int64_t timestamp_ns,
int64_t compositor_time_ns,
uint32_t vsync_count) {
ATRACE_NAME("VSyncService::VSyncEvent");
std::lock_guard<std::mutex> autolock(mutex_);
- if (display == HWC_DISPLAY_PRIMARY) {
- last_vsync_ = current_vsync_;
- current_vsync_ = timestamp_ns;
- compositor_time_ns_ = compositor_time_ns;
- current_vsync_count_ = vsync_count;
+ last_vsync_ = current_vsync_;
+ current_vsync_ = timestamp_ns;
+ compositor_time_ns_ = compositor_time_ns;
+ current_vsync_count_ = vsync_count;
- NotifyWaiters();
- UpdateClients();
- }
+ NotifyWaiters();
+ UpdateClients();
}
std::shared_ptr<Channel> VSyncService::OnChannelOpen(pdx::Message& message) {
diff --git a/libs/vr/libvrflinger/vsync_service.h b/libs/vr/libvrflinger/vsync_service.h
index 215948e..822f02b 100644
--- a/libs/vr/libvrflinger/vsync_service.h
+++ b/libs/vr/libvrflinger/vsync_service.h
@@ -63,9 +63,10 @@
const std::shared_ptr<pdx::Channel>& channel) override;
// Called by the hardware composer HAL, or similar, whenever a vsync event
- // occurs. |compositor_time_ns| is the number of ns before the next vsync when
- // the compositor will preempt the GPU to do EDS and lens warp.
- void VSyncEvent(int display, int64_t timestamp_ns, int64_t compositor_time_ns,
+ // occurs on the primary display. |compositor_time_ns| is the number of ns
+ // before the next vsync when the compositor will preempt the GPU to do EDS
+ // and lens warp.
+ void VSyncEvent(int64_t timestamp_ns, int64_t compositor_time_ns,
uint32_t vsync_count);
private:
diff --git a/opengl/libs/EGL/Loader.cpp b/opengl/libs/EGL/Loader.cpp
index 399affc..9822849 100644
--- a/opengl/libs/EGL/Loader.cpp
+++ b/opengl/libs/EGL/Loader.cpp
@@ -340,6 +340,14 @@
result = std::string("/vendor/lib/egl/lib") + kind + "_emulation.so";
#endif
return result;
+ case 2:
+ // Use guest side swiftshader library
+#if defined(__LP64__)
+ result = std::string("/vendor/lib64/egl/lib") + kind + "_swiftshader.so";
+#else
+ result = std::string("/vendor/lib/egl/lib") + kind + "_swiftshader.so";
+#endif
+ return result;
default:
// Not in emulator, or use other guest-side implementation
break;
diff --git a/services/surfaceflinger/Android.mk b/services/surfaceflinger/Android.mk
index 2a78aa5..ecee8ce 100644
--- a/services/surfaceflinger/Android.mk
+++ b/services/surfaceflinger/Android.mk
@@ -150,7 +150,7 @@
LOCAL_32_BIT_ONLY := true
endif
-LOCAL_CFLAGS += -Wall -Werror -Wunused -Wunreachable-code
+LOCAL_CFLAGS += -Wall -Werror -Wunused -Wunreachable-code -std=c++1z
include $(BUILD_EXECUTABLE)
diff --git a/services/surfaceflinger/BufferLayer.cpp b/services/surfaceflinger/BufferLayer.cpp
index 4e214d1..2fa17e9 100644
--- a/services/surfaceflinger/BufferLayer.cpp
+++ b/services/surfaceflinger/BufferLayer.cpp
@@ -88,7 +88,7 @@
}
mFlinger->deleteTextureAsync(mTextureName);
- if (!mHwcLayers.empty()) {
+ if (!getBE().mHwcLayers.empty()) {
ALOGE("Found stale hardware composer layers when destroying "
"surface flinger layer %s",
mName.string());
@@ -115,7 +115,7 @@
bool BufferLayer::isVisible() const {
return !(isHiddenByPolicy()) && getAlpha() > 0.0f &&
- (mActiveBuffer != NULL || mSidebandStream != NULL);
+ (mActiveBuffer != NULL || getBE().mSidebandStream != NULL);
}
bool BufferLayer::isFixedSize() const {
@@ -249,7 +249,8 @@
}
// Set things up for texturing.
- mTexture.setDimensions(mActiveBuffer->getWidth(), mActiveBuffer->getHeight());
+ mTexture.setDimensions(mActiveBuffer->getWidth(),
+ mActiveBuffer->getHeight());
mTexture.setFiltering(useFiltering);
mTexture.setMatrix(textureMatrix);
@@ -299,10 +300,12 @@
bool BufferLayer::onPreComposition(nsecs_t refreshStartTime) {
if (mBufferLatched) {
Mutex::Autolock lock(mFrameEventHistoryMutex);
- mFrameEventHistory.addPreComposition(mCurrentFrameNumber, refreshStartTime);
+ mFrameEventHistory.addPreComposition(mCurrentFrameNumber,
+ refreshStartTime);
}
mRefreshPending = false;
- return mQueuedFrames > 0 || mSidebandStreamChanged || mAutoRefresh;
+ return mQueuedFrames > 0 || mSidebandStreamChanged ||
+ mAutoRefresh;
}
bool BufferLayer::onPostComposition(const std::shared_ptr<FenceTime>& glDoneFence,
const std::shared_ptr<FenceTime>& presentFence,
@@ -314,8 +317,8 @@
// Update mFrameEventHistory.
{
Mutex::Autolock lock(mFrameEventHistoryMutex);
- mFrameEventHistory.addPostComposition(mCurrentFrameNumber, glDoneFence, presentFence,
- compositorTiming);
+ mFrameEventHistory.addPostComposition(mCurrentFrameNumber, glDoneFence,
+ presentFence, compositorTiming);
}
// Update mFrameTracker.
@@ -382,7 +385,9 @@
if (android_atomic_acquire_cas(true, false, &mSidebandStreamChanged) == 0) {
// mSidebandStreamChanged was true
mSidebandStream = mSurfaceFlingerConsumer->getSidebandStream();
- if (mSidebandStream != NULL) {
+ // replicated in LayerBE until FE/BE is ready to be synchronized
+ getBE().mSidebandStream = mSidebandStream;
+ if (getBE().mSidebandStream != NULL) {
setTransactionFlags(eTransactionNeeded);
mFlinger->setTransactionFlags(eTraversalNeeded);
}
@@ -429,11 +434,12 @@
// buffer mode.
bool queuedBuffer = false;
LayerRejecter r(mDrawingState, getCurrentState(), recomputeVisibleRegions,
- getProducerStickyTransform() != 0, mName.string(), mOverrideScalingMode,
- mFreezeGeometryUpdates);
+ getProducerStickyTransform() != 0, mName.string(),
+ mOverrideScalingMode, mFreezeGeometryUpdates);
status_t updateResult =
- mSurfaceFlingerConsumer->updateTexImage(&r, mFlinger->mPrimaryDispSync, &mAutoRefresh,
- &queuedBuffer, mLastFrameNumberReceived);
+ mSurfaceFlingerConsumer->updateTexImage(&r, mFlinger->mPrimaryDispSync,
+ &mAutoRefresh, &queuedBuffer,
+ mLastFrameNumberReceived);
if (updateResult == BufferQueue::PRESENT_LATER) {
// Producer doesn't want buffer to be displayed yet. Signal a
// layer update so we check again at the next opportunity.
@@ -486,12 +492,14 @@
// Decrement the queued-frames count. Signal another event if we
// have more frames pending.
- if ((queuedBuffer && android_atomic_dec(&mQueuedFrames) > 1) || mAutoRefresh) {
+ if ((queuedBuffer && android_atomic_dec(&mQueuedFrames) > 1) ||
+ mAutoRefresh) {
mFlinger->signalLayerUpdate();
}
// update the active buffer
- mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer(&mActiveBufferSlot);
+ mActiveBuffer =
+ mSurfaceFlingerConsumer->getCurrentBuffer(&mActiveBufferSlot);
if (mActiveBuffer == NULL) {
// this can only happen if the very first buffer was rejected.
return outDirtyRegion;
@@ -519,7 +527,8 @@
Rect crop(mSurfaceFlingerConsumer->getCurrentCrop());
const uint32_t transform(mSurfaceFlingerConsumer->getCurrentTransform());
const uint32_t scalingMode(mSurfaceFlingerConsumer->getCurrentScalingMode());
- if ((crop != mCurrentCrop) || (transform != mCurrentTransform) ||
+ if ((crop != mCurrentCrop) ||
+ (transform != mCurrentTransform) ||
(scalingMode != mCurrentScalingMode)) {
mCurrentCrop = crop;
mCurrentTransform = transform;
@@ -582,7 +591,7 @@
const auto& viewport = displayDevice->getViewport();
Region visible = tr.transform(visibleRegion.intersect(viewport));
auto hwcId = displayDevice->getHwcDisplayId();
- auto& hwcInfo = mHwcLayers[hwcId];
+ auto& hwcInfo = getBE().mHwcLayers[hwcId];
auto& hwcLayer = hwcInfo.layer;
auto error = hwcLayer->setVisibleRegion(visible);
if (error != HWC2::Error::None) {
@@ -599,13 +608,14 @@
}
// Sideband layers
- if (mSidebandStream.get()) {
+ if (getBE().mSidebandStream.get()) {
setCompositionType(hwcId, HWC2::Composition::Sideband);
ALOGV("[%s] Requesting Sideband composition", mName.string());
- error = hwcLayer->setSidebandStream(mSidebandStream->handle());
+ error = hwcLayer->setSidebandStream(getBE().mSidebandStream->handle());
if (error != HWC2::Error::None) {
ALOGE("[%s] Failed to set sideband stream %p: %s (%d)", mName.string(),
- mSidebandStream->handle(), to_string(error).c_str(), static_cast<int32_t>(error));
+ getBE().mSidebandStream->handle(), to_string(error).c_str(),
+ static_cast<int32_t>(error));
}
return;
}
@@ -628,20 +638,22 @@
uint32_t hwcSlot = 0;
sp<GraphicBuffer> hwcBuffer;
- hwcInfo.bufferCache.getHwcBuffer(mActiveBufferSlot, mActiveBuffer, &hwcSlot, &hwcBuffer);
+ hwcInfo.bufferCache.getHwcBuffer(mActiveBufferSlot,
+ mActiveBuffer, &hwcSlot, &hwcBuffer);
auto acquireFence = mSurfaceFlingerConsumer->getCurrentFence();
error = hwcLayer->setBuffer(hwcSlot, hwcBuffer, acquireFence);
if (error != HWC2::Error::None) {
- ALOGE("[%s] Failed to set buffer %p: %s (%d)", mName.string(), mActiveBuffer->handle,
- to_string(error).c_str(), static_cast<int32_t>(error));
+ ALOGE("[%s] Failed to set buffer %p: %s (%d)", mName.string(),
+ mActiveBuffer->handle, to_string(error).c_str(),
+ static_cast<int32_t>(error));
}
}
bool BufferLayer::isOpaque(const Layer::State& s) const {
// if we don't have a buffer or sidebandStream yet, we're translucent regardless of the
// layer's opaque flag.
- if ((mSidebandStream == nullptr) && (mActiveBuffer == nullptr)) {
+ if ((getBE().mSidebandStream == nullptr) && (mActiveBuffer == nullptr)) {
return false;
}
@@ -688,7 +700,8 @@
// Ensure that callbacks are handled in order
while (item.mFrameNumber != mLastFrameNumberReceived + 1) {
- status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, ms2ns(500));
+ status_t result = mQueueItemCondition.waitRelative(mQueueItemLock,
+ ms2ns(500));
if (result != NO_ERROR) {
ALOGE("[%s] Timed out waiting on callback", mName.string());
}
@@ -711,7 +724,8 @@
// Ensure that callbacks are handled in order
while (item.mFrameNumber != mLastFrameNumberReceived + 1) {
- status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, ms2ns(500));
+ status_t result = mQueueItemCondition.waitRelative(mQueueItemLock,
+ ms2ns(500));
if (result != NO_ERROR) {
ALOGE("[%s] Timed out waiting on callback", mName.string());
}
@@ -765,7 +779,7 @@
void BufferLayer::drawWithOpenGL(const RenderArea& renderArea, bool useIdentityTransform) const {
const State& s(getDrawingState());
- computeGeometry(renderArea, mMesh, useIdentityTransform);
+ computeGeometry(renderArea, getBE().mMesh, useIdentityTransform);
/*
* NOTE: the way we compute the texture coordinates here produces
@@ -802,7 +816,7 @@
// TODO: we probably want to generate the texture coords with the mesh
// here we assume that we only have 4 vertices
- Mesh::VertexArray<vec2> texCoords(mMesh.getTexCoordArray<vec2>());
+ Mesh::VertexArray<vec2> texCoords(getBE().mMesh.getTexCoordArray<vec2>());
texCoords[0] = vec2(left, 1.0f - top);
texCoords[1] = vec2(left, 1.0f - bottom);
texCoords[2] = vec2(right, 1.0f - bottom);
@@ -812,7 +826,7 @@
engine.setupLayerBlending(mPremultipliedAlpha, isOpaque(s), false /* disableTexture */,
getColor());
engine.setSourceDataSpace(mCurrentState.dataSpace);
- engine.drawMesh(mMesh);
+ engine.drawMesh(getBE().mMesh);
engine.disableBlending();
}
@@ -866,7 +880,8 @@
// able to be latched. To avoid this, grab this buffer anyway.
return true;
}
- return mQueueItems[0].mFenceTime->getSignalTime() != Fence::SIGNAL_TIME_PENDING;
+ return mQueueItems[0].mFenceTime->getSignalTime() !=
+ Fence::SIGNAL_TIME_PENDING;
}
uint32_t BufferLayer::getEffectiveScalingMode() const {
diff --git a/services/surfaceflinger/ColorLayer.cpp b/services/surfaceflinger/ColorLayer.cpp
index 292e1a7..b784c8d 100644
--- a/services/surfaceflinger/ColorLayer.cpp
+++ b/services/surfaceflinger/ColorLayer.cpp
@@ -66,7 +66,7 @@
const auto& viewport = displayDevice->getViewport();
Region visible = tr.transform(visibleRegion.intersect(viewport));
auto hwcId = displayDevice->getHwcDisplayId();
- auto& hwcInfo = mHwcLayers[hwcId];
+ auto& hwcInfo = getBE().mHwcLayers[hwcId];
auto& hwcLayer = hwcInfo.layer;
auto error = hwcLayer->setVisibleRegion(visible);
diff --git a/services/surfaceflinger/DisplayHardware/HWComposer.cpp b/services/surfaceflinger/DisplayHardware/HWComposer.cpp
index 5328a22..60b85c5 100644
--- a/services/surfaceflinger/DisplayHardware/HWComposer.cpp
+++ b/services/surfaceflinger/DisplayHardware/HWComposer.cpp
@@ -868,6 +868,14 @@
result.append(mHwcDevice->dump().c_str());
}
+std::optional<hwc2_display_t>
+HWComposer::getHwcDisplayId(int32_t displayId) const {
+ if (!isValidDisplay(displayId)) {
+ return {};
+ }
+ return mDisplayData[displayId].hwcDisplay->getId();
+}
+
// ---------------------------------------------------------------------------
HWComposer::DisplayData::DisplayData()
diff --git a/services/surfaceflinger/DisplayHardware/HWComposer.h b/services/surfaceflinger/DisplayHardware/HWComposer.h
index 3b6d931..74b3a38 100644
--- a/services/surfaceflinger/DisplayHardware/HWComposer.h
+++ b/services/surfaceflinger/DisplayHardware/HWComposer.h
@@ -33,6 +33,7 @@
#include <utils/Vector.h>
#include <memory>
+#include <optional>
#include <set>
#include <vector>
@@ -161,6 +162,8 @@
void dump(String8& out) const;
android::Hwc2::Composer* getComposer() const { return mHwcDevice->getComposer(); }
+
+ std::optional<hwc2_display_t> getHwcDisplayId(int32_t displayId) const;
private:
static const int32_t VIRTUAL_DISPLAY_ID_BASE = 2;
diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp
index 3be7f47..359b64f 100644
--- a/services/surfaceflinger/Layer.cpp
+++ b/services/surfaceflinger/Layer.cpp
@@ -62,6 +62,11 @@
namespace android {
+LayerBE::LayerBE()
+ : mMesh(Mesh::TRIANGLE_FAN, 4, 2, 2) {
+}
+
+
int32_t Layer::sSequence = 1;
Layer::Layer(SurfaceFlinger* flinger, const sp<Client>& client, const String8& name, uint32_t w,
@@ -84,7 +89,6 @@
mFrameLatencyNeeded(false),
mFiltering(false),
mNeedsFiltering(false),
- mMesh(Mesh::TRIANGLE_FAN, 4, 2, 2),
mProtectedByApp(false),
mClientRef(client),
mPotentialCursor(false),
@@ -133,6 +137,7 @@
CompositorTiming compositorTiming;
flinger->getCompositorTiming(&compositorTiming);
mFrameEventHistory.initializeCompositorTiming(compositorTiming);
+
}
void Layer::onFirstRef() {}
@@ -204,41 +209,42 @@
// ---------------------------------------------------------------------------
bool Layer::createHwcLayer(HWComposer* hwc, int32_t hwcId) {
- LOG_ALWAYS_FATAL_IF(mHwcLayers.count(hwcId) != 0, "Already have a layer for hwcId %d", hwcId);
+ LOG_ALWAYS_FATAL_IF(getBE().mHwcLayers.count(hwcId) != 0,
+ "Already have a layer for hwcId %d", hwcId);
HWC2::Layer* layer = hwc->createLayer(hwcId);
if (!layer) {
return false;
}
- HWCInfo& hwcInfo = mHwcLayers[hwcId];
+ LayerBE::HWCInfo& hwcInfo = getBE().mHwcLayers[hwcId];
hwcInfo.hwc = hwc;
hwcInfo.layer = layer;
layer->setLayerDestroyedListener(
- [this, hwcId](HWC2::Layer* /*layer*/) { mHwcLayers.erase(hwcId); });
+ [this, hwcId](HWC2::Layer* /*layer*/) { getBE().mHwcLayers.erase(hwcId); });
return true;
}
bool Layer::destroyHwcLayer(int32_t hwcId) {
- if (mHwcLayers.count(hwcId) == 0) {
+ if (getBE().mHwcLayers.count(hwcId) == 0) {
return false;
}
- auto& hwcInfo = mHwcLayers[hwcId];
+ auto& hwcInfo = getBE().mHwcLayers[hwcId];
LOG_ALWAYS_FATAL_IF(hwcInfo.layer == nullptr, "Attempt to destroy null layer");
LOG_ALWAYS_FATAL_IF(hwcInfo.hwc == nullptr, "Missing HWComposer");
hwcInfo.hwc->destroyLayer(hwcId, hwcInfo.layer);
// The layer destroyed listener should have cleared the entry from
// mHwcLayers. Verify that.
- LOG_ALWAYS_FATAL_IF(mHwcLayers.count(hwcId) != 0, "Stale layer entry in mHwcLayers");
-
+ LOG_ALWAYS_FATAL_IF(getBE().mHwcLayers.count(hwcId) != 0,
+ "Stale layer entry in getBE().mHwcLayers");
return true;
}
void Layer::destroyAllHwcLayers() {
- size_t numLayers = mHwcLayers.size();
+ size_t numLayers = getBE().mHwcLayers.size();
for (size_t i = 0; i < numLayers; ++i) {
- LOG_ALWAYS_FATAL_IF(mHwcLayers.empty(), "destroyAllHwcLayers failed");
- destroyHwcLayer(mHwcLayers.begin()->first);
+ LOG_ALWAYS_FATAL_IF(getBE().mHwcLayers.empty(), "destroyAllHwcLayers failed");
+ destroyHwcLayer(getBE().mHwcLayers.begin()->first);
}
- LOG_ALWAYS_FATAL_IF(!mHwcLayers.empty(),
+ LOG_ALWAYS_FATAL_IF(!getBE().mHwcLayers.empty(),
"All hardware composer layers should have been destroyed");
}
@@ -459,7 +465,7 @@
void Layer::setGeometry(const sp<const DisplayDevice>& displayDevice, uint32_t z)
{
const auto hwcId = displayDevice->getHwcDisplayId();
- auto& hwcInfo = mHwcLayers[hwcId];
+ auto& hwcInfo = getBE().mHwcLayers[hwcId];
// enable this layer
hwcInfo.forceClientComposition = false;
@@ -615,26 +621,27 @@
}
void Layer::forceClientComposition(int32_t hwcId) {
- if (mHwcLayers.count(hwcId) == 0) {
+ if (getBE().mHwcLayers.count(hwcId) == 0) {
ALOGE("forceClientComposition: no HWC layer found (%d)", hwcId);
return;
}
- mHwcLayers[hwcId].forceClientComposition = true;
+ getBE().mHwcLayers[hwcId].forceClientComposition = true;
}
bool Layer::getForceClientComposition(int32_t hwcId) {
- if (mHwcLayers.count(hwcId) == 0) {
+ if (getBE().mHwcLayers.count(hwcId) == 0) {
ALOGE("getForceClientComposition: no HWC layer found (%d)", hwcId);
return false;
}
- return mHwcLayers[hwcId].forceClientComposition;
+ return getBE().mHwcLayers[hwcId].forceClientComposition;
}
void Layer::updateCursorPosition(const sp<const DisplayDevice>& displayDevice) {
auto hwcId = displayDevice->getHwcDisplayId();
- if (mHwcLayers.count(hwcId) == 0 || getCompositionType(hwcId) != HWC2::Composition::Cursor) {
+ if (getBE().mHwcLayers.count(hwcId) == 0 ||
+ getCompositionType(hwcId) != HWC2::Composition::Cursor) {
return;
}
@@ -657,7 +664,8 @@
auto& displayTransform(displayDevice->getTransform());
auto position = displayTransform.transform(frame);
- auto error = mHwcLayers[hwcId].layer->setCursorPosition(position.left, position.top);
+ auto error = getBE().mHwcLayers[hwcId].layer->setCursorPosition(position.left,
+ position.top);
ALOGE_IF(error != HWC2::Error::None,
"[%s] Failed to set cursor position "
"to (%d, %d): %s (%d)",
@@ -684,9 +692,9 @@
void Layer::clearWithOpenGL(const RenderArea& renderArea, float red, float green, float blue,
float alpha) const {
RenderEngine& engine(mFlinger->getRenderEngine());
- computeGeometry(renderArea, mMesh, false);
+ computeGeometry(renderArea, getBE().mMesh, false);
engine.setupFillWithColor(red, green, blue, alpha);
- engine.drawMesh(mMesh);
+ engine.drawMesh(getBE().mMesh);
}
void Layer::clearWithOpenGL(const RenderArea& renderArea) const {
@@ -694,11 +702,11 @@
}
void Layer::setCompositionType(int32_t hwcId, HWC2::Composition type, bool callIntoHwc) {
- if (mHwcLayers.count(hwcId) == 0) {
+ if (getBE().mHwcLayers.count(hwcId) == 0) {
ALOGE("setCompositionType called without a valid HWC layer");
return;
}
- auto& hwcInfo = mHwcLayers[hwcId];
+ auto& hwcInfo = getBE().mHwcLayers[hwcId];
auto& hwcLayer = hwcInfo.layer;
ALOGV("setCompositionType(%" PRIx64 ", %s, %d)", hwcLayer->getId(), to_string(type).c_str(),
static_cast<int>(callIntoHwc));
@@ -722,27 +730,27 @@
// have a HWC counterpart, then it will always be Client
return HWC2::Composition::Client;
}
- if (mHwcLayers.count(hwcId) == 0) {
+ if (getBE().mHwcLayers.count(hwcId) == 0) {
ALOGE("getCompositionType called with an invalid HWC layer");
return HWC2::Composition::Invalid;
}
- return mHwcLayers.at(hwcId).compositionType;
+ return getBE().mHwcLayers.at(hwcId).compositionType;
}
void Layer::setClearClientTarget(int32_t hwcId, bool clear) {
- if (mHwcLayers.count(hwcId) == 0) {
+ if (getBE().mHwcLayers.count(hwcId) == 0) {
ALOGE("setClearClientTarget called without a valid HWC layer");
return;
}
- mHwcLayers[hwcId].clearClientTarget = clear;
+ getBE().mHwcLayers[hwcId].clearClientTarget = clear;
}
bool Layer::getClearClientTarget(int32_t hwcId) const {
- if (mHwcLayers.count(hwcId) == 0) {
+ if (getBE().mHwcLayers.count(hwcId) == 0) {
ALOGE("getClearClientTarget called without a valid HWC layer");
return false;
}
- return mHwcLayers.at(hwcId).clearClientTarget;
+ return getBE().mHwcLayers.at(hwcId).clearClientTarget;
}
bool Layer::addSyncPoint(const std::shared_ptr<SyncPoint>& point) {
@@ -961,11 +969,12 @@
" requested={ wh={%4u,%4u} }}\n"
" drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n"
" requested={ wh={%4u,%4u} }}\n",
- this, getName().string(), mCurrentTransform, getEffectiveScalingMode(), c.active.w,
- c.active.h, c.crop.left, c.crop.top, c.crop.right, c.crop.bottom,
- c.crop.getWidth(), c.crop.getHeight(), c.requested.w, c.requested.h, s.active.w,
- s.active.h, s.crop.left, s.crop.top, s.crop.right, s.crop.bottom,
- s.crop.getWidth(), s.crop.getHeight(), s.requested.w, s.requested.h);
+ this, getName().string(), mCurrentTransform,
+ getEffectiveScalingMode(), c.active.w, c.active.h, c.crop.left, c.crop.top,
+ c.crop.right, c.crop.bottom, c.crop.getWidth(), c.crop.getHeight(), c.requested.w,
+ c.requested.h, s.active.w, s.active.h, s.crop.left, s.crop.top, s.crop.right,
+ s.crop.bottom, s.crop.getWidth(), s.crop.getHeight(), s.requested.w,
+ s.requested.h);
// record the new size, form this point on, when the client request
// a buffer, it'll get the new size.
@@ -993,7 +1002,7 @@
const bool resizePending = ((c.requested.w != c.active.w) || (c.requested.h != c.active.h)) &&
(mActiveBuffer != nullptr);
if (!isFixedSize()) {
- if (resizePending && mSidebandStream == NULL) {
+ if (resizePending && getBE().mSidebandStream == NULL) {
flags |= eDontUpdateGeometryState;
}
}
@@ -1423,7 +1432,7 @@
}
void Layer::miniDump(String8& result, int32_t hwcId) const {
- if (mHwcLayers.count(hwcId) == 0) {
+ if (getBE().mHwcLayers.count(hwcId) == 0) {
return;
}
@@ -1441,7 +1450,7 @@
result.appendFormat(" %s\n", name.string());
const Layer::State& layerState(getDrawingState());
- const HWCInfo& hwcInfo = mHwcLayers.at(hwcId);
+ const LayerBE::HWCInfo& hwcInfo = getBE().mHwcLayers.at(hwcId);
result.appendFormat(" %10d | ", layerState.z);
result.appendFormat("%10s | ", to_string(getCompositionType(hwcId)).c_str());
const Rect& frame = hwcInfo.displayFrame;
diff --git a/services/surfaceflinger/Layer.h b/services/surfaceflinger/Layer.h
index 9ea800e..b7b7a3a 100644
--- a/services/surfaceflinger/Layer.h
+++ b/services/surfaceflinger/Layer.h
@@ -65,13 +65,51 @@
class GraphicBuffer;
class SurfaceFlinger;
class LayerDebugInfo;
+class LayerBE;
// ---------------------------------------------------------------------------
+class LayerBE {
+public:
+ LayerBE();
+
+ sp<NativeHandle> mSidebandStream;
+
+ // The mesh used to draw the layer in GLES composition mode
+ Mesh mMesh;
+
+ // HWC items, accessed from the main thread
+ struct HWCInfo {
+ HWCInfo()
+ : hwc(nullptr),
+ layer(nullptr),
+ forceClientComposition(false),
+ compositionType(HWC2::Composition::Invalid),
+ clearClientTarget(false) {}
+
+ HWComposer* hwc;
+ HWC2::Layer* layer;
+ bool forceClientComposition;
+ HWC2::Composition compositionType;
+ bool clearClientTarget;
+ Rect displayFrame;
+ FloatRect sourceCrop;
+ HWComposerBufferCache bufferCache;
+ };
+
+ // A layer can be attached to multiple displays when operating in mirror mode
+ // (a.k.a: when several displays are attached with equal layerStack). In this
+ // case we need to keep track. In non-mirror mode, a layer will have only one
+ // HWCInfo. This map key is a display layerStack.
+ std::unordered_map<int32_t, HWCInfo> mHwcLayers;
+};
+
class Layer : public virtual RefBase {
static int32_t sSequence;
public:
+ LayerBE& getBE() { return mBE; }
+ LayerBE& getBE() const { return mBE; }
mutable bool contentDirty;
// regions below are in window-manager space
Region visibleRegion;
@@ -417,13 +455,15 @@
bool destroyHwcLayer(int32_t hwcId);
void destroyAllHwcLayers();
- bool hasHwcLayer(int32_t hwcId) { return mHwcLayers.count(hwcId) > 0; }
+ bool hasHwcLayer(int32_t hwcId) {
+ return getBE().mHwcLayers.count(hwcId) > 0;
+ }
HWC2::Layer* getHwcLayer(int32_t hwcId) {
- if (mHwcLayers.count(hwcId) == 0) {
+ if (getBE().mHwcLayers.count(hwcId) == 0) {
return nullptr;
}
- return mHwcLayers[hwcId].layer;
+ return getBE().mHwcLayers[hwcId].layer;
}
// -----------------------------------------------------------------------
@@ -652,36 +692,9 @@
bool mFiltering;
// Whether filtering is needed b/c of the drawingstate
bool mNeedsFiltering;
- // The mesh used to draw the layer in GLES composition mode
- mutable Mesh mMesh;
bool mPendingRemoval = false;
- // HWC items, accessed from the main thread
- struct HWCInfo {
- HWCInfo()
- : hwc(nullptr),
- layer(nullptr),
- forceClientComposition(false),
- compositionType(HWC2::Composition::Invalid),
- clearClientTarget(false) {}
-
- HWComposer* hwc;
- HWC2::Layer* layer;
- bool forceClientComposition;
- HWC2::Composition compositionType;
- bool clearClientTarget;
- Rect displayFrame;
- FloatRect sourceCrop;
- HWComposerBufferCache bufferCache;
- };
-
- // A layer can be attached to multiple displays when operating in mirror mode
- // (a.k.a: when several displays are attached with equal layerStack). In this
- // case we need to keep track. In non-mirror mode, a layer will have only one
- // HWCInfo. This map key is a display layerStack.
- std::unordered_map<int32_t, HWCInfo> mHwcLayers;
-
// page-flip thread (currently main thread)
bool mProtectedByApp; // application requires protected path to external sink
@@ -708,6 +721,8 @@
wp<Layer> mCurrentParent;
wp<Layer> mDrawingParent;
+
+ mutable LayerBE mBE;
};
// ---------------------------------------------------------------------------
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index ea4f495..d81178c 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -649,7 +649,8 @@
postMessageAsync(message);
};
mVrFlinger = dvr::VrFlinger::Create(mHwc->getComposer(),
- vrFlingerRequestDisplayCallback);
+ mHwc->getHwcDisplayId(HWC_DISPLAY_PRIMARY).value_or(0),
+ vrFlingerRequestDisplayCallback);
if (!mVrFlinger) {
ALOGE("Failed to start vrflinger");
}
@@ -2869,14 +2870,7 @@
if (parent == nullptr) {
mCurrentState.layersSortedByZ.add(lbc);
} else {
- bool found = false;
- mCurrentState.traverseInZOrder([&](Layer* layer) {
- if (layer == parent.get()) {
- found = true;
- }
- });
-
- if (!found) {
+ if (parent->isPendingRemoval()) {
ALOGE("addClientLayer called with a removed parent");
return NAME_NOT_FOUND;
}
diff --git a/services/surfaceflinger/tests/fakehwc/Android.bp b/services/surfaceflinger/tests/fakehwc/Android.bp
index 212b9e7..47c4f4a 100644
--- a/services/surfaceflinger/tests/fakehwc/Android.bp
+++ b/services/surfaceflinger/tests/fakehwc/Android.bp
@@ -31,6 +31,9 @@
"libtrace_proto",
"libgmock"
],
+ cppflags: [
+ "-std=c++1z",
+ ],
tags: ["tests"],
test_suites: ["device-tests"]
}
\ No newline at end of file
diff --git a/services/vr/bufferhubd/bufferhubd.rc b/services/vr/bufferhubd/bufferhubd.rc
index 46fe5f9..c470de5 100644
--- a/services/vr/bufferhubd/bufferhubd.rc
+++ b/services/vr/bufferhubd/bufferhubd.rc
@@ -2,5 +2,4 @@
class core
user system
group system
- writepid /dev/cpuset/tasks
socket pdx/system/buffer_hub/client stream 0660 system system u:object_r:pdx_bufferhub_client_endpoint_socket:s0
diff --git a/services/vr/performanced/performanced.rc b/services/vr/performanced/performanced.rc
index 2605a47..af9760e 100644
--- a/services/vr/performanced/performanced.rc
+++ b/services/vr/performanced/performanced.rc
@@ -2,5 +2,4 @@
class core
user root
group system readproc
- writepid /dev/cpuset/tasks
socket pdx/system/performance/client stream 0666 system system u:object_r:pdx_performance_client_endpoint_socket:s0