Merge "Provide a basic BLASTBufferQueue implementation."
diff --git a/cmds/dumpstate/dumpstate.cpp b/cmds/dumpstate/dumpstate.cpp
index 0a91a07..e1181a6 100644
--- a/cmds/dumpstate/dumpstate.cpp
+++ b/cmds/dumpstate/dumpstate.cpp
@@ -253,7 +253,7 @@
MYLOGE("Failed to retrieve module metadata package name: %s", status.toString8().c_str());
return 0L;
}
- MYLOGD("Module metadata package name: %s", package_name.c_str());
+ MYLOGD("Module metadata package name: %s\n", package_name.c_str());
int64_t version_code;
status = package_service->getVersionCodeForPackage(android::String16(package_name.c_str()),
&version_code);
@@ -876,6 +876,17 @@
CommandOptions::WithTimeoutInMs(timeout_ms).Build());
}
+static void DoSystemLogcat(time_t since) {
+ char since_str[80];
+ strftime(since_str, sizeof(since_str), "%Y-%m-%d %H:%M:%S.000", localtime(&since));
+
+ unsigned long timeout_ms = logcat_timeout({"main", "system", "crash"});
+ RunCommand("SYSTEM LOG",
+ {"logcat", "-v", "threadtime", "-v", "printable", "-v", "uid", "-d", "*:v", "-T",
+ since_str},
+ CommandOptions::WithTimeoutInMs(timeout_ms).Build());
+}
+
static void DoLogcat() {
unsigned long timeout_ms;
// DumpFile("EVENT LOG TAGS", "/etc/event-log-tags");
@@ -1365,8 +1376,6 @@
ds.TakeScreenshot();
}
- DoLogcat();
-
AddAnrTraceFiles();
// NOTE: tombstones are always added as separate entries in the zip archive
@@ -1523,6 +1532,12 @@
// keep the system stats as close to its initial state as possible.
RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK(RunDumpsysCritical);
+ // Capture first logcat early on; useful to take a snapshot before dumpstate logs take over the
+ // buffer.
+ DoLogcat();
+ // Capture timestamp after first logcat to use in next logcat
+ time_t logcat_ts = time(nullptr);
+
/* collect stack traces from Dalvik and native processes (needs root) */
RUN_SLOW_FUNCTION_WITH_CONSENT_CHECK(ds.DumpTraces, &dump_traces_path);
@@ -1560,12 +1575,19 @@
RunCommand("Dmabuf dump", {"/product/bin/dmabuf_dump"});
}
+ DumpFile("PSI cpu", "/proc/pressure/cpu");
+ DumpFile("PSI memory", "/proc/pressure/memory");
+ DumpFile("PSI io", "/proc/pressure/io");
+
if (!DropRootUser()) {
return Dumpstate::RunStatus::ERROR;
}
RETURN_IF_USER_DENIED_CONSENT();
- return dumpstate();
+ Dumpstate::RunStatus status = dumpstate();
+ // Capture logcat since the last time we did it.
+ DoSystemLogcat(logcat_ts);
+ return status;
}
// This method collects common dumpsys for telephony and wifi
diff --git a/cmds/dumpstate/tests/dumpstate_smoke_test.cpp b/cmds/dumpstate/tests/dumpstate_smoke_test.cpp
index dbbcdff..fbb01f5 100644
--- a/cmds/dumpstate/tests/dumpstate_smoke_test.cpp
+++ b/cmds/dumpstate/tests/dumpstate_smoke_test.cpp
@@ -214,8 +214,8 @@
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
}
- static const char* getZipFilePath() {
- return ds.GetPath(".zip").c_str();
+ static const std::string getZipFilePath() {
+ return ds.GetPath(".zip");
}
};
std::shared_ptr<std::vector<SectionInfo>> ZippedBugreportGenerationTest::sections =
@@ -224,12 +224,12 @@
std::chrono::milliseconds ZippedBugreportGenerationTest::duration = 0s;
TEST_F(ZippedBugreportGenerationTest, IsGeneratedWithoutErrors) {
- EXPECT_EQ(access(getZipFilePath(), F_OK), 0);
+ EXPECT_EQ(access(getZipFilePath().c_str(), F_OK), 0);
}
TEST_F(ZippedBugreportGenerationTest, Is3MBto30MBinSize) {
struct stat st;
- EXPECT_EQ(stat(getZipFilePath(), &st), 0);
+ EXPECT_EQ(stat(getZipFilePath().c_str(), &st), 0);
EXPECT_GE(st.st_size, 3000000 /* 3MB */);
EXPECT_LE(st.st_size, 30000000 /* 30MB */);
}
@@ -248,7 +248,7 @@
public:
ZipArchiveHandle handle;
void SetUp() {
- ASSERT_EQ(OpenArchive(ZippedBugreportGenerationTest::getZipFilePath(), &handle), 0);
+ ASSERT_EQ(OpenArchive(ZippedBugreportGenerationTest::getZipFilePath().c_str(), &handle), 0);
}
void TearDown() {
CloseArchive(handle);
@@ -312,7 +312,7 @@
class BugreportSectionTest : public Test {
public:
static void SetUpTestCase() {
- ParseSections(ZippedBugreportGenerationTest::getZipFilePath(),
+ ParseSections(ZippedBugreportGenerationTest::getZipFilePath().c_str(),
ZippedBugreportGenerationTest::sections.get());
}
diff --git a/cmds/installd/tests/installd_cache_test.cpp b/cmds/installd/tests/installd_cache_test.cpp
index db09070..5a5cb53 100644
--- a/cmds/installd/tests/installd_cache_test.cpp
+++ b/cmds/installd/tests/installd_cache_test.cpp
@@ -67,29 +67,29 @@
}
static void mkdir(const char* path) {
- const char* fullPath = StringPrintf("/data/local/tmp/user/0/%s", path).c_str();
- ::mkdir(fullPath, 0755);
+ const std::string fullPath = StringPrintf("/data/local/tmp/user/0/%s", path);
+ ::mkdir(fullPath.c_str(), 0755);
}
static void touch(const char* path, int len, int time) {
- const char* fullPath = StringPrintf("/data/local/tmp/user/0/%s", path).c_str();
- int fd = ::open(fullPath, O_RDWR | O_CREAT, 0644);
+ const std::string fullPath = StringPrintf("/data/local/tmp/user/0/%s", path);
+ int fd = ::open(fullPath.c_str(), O_RDWR | O_CREAT, 0644);
::fallocate(fd, 0, 0, len);
::close(fd);
struct utimbuf times;
times.actime = times.modtime = std::time(0) + time;
- ::utime(fullPath, ×);
+ ::utime(fullPath.c_str(), ×);
}
static int exists(const char* path) {
- const char* fullPath = StringPrintf("/data/local/tmp/user/0/%s", path).c_str();
- return ::access(fullPath, F_OK);
+ const std::string fullPath = StringPrintf("/data/local/tmp/user/0/%s", path);
+ return ::access(fullPath.c_str(), F_OK);
}
static int64_t size(const char* path) {
- const char* fullPath = StringPrintf("/data/local/tmp/user/0/%s", path).c_str();
+ const std::string fullPath = StringPrintf("/data/local/tmp/user/0/%s", path);
struct stat buf;
- if (!stat(fullPath, &buf)) {
+ if (!stat(fullPath.c_str(), &buf)) {
return buf.st_size;
} else {
return -1;
@@ -107,8 +107,8 @@
}
static void setxattr(const char* path, const char* key) {
- const char* fullPath = StringPrintf("/data/local/tmp/user/0/%s", path).c_str();
- ::setxattr(fullPath, key, "", 0, 0);
+ const std::string fullPath = StringPrintf("/data/local/tmp/user/0/%s", path);
+ ::setxattr(fullPath.c_str(), key, "", 0, 0);
}
class CacheTest : public testing::Test {
diff --git a/cmds/servicemanager/Access.cpp b/cmds/servicemanager/Access.cpp
index 606477f..b7e520f 100644
--- a/cmds/servicemanager/Access.cpp
+++ b/cmds/servicemanager/Access.cpp
@@ -137,7 +137,7 @@
bool Access::actionAllowedFromLookup(const CallingContext& sctx, const std::string& name, const char *perm) {
char *tctx = nullptr;
- if (selabel_lookup(getSehandle(), &tctx, name.c_str(), 0) != 0) {
+ if (selabel_lookup(getSehandle(), &tctx, name.c_str(), SELABEL_CTX_ANDROID_SERVICE) != 0) {
LOG(ERROR) << "SELinux: No match for " << name << " in service_contexts.\n";
return false;
}
diff --git a/headers/media_plugin/media/openmax/OMX_IndexExt.h b/headers/media_plugin/media/openmax/OMX_IndexExt.h
index 479e9b8..bbb3193 100644
--- a/headers/media_plugin/media/openmax/OMX_IndexExt.h
+++ b/headers/media_plugin/media/openmax/OMX_IndexExt.h
@@ -101,6 +101,7 @@
OMX_IndexConfigOperatingRate, /**< reference: OMX_PARAM_U32TYPE in Q16 format for video and in Hz for audio */
OMX_IndexParamConsumerUsageBits, /**< reference: OMX_PARAM_U32TYPE */
OMX_IndexConfigLatency, /**< reference: OMX_PARAM_U32TYPE */
+ OMX_IndexConfigLowLatency, /**< reference: OMX_CONFIG_BOOLEANTYPE */
OMX_IndexExtOtherEndUnused,
/* Time configurations */
diff --git a/libs/binder/Android.bp b/libs/binder/Android.bp
index 296e3f6..643a956 100644
--- a/libs/binder/Android.bp
+++ b/libs/binder/Android.bp
@@ -71,7 +71,12 @@
// libbinder does not offer a stable wire protocol.
// if a second copy of it is installed, then it may break after security
// or dessert updates. Instead, apex users should use libbinder_ndk.
- no_apex: true,
+ apex_available: [
+ "//apex_available:platform",
+ // TODO(b/139016109) remove these three
+ "com.android.media.swcodec",
+ "test_com.android.media.swcodec",
+ ],
srcs: [
"Binder.cpp",
diff --git a/libs/binder/IServiceManager.cpp b/libs/binder/IServiceManager.cpp
index 4bea2179..a30df14 100644
--- a/libs/binder/IServiceManager.cpp
+++ b/libs/binder/IServiceManager.cpp
@@ -54,6 +54,36 @@
static_assert(AidlServiceManager::DUMP_FLAG_PRIORITY_ALL == IServiceManager::DUMP_FLAG_PRIORITY_ALL);
static_assert(AidlServiceManager::DUMP_FLAG_PROTO == IServiceManager::DUMP_FLAG_PROTO);
+const String16& IServiceManager::getInterfaceDescriptor() const {
+ return AidlServiceManager::descriptor;
+}
+IServiceManager::IServiceManager() {}
+IServiceManager::~IServiceManager() {}
+
+// From the old libbinder IServiceManager interface to IServiceManager.
+class ServiceManagerShim : public IServiceManager
+{
+public:
+ explicit ServiceManagerShim (const sp<AidlServiceManager>& impl);
+
+ sp<IBinder> getService(const String16& name) const override;
+ sp<IBinder> checkService(const String16& name) const override;
+ status_t addService(const String16& name, const sp<IBinder>& service,
+ bool allowIsolated, int dumpsysPriority) override;
+ Vector<String16> listServices(int dumpsysPriority) override;
+ sp<IBinder> waitForService(const String16& name16) override;
+
+ // for legacy ABI
+ const String16& getInterfaceDescriptor() const override {
+ return mTheRealServiceManager->getInterfaceDescriptor();
+ }
+ IBinder* onAsBinder() override {
+ return IInterface::asBinder(mTheRealServiceManager).get();
+ }
+private:
+ sp<AidlServiceManager> mTheRealServiceManager;
+};
+
sp<IServiceManager> defaultServiceManager()
{
static Mutex gDefaultServiceManagerLock;
@@ -64,8 +94,9 @@
{
AutoMutex _l(gDefaultServiceManagerLock);
while (gDefaultServiceManager == nullptr) {
- gDefaultServiceManager = interface_cast<IServiceManager>(
- ProcessState::self()->getContextObject(nullptr));
+ gDefaultServiceManager = new ServiceManagerShim(
+ interface_cast<AidlServiceManager>(
+ ProcessState::self()->getContextObject(nullptr)));
if (gDefaultServiceManager == nullptr)
sleep(1);
}
@@ -158,142 +189,136 @@
// ----------------------------------------------------------------------
-class BpServiceManager : public BpInterface<IServiceManager>
-{
-public:
- explicit BpServiceManager(const sp<IBinder>& impl)
- : BpInterface<IServiceManager>(impl),
- mTheRealServiceManager(interface_cast<AidlServiceManager>(impl))
- {
- }
+ServiceManagerShim::ServiceManagerShim(const sp<AidlServiceManager>& impl)
+ : mTheRealServiceManager(impl)
+{}
- sp<IBinder> getService(const String16& name) const override
- {
- static bool gSystemBootCompleted = false;
+sp<IBinder> ServiceManagerShim::getService(const String16& name) const
+{
+ static bool gSystemBootCompleted = false;
+
+ sp<IBinder> svc = checkService(name);
+ if (svc != nullptr) return svc;
+
+ const bool isVendorService =
+ strcmp(ProcessState::self()->getDriverName().c_str(), "/dev/vndbinder") == 0;
+ const long timeout = uptimeMillis() + 5000;
+ // Vendor code can't access system properties
+ if (!gSystemBootCompleted && !isVendorService) {
+#ifdef __ANDROID__
+ char bootCompleted[PROPERTY_VALUE_MAX];
+ property_get("sys.boot_completed", bootCompleted, "0");
+ gSystemBootCompleted = strcmp(bootCompleted, "1") == 0 ? true : false;
+#else
+ gSystemBootCompleted = true;
+#endif
+ }
+ // retry interval in millisecond; note that vendor services stay at 100ms
+ const long sleepTime = gSystemBootCompleted ? 1000 : 100;
+
+ int n = 0;
+ while (uptimeMillis() < timeout) {
+ n++;
+ ALOGI("Waiting for service '%s' on '%s'...", String8(name).string(),
+ ProcessState::self()->getDriverName().c_str());
+ usleep(1000*sleepTime);
sp<IBinder> svc = checkService(name);
if (svc != nullptr) return svc;
+ }
+ ALOGW("Service %s didn't start. Returning NULL", String8(name).string());
+ return nullptr;
+}
- const bool isVendorService =
- strcmp(ProcessState::self()->getDriverName().c_str(), "/dev/vndbinder") == 0;
- const long timeout = uptimeMillis() + 5000;
- // Vendor code can't access system properties
- if (!gSystemBootCompleted && !isVendorService) {
-#ifdef __ANDROID__
- char bootCompleted[PROPERTY_VALUE_MAX];
- property_get("sys.boot_completed", bootCompleted, "0");
- gSystemBootCompleted = strcmp(bootCompleted, "1") == 0 ? true : false;
-#else
- gSystemBootCompleted = true;
-#endif
+sp<IBinder> ServiceManagerShim::checkService(const String16& name) const
+{
+ sp<IBinder> ret;
+ if (!mTheRealServiceManager->checkService(String8(name).c_str(), &ret).isOk()) {
+ return nullptr;
+ }
+ return ret;
+}
+
+status_t ServiceManagerShim::addService(const String16& name, const sp<IBinder>& service,
+ bool allowIsolated, int dumpsysPriority)
+{
+ Status status = mTheRealServiceManager->addService(
+ String8(name).c_str(), service, allowIsolated, dumpsysPriority);
+ return status.exceptionCode();
+}
+
+Vector<String16> ServiceManagerShim::listServices(int dumpsysPriority)
+{
+ std::vector<std::string> ret;
+ if (!mTheRealServiceManager->listServices(dumpsysPriority, &ret).isOk()) {
+ return {};
+ }
+
+ Vector<String16> res;
+ res.setCapacity(ret.size());
+ for (const std::string& name : ret) {
+ res.push(String16(name.c_str()));
+ }
+ return res;
+}
+
+sp<IBinder> ServiceManagerShim::waitForService(const String16& name16)
+{
+ class Waiter : public android::os::BnServiceCallback {
+ Status onRegistration(const std::string& /*name*/,
+ const sp<IBinder>& binder) override {
+ std::unique_lock<std::mutex> lock(mMutex);
+ mBinder = binder;
+ lock.unlock();
+ mCv.notify_one();
+ return Status::ok();
}
- // retry interval in millisecond; note that vendor services stay at 100ms
- const long sleepTime = gSystemBootCompleted ? 1000 : 100;
+ public:
+ sp<IBinder> mBinder;
+ std::mutex mMutex;
+ std::condition_variable mCv;
+ };
- int n = 0;
- while (uptimeMillis() < timeout) {
- n++;
- ALOGI("Waiting for service '%s' on '%s'...", String8(name).string(),
- ProcessState::self()->getDriverName().c_str());
- usleep(1000*sleepTime);
+ const std::string name = String8(name16).c_str();
- sp<IBinder> svc = checkService(name);
- if (svc != nullptr) return svc;
- }
- ALOGW("Service %s didn't start. Returning NULL", String8(name).string());
+ sp<IBinder> out;
+ if (!mTheRealServiceManager->getService(name, &out).isOk()) {
+ return nullptr;
+ }
+ if(out != nullptr) return out;
+
+ sp<Waiter> waiter = new Waiter;
+ if (!mTheRealServiceManager->registerForNotifications(
+ name, waiter).isOk()) {
return nullptr;
}
- sp<IBinder> checkService(const String16& name) const override {
- sp<IBinder> ret;
- if (!mTheRealServiceManager->checkService(String8(name).c_str(), &ret).isOk()) {
- return nullptr;
- }
- return ret;
- }
-
- status_t addService(const String16& name, const sp<IBinder>& service,
- bool allowIsolated, int dumpsysPriority) override {
- Status status = mTheRealServiceManager->addService(String8(name).c_str(), service, allowIsolated, dumpsysPriority);
- return status.exceptionCode();
- }
-
- virtual Vector<String16> listServices(int dumpsysPriority) {
- std::vector<std::string> ret;
- if (!mTheRealServiceManager->listServices(dumpsysPriority, &ret).isOk()) {
- return {};
+ while(true) {
+ {
+ std::unique_lock<std::mutex> lock(waiter->mMutex);
+ using std::literals::chrono_literals::operator""s;
+ waiter->mCv.wait_for(lock, 1s, [&] {
+ return waiter->mBinder != nullptr;
+ });
+ if (waiter->mBinder != nullptr) return waiter->mBinder;
}
- Vector<String16> res;
- res.setCapacity(ret.size());
- for (const std::string& name : ret) {
- res.push(String16(name.c_str()));
- }
- return res;
- }
-
- sp<IBinder> waitForService(const String16& name16) override {
- class Waiter : public android::os::BnServiceCallback {
- Status onRegistration(const std::string& /*name*/,
- const sp<IBinder>& binder) override {
- std::unique_lock<std::mutex> lock(mMutex);
- mBinder = binder;
- lock.unlock();
- mCv.notify_one();
- return Status::ok();
- }
- public:
- sp<IBinder> mBinder;
- std::mutex mMutex;
- std::condition_variable mCv;
- };
-
- const std::string name = String8(name16).c_str();
-
- sp<IBinder> out;
+ // Handle race condition for lazy services. Here is what can happen:
+ // - the service dies (not processed by init yet).
+ // - sm processes death notification.
+ // - sm gets getService and calls init to start service.
+ // - init gets the start signal, but the service already appears
+ // started, so it does nothing.
+ // - init gets death signal, but doesn't know it needs to restart
+ // the service
+ // - we need to request service again to get it to start
if (!mTheRealServiceManager->getService(name, &out).isOk()) {
return nullptr;
}
if(out != nullptr) return out;
- sp<Waiter> waiter = new Waiter;
- if (!mTheRealServiceManager->registerForNotifications(
- name, waiter).isOk()) {
- return nullptr;
- }
-
- while(true) {
- {
- std::unique_lock<std::mutex> lock(waiter->mMutex);
- using std::literals::chrono_literals::operator""s;
- waiter->mCv.wait_for(lock, 1s, [&] {
- return waiter->mBinder != nullptr;
- });
- if (waiter->mBinder != nullptr) return waiter->mBinder;
- }
-
- // Handle race condition for lazy services. Here is what can happen:
- // - the service dies (not processed by init yet).
- // - sm processes death notification.
- // - sm gets getService and calls init to start service.
- // - init gets the start signal, but the service already appears
- // started, so it does nothing.
- // - init gets death signal, but doesn't know it needs to restart
- // the service
- // - we need to request service again to get it to start
- if (!mTheRealServiceManager->getService(name, &out).isOk()) {
- return nullptr;
- }
- if(out != nullptr) return out;
-
- ALOGW("Waited one second for %s", name.c_str());
- }
+ ALOGW("Waited one second for %s", name.c_str());
}
-
-private:
- sp<AidlServiceManager> mTheRealServiceManager;
-};
-
-IMPLEMENT_META_INTERFACE(ServiceManager, "android.os.IServiceManager");
+}
} // namespace android
diff --git a/libs/binder/include/binder/IServiceManager.h b/libs/binder/include/binder/IServiceManager.h
index cd63a58..a675513 100644
--- a/libs/binder/include/binder/IServiceManager.h
+++ b/libs/binder/include/binder/IServiceManager.h
@@ -26,10 +26,20 @@
// ----------------------------------------------------------------------
+/**
+ * Service manager for C++ services.
+ *
+ * IInterface is only for legacy ABI compatibility
+ */
class IServiceManager : public IInterface
{
public:
- DECLARE_META_INTERFACE(ServiceManager)
+ // for ABI compatibility
+ virtual const String16& getInterfaceDescriptor() const;
+
+ IServiceManager();
+ virtual ~IServiceManager();
+
/**
* Must match values in IServiceManager.aidl
*/
diff --git a/libs/cputimeinstate/Android.bp b/libs/cputimeinstate/Android.bp
index 9080ce1..a8f7d92 100644
--- a/libs/cputimeinstate/Android.bp
+++ b/libs/cputimeinstate/Android.bp
@@ -8,6 +8,7 @@
"liblog",
"libnetdutils"
],
+ header_libs: ["bpf_prog_headers"],
cflags: [
"-Werror",
"-Wall",
@@ -25,6 +26,7 @@
"libtimeinstate",
"libnetdutils",
],
+ header_libs: ["bpf_prog_headers"],
cflags: [
"-Werror",
"-Wall",
diff --git a/libs/cputimeinstate/cputimeinstate.cpp b/libs/cputimeinstate/cputimeinstate.cpp
index f255512..45fea85 100644
--- a/libs/cputimeinstate/cputimeinstate.cpp
+++ b/libs/cputimeinstate/cputimeinstate.cpp
@@ -17,7 +17,7 @@
#define LOG_TAG "libtimeinstate"
#include "cputimeinstate.h"
-#include "timeinstate.h"
+#include <bpf_timeinstate.h>
#include <dirent.h>
#include <errno.h>
@@ -110,9 +110,10 @@
std::string path =
StringPrintf("%s/%s/scaling_%s_frequencies", basepath, policy.c_str(), name);
auto nums = readNumbersFromFile(path);
- if (!nums) return false;
+ if (!nums) continue;
freqs.insert(freqs.end(), nums->begin(), nums->end());
}
+ if (freqs.empty()) return false;
std::sort(freqs.begin(), freqs.end());
gPolicyFreqs.emplace_back(freqs);
diff --git a/libs/cputimeinstate/testtimeinstate.cpp b/libs/cputimeinstate/testtimeinstate.cpp
index 15f6214..c0cd3e0 100644
--- a/libs/cputimeinstate/testtimeinstate.cpp
+++ b/libs/cputimeinstate/testtimeinstate.cpp
@@ -1,5 +1,5 @@
-#include "timeinstate.h"
+#include <bpf_timeinstate.h>
#include <sys/sysinfo.h>
diff --git a/libs/cputimeinstate/timeinstate.h b/libs/cputimeinstate/timeinstate.h
deleted file mode 100644
index 6d4f913..0000000
--- a/libs/cputimeinstate/timeinstate.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <inttypes.h>
-
-#define BPF_FS_PATH "/sys/fs/bpf/"
-
-#define FREQS_PER_ENTRY 32
-#define CPUS_PER_ENTRY 8
-
-struct time_key_t {
- uint32_t uid;
- uint32_t bucket;
-};
-
-struct tis_val_t {
- uint64_t ar[FREQS_PER_ENTRY];
-};
-
-struct concurrent_val_t {
- uint64_t active[CPUS_PER_ENTRY];
- uint64_t policy[CPUS_PER_ENTRY];
-};
-
-struct freq_idx_key_t {
- uint32_t policy;
- uint32_t freq;
-};
diff --git a/libs/graphicsenv/GraphicsEnv.cpp b/libs/graphicsenv/GraphicsEnv.cpp
index 30f5f73..2859111 100644
--- a/libs/graphicsenv/GraphicsEnv.cpp
+++ b/libs/graphicsenv/GraphicsEnv.cpp
@@ -307,6 +307,13 @@
}
}
+bool GraphicsEnv::setInjectLayersPrSetDumpable() {
+ if (prctl(PR_SET_DUMPABLE, 1, 0, 0, 0) == -1) {
+ return false;
+ }
+ return true;
+}
+
void* GraphicsEnv::loadLibrary(std::string name) {
const android_dlextinfo dlextinfo = {
.flags = ANDROID_DLEXT_USE_NAMESPACE,
diff --git a/libs/graphicsenv/include/graphicsenv/GraphicsEnv.h b/libs/graphicsenv/include/graphicsenv/GraphicsEnv.h
index a47f468..83448d4 100644
--- a/libs/graphicsenv/include/graphicsenv/GraphicsEnv.h
+++ b/libs/graphicsenv/include/graphicsenv/GraphicsEnv.h
@@ -68,6 +68,14 @@
void setDriverLoaded(GpuStatsInfo::Api api, bool isDriverLoaded, int64_t driverLoadingTime);
/*
+ * Api for Vk/GL layer injection. Presently, drivers enable certain
+ * profiling features when prctl(PR_GET_DUMPABLE) returns true.
+ * Calling this when layer injection metadata is present allows the driver
+ * to enable profiling even when in a non-debuggable app
+ */
+ bool setInjectLayersPrSetDumpable();
+
+ /*
* Apis for ANGLE
*/
// Check if the requested app should use ANGLE.
diff --git a/libs/gui/Android.bp b/libs/gui/Android.bp
index 5a663ad..e6d442d 100644
--- a/libs/gui/Android.bp
+++ b/libs/gui/Android.bp
@@ -32,6 +32,8 @@
defaults: ["libgui_bufferqueue-defaults"],
srcs: [
+ ":libgui_bufferqueue_sources",
+
"BitTube.cpp",
"BLASTBufferQueue.cpp",
"BufferHubConsumer.cpp",
@@ -105,32 +107,14 @@
],
defaults: ["libgui_bufferqueue-defaults"],
+
+ srcs: [
+ ":libgui_bufferqueue_sources",
+ ],
}
-// Common build config shared by libgui and libgui_bufferqueue_static.
-cc_defaults {
- name: "libgui_bufferqueue-defaults",
-
- clang: true,
- cflags: [
- "-Wall",
- "-Werror",
- ],
-
- cppflags: [
- "-Wextra",
- "-DDEBUG_ONLY_CODE=0",
- ],
-
- product_variables: {
- eng: {
- cppflags: [
- "-UDEBUG_ONLY_CODE",
- "-DDEBUG_ONLY_CODE=1",
- ],
- },
- },
-
+filegroup {
+ name: "libgui_bufferqueue_sources",
srcs: [
"BufferItem.cpp",
"BufferQueue.cpp",
@@ -158,6 +142,31 @@
"bufferqueue/2.0/H2BProducerListener.cpp",
"bufferqueue/2.0/types.cpp",
],
+}
+
+// Common build config shared by libgui and libgui_bufferqueue_static.
+cc_defaults {
+ name: "libgui_bufferqueue-defaults",
+
+ clang: true,
+ cflags: [
+ "-Wall",
+ "-Werror",
+ ],
+
+ cppflags: [
+ "-Wextra",
+ "-DDEBUG_ONLY_CODE=0",
+ ],
+
+ product_variables: {
+ eng: {
+ cppflags: [
+ "-UDEBUG_ONLY_CODE",
+ "-DDEBUG_ONLY_CODE=1",
+ ],
+ },
+ },
shared_libs: [
"android.hardware.graphics.bufferqueue@1.0",
@@ -205,4 +214,21 @@
],
}
+// GMocks for use by external code
+cc_library_static {
+ name: "libgui_mocks",
+ vendor_available: false,
+
+ defaults: ["libgui_bufferqueue-defaults"],
+ static_libs: [
+ "libgtest",
+ "libgmock",
+ ],
+
+ srcs: [
+ "mock/GraphicBufferConsumer.cpp",
+ "mock/GraphicBufferProducer.cpp",
+ ],
+}
+
subdirs = ["tests"]
diff --git a/services/surfaceflinger/tests/unittests/mock/gui/MockGraphicBufferConsumer.h b/libs/gui/include/gui/mock/GraphicBufferConsumer.h
similarity index 100%
rename from services/surfaceflinger/tests/unittests/mock/gui/MockGraphicBufferConsumer.h
rename to libs/gui/include/gui/mock/GraphicBufferConsumer.h
diff --git a/services/surfaceflinger/tests/unittests/mock/gui/MockGraphicBufferProducer.h b/libs/gui/include/gui/mock/GraphicBufferProducer.h
similarity index 100%
rename from services/surfaceflinger/tests/unittests/mock/gui/MockGraphicBufferProducer.h
rename to libs/gui/include/gui/mock/GraphicBufferProducer.h
diff --git a/services/surfaceflinger/tests/unittests/mock/gui/MockGraphicBufferConsumer.cpp b/libs/gui/mock/GraphicBufferConsumer.cpp
similarity index 94%
rename from services/surfaceflinger/tests/unittests/mock/gui/MockGraphicBufferConsumer.cpp
rename to libs/gui/mock/GraphicBufferConsumer.cpp
index a17b73f..4a6c081 100644
--- a/services/surfaceflinger/tests/unittests/mock/gui/MockGraphicBufferConsumer.cpp
+++ b/libs/gui/mock/GraphicBufferConsumer.cpp
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-#include "mock/gui/MockGraphicBufferConsumer.h"
+#include <gui/mock/GraphicBufferConsumer.h>
namespace android {
namespace mock {
diff --git a/services/surfaceflinger/tests/unittests/mock/gui/MockGraphicBufferProducer.cpp b/libs/gui/mock/GraphicBufferProducer.cpp
similarity index 94%
rename from services/surfaceflinger/tests/unittests/mock/gui/MockGraphicBufferProducer.cpp
rename to libs/gui/mock/GraphicBufferProducer.cpp
index a7fd667..239a80a 100644
--- a/services/surfaceflinger/tests/unittests/mock/gui/MockGraphicBufferProducer.cpp
+++ b/libs/gui/mock/GraphicBufferProducer.cpp
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-#include "mock/gui/MockGraphicBufferProducer.h"
+#include <gui/mock/GraphicBufferProducer.h>
namespace android {
namespace mock {
diff --git a/libs/renderengine/gl/GLESRenderEngine.cpp b/libs/renderengine/gl/GLESRenderEngine.cpp
index f39f066..b8cf0ea 100644
--- a/libs/renderengine/gl/GLESRenderEngine.cpp
+++ b/libs/renderengine/gl/GLESRenderEngine.cpp
@@ -457,8 +457,10 @@
}
void GLESRenderEngine::primeCache() const {
- ProgramCache::getInstance().primeCache(mInProtectedContext ? mProtectedEGLContext : mEGLContext,
- mFeatureFlags & USE_COLOR_MANAGEMENT);
+ ProgramCache::getInstance().primeCache(
+ mInProtectedContext ? mProtectedEGLContext : mEGLContext,
+ mFeatureFlags & USE_COLOR_MANAGEMENT,
+ mFeatureFlags & PRECACHE_TONE_MAPPER_SHADER_ONLY);
}
base::unique_fd GLESRenderEngine::flush() {
diff --git a/libs/renderengine/gl/ProgramCache.cpp b/libs/renderengine/gl/ProgramCache.cpp
index d242677..494623e 100644
--- a/libs/renderengine/gl/ProgramCache.cpp
+++ b/libs/renderengine/gl/ProgramCache.cpp
@@ -77,9 +77,38 @@
return f;
}
-void ProgramCache::primeCache(EGLContext context, bool useColorManagement) {
+void ProgramCache::primeCache(
+ EGLContext context, bool useColorManagement, bool toneMapperShaderOnly) {
auto& cache = mCaches[context];
uint32_t shaderCount = 0;
+
+ if (toneMapperShaderOnly) {
+ Key shaderKey;
+ // base settings used by HDR->SDR tonemap only
+ shaderKey.set(Key::BLEND_MASK | Key::INPUT_TRANSFORM_MATRIX_MASK |
+ Key::OUTPUT_TRANSFORM_MATRIX_MASK | Key::OUTPUT_TF_MASK |
+ Key::OPACITY_MASK | Key::ALPHA_MASK |
+ Key::ROUNDED_CORNERS_MASK | Key::TEXTURE_MASK,
+ Key::BLEND_NORMAL | Key::INPUT_TRANSFORM_MATRIX_ON |
+ Key::OUTPUT_TRANSFORM_MATRIX_ON | Key::OUTPUT_TF_SRGB |
+ Key::OPACITY_OPAQUE | Key::ALPHA_EQ_ONE |
+ Key::ROUNDED_CORNERS_OFF | Key::TEXTURE_EXT);
+ for (int i = 0; i < 4; i++) {
+ // Cache input transfer for HLG & ST2084
+ shaderKey.set(Key::INPUT_TF_MASK, (i & 1) ?
+ Key::INPUT_TF_HLG : Key::INPUT_TF_ST2084);
+
+ // Cache Y410 input on or off
+ shaderKey.set(Key::Y410_BT2020_MASK, (i & 2) ?
+ Key::Y410_BT2020_ON : Key::Y410_BT2020_OFF);
+ if (cache.count(shaderKey) == 0) {
+ cache.emplace(shaderKey, generateProgram(shaderKey));
+ shaderCount++;
+ }
+ }
+ return;
+ }
+
uint32_t keyMask = Key::BLEND_MASK | Key::OPACITY_MASK | Key::ALPHA_MASK | Key::TEXTURE_MASK
| Key::ROUNDED_CORNERS_MASK;
// Prime the cache for all combinations of the above masks,
diff --git a/libs/renderengine/gl/ProgramCache.h b/libs/renderengine/gl/ProgramCache.h
index 400ad74..175c6e8 100644
--- a/libs/renderengine/gl/ProgramCache.h
+++ b/libs/renderengine/gl/ProgramCache.h
@@ -179,7 +179,7 @@
~ProgramCache() = default;
// Generate shaders to populate the cache
- void primeCache(const EGLContext context, bool useColorManagement);
+ void primeCache(const EGLContext context, bool useColorManagement, bool toneMapperShaderOnly);
size_t getSize(const EGLContext context) { return mCaches[context].size(); }
diff --git a/libs/renderengine/include/renderengine/RenderEngine.h b/libs/renderengine/include/renderengine/RenderEngine.h
index 205782b..9dcd510 100644
--- a/libs/renderengine/include/renderengine/RenderEngine.h
+++ b/libs/renderengine/include/renderengine/RenderEngine.h
@@ -66,6 +66,9 @@
// Create a protected context when if possible
ENABLE_PROTECTED_CONTEXT = 1 << 2,
+
+ // Only precache HDR to SDR tone-mapping shaders
+ PRECACHE_TONE_MAPPER_SHADER_ONLY = 1 << 3,
};
static std::unique_ptr<impl::RenderEngine> create(int hwcFormat, uint32_t featureFlags,
diff --git a/libs/sensor/Sensor.cpp b/libs/sensor/Sensor.cpp
index 139987e..abc9103 100644
--- a/libs/sensor/Sensor.cpp
+++ b/libs/sensor/Sensor.cpp
@@ -577,7 +577,8 @@
uint32_t len = static_cast<uint32_t>(string8.length());
FlattenableUtils::write(buffer, size, len);
memcpy(static_cast<char*>(buffer), string8.string(), len);
- FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(len));
+ FlattenableUtils::advance(buffer, size, len);
+ size -= FlattenableUtils::align<4>(buffer);
}
bool Sensor::unflattenString8(void const*& buffer, size_t& size, String8& outputString8) {
diff --git a/opengl/tests/gl_perf/fill_common.cpp b/opengl/tests/gl_perf/fill_common.cpp
index fefedc0..613f1c6 100644
--- a/opengl/tests/gl_perf/fill_common.cpp
+++ b/opengl/tests/gl_perf/fill_common.cpp
@@ -191,10 +191,10 @@
static void randUniform(int pgm, const char *var) {
GLint loc = glGetUniformLocation(pgm, var);
if (loc >= 0) {
- float x = ((float)rand()) / RAND_MAX;
- float y = ((float)rand()) / RAND_MAX;
- float z = ((float)rand()) / RAND_MAX;
- float w = ((float)rand()) / RAND_MAX;
+ float x = ((float)rand()) / (float)RAND_MAX;
+ float y = ((float)rand()) / (float)RAND_MAX;
+ float z = ((float)rand()) / (float)RAND_MAX;
+ float w = ((float)rand()) / (float)RAND_MAX;
glUniform4f(loc, x, y, z, w);
}
}
diff --git a/services/inputflinger/dispatcher/TouchState.cpp b/services/inputflinger/dispatcher/TouchState.cpp
index 18848a0..2baceba 100644
--- a/services/inputflinger/dispatcher/TouchState.cpp
+++ b/services/inputflinger/dispatcher/TouchState.cpp
@@ -93,15 +93,6 @@
std::end(newMonitors));
}
-void TouchState::removeWindow(const sp<InputWindowHandle>& windowHandle) {
- for (size_t i = 0; i < windows.size(); i++) {
- if (windows[i].windowHandle == windowHandle) {
- windows.erase(windows.begin() + i);
- return;
- }
- }
-}
-
void TouchState::removeWindowByToken(const sp<IBinder>& token) {
for (size_t i = 0; i < windows.size(); i++) {
if (windows[i].windowHandle->getToken() == token) {
diff --git a/services/inputflinger/dispatcher/TouchState.h b/services/inputflinger/dispatcher/TouchState.h
index 3e0e0eb..623c6a8 100644
--- a/services/inputflinger/dispatcher/TouchState.h
+++ b/services/inputflinger/dispatcher/TouchState.h
@@ -49,7 +49,6 @@
BitSet32 pointerIds);
void addPortalWindow(const sp<android::InputWindowHandle>& windowHandle);
void addGestureMonitors(const std::vector<TouchedMonitor>& monitors);
- void removeWindow(const sp<android::InputWindowHandle>& windowHandle);
void removeWindowByToken(const sp<IBinder>& token);
void filterNonAsIsTouchWindows();
void filterNonMonitors();
diff --git a/services/surfaceflinger/Android.bp b/services/surfaceflinger/Android.bp
index 213a62e..e5d23d0 100644
--- a/services/surfaceflinger/Android.bp
+++ b/services/surfaceflinger/Android.bp
@@ -168,6 +168,7 @@
"Scheduler/VSyncModulator.cpp",
"StartPropertySetThread.cpp",
"SurfaceFlinger.cpp",
+ "SurfaceFlingerDefaultFactory.cpp",
"SurfaceInterceptor.cpp",
"SurfaceTracing.cpp",
"TransactionCompletedThread.cpp",
diff --git a/services/surfaceflinger/BufferQueueLayer.cpp b/services/surfaceflinger/BufferQueueLayer.cpp
index eb13f65..d80a70e 100644
--- a/services/surfaceflinger/BufferQueueLayer.cpp
+++ b/services/surfaceflinger/BufferQueueLayer.cpp
@@ -531,7 +531,7 @@
LayerCreationArgs args =
LayerCreationArgs(mFlinger.get(), nullptr, name, 0, 0, 0, LayerMetadata());
args.textureName = mTextureName;
- sp<BufferQueueLayer> layer = new BufferQueueLayer(args);
+ sp<BufferQueueLayer> layer = mFlinger->getFactory().createBufferQueueLayer(args);
layer->setInitialValuesForClone(this);
return layer;
diff --git a/services/surfaceflinger/BufferStateLayer.cpp b/services/surfaceflinger/BufferStateLayer.cpp
index fa4539a..75fc0e9 100644
--- a/services/surfaceflinger/BufferStateLayer.cpp
+++ b/services/surfaceflinger/BufferStateLayer.cpp
@@ -673,7 +673,7 @@
LayerCreationArgs args =
LayerCreationArgs(mFlinger.get(), nullptr, name, 0, 0, 0, LayerMetadata());
args.textureName = mTextureName;
- sp<BufferStateLayer> layer = new BufferStateLayer(args);
+ sp<BufferStateLayer> layer = mFlinger->getFactory().createBufferStateLayer(args);
layer->mHwcSlotGenerator = mHwcSlotGenerator;
layer->setInitialValuesForClone(this);
return layer;
diff --git a/services/surfaceflinger/ColorLayer.cpp b/services/surfaceflinger/ColorLayer.cpp
index 5b62054..172d445 100644
--- a/services/surfaceflinger/ColorLayer.cpp
+++ b/services/surfaceflinger/ColorLayer.cpp
@@ -109,7 +109,7 @@
sp<Layer> ColorLayer::createClone() {
String8 name = mName + " (Mirror)";
- sp<ColorLayer> layer = new ColorLayer(
+ sp<ColorLayer> layer = mFlinger->getFactory().createColorLayer(
LayerCreationArgs(mFlinger.get(), nullptr, name, 0, 0, 0, LayerMetadata()));
layer->setInitialValuesForClone(this);
return layer;
diff --git a/services/surfaceflinger/ContainerLayer.cpp b/services/surfaceflinger/ContainerLayer.cpp
index cb50d9f..e58e6f4 100644
--- a/services/surfaceflinger/ContainerLayer.cpp
+++ b/services/surfaceflinger/ContainerLayer.cpp
@@ -32,7 +32,7 @@
sp<Layer> ContainerLayer::createClone() {
String8 name = mName + " (Mirror)";
- sp<ContainerLayer> layer = new ContainerLayer(
+ sp<ContainerLayer> layer = mFlinger->getFactory().createContainerLayer(
LayerCreationArgs(mFlinger.get(), nullptr, name, 0, 0, 0, LayerMetadata()));
layer->setInitialValuesForClone(this);
return layer;
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index b9e95a6..54e2065 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -258,7 +258,8 @@
mFrameTracer(std::make_unique<FrameTracer>()),
mEventQueue(mFactory.createMessageQueue()),
mCompositionEngine(mFactory.createCompositionEngine()),
- mPhaseOffsets(mFactory.createPhaseOffsets()) {}
+ mPhaseOffsets(mFactory.createPhaseOffsets()),
+ mPendingSyncInputWindows(false) {}
SurfaceFlinger::SurfaceFlinger(Factory& factory) : SurfaceFlinger(factory, SkipInitialization) {
ALOGI("SurfaceFlinger is starting");
diff --git a/services/surfaceflinger/SurfaceFlinger.h b/services/surfaceflinger/SurfaceFlinger.h
index a9a4276..9f3a914 100644
--- a/services/surfaceflinger/SurfaceFlinger.h
+++ b/services/surfaceflinger/SurfaceFlinger.h
@@ -338,6 +338,7 @@
// For unit tests
friend class TestableSurfaceFlinger;
+ friend class TransactionApplicationTest;
// This value is specified in number of frames. Log frame stats at most
// every half hour.
diff --git a/services/surfaceflinger/SurfaceFlingerDefaultFactory.cpp b/services/surfaceflinger/SurfaceFlingerDefaultFactory.cpp
new file mode 100644
index 0000000..f0457e3
--- /dev/null
+++ b/services/surfaceflinger/SurfaceFlingerDefaultFactory.cpp
@@ -0,0 +1,120 @@
+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <compositionengine/impl/CompositionEngine.h>
+#include <ui/GraphicBuffer.h>
+
+#include "BufferQueueLayer.h"
+#include "BufferStateLayer.h"
+#include "ColorLayer.h"
+#include "ContainerLayer.h"
+#include "DisplayDevice.h"
+#include "Layer.h"
+#include "NativeWindowSurface.h"
+#include "StartPropertySetThread.h"
+#include "SurfaceFlingerDefaultFactory.h"
+#include "SurfaceInterceptor.h"
+
+#include "DisplayHardware/ComposerHal.h"
+#include "Scheduler/DispSync.h"
+#include "Scheduler/EventControlThread.h"
+#include "Scheduler/MessageQueue.h"
+#include "Scheduler/PhaseOffsets.h"
+#include "Scheduler/Scheduler.h"
+
+namespace android::surfaceflinger {
+
+DefaultFactory::~DefaultFactory() = default;
+
+std::unique_ptr<DispSync> DefaultFactory::createDispSync(const char* name, bool hasSyncFramework) {
+ return std::make_unique<android::impl::DispSync>(name, hasSyncFramework);
+}
+
+std::unique_ptr<EventControlThread> DefaultFactory::createEventControlThread(
+ SetVSyncEnabled setVSyncEnabled) {
+ return std::make_unique<android::impl::EventControlThread>(std::move(setVSyncEnabled));
+}
+
+std::unique_ptr<HWComposer> DefaultFactory::createHWComposer(const std::string& serviceName) {
+ return std::make_unique<android::impl::HWComposer>(
+ std::make_unique<Hwc2::impl::Composer>(serviceName));
+}
+
+std::unique_ptr<MessageQueue> DefaultFactory::createMessageQueue() {
+ return std::make_unique<android::impl::MessageQueue>();
+}
+
+std::unique_ptr<scheduler::PhaseOffsets> DefaultFactory::createPhaseOffsets() {
+ return std::make_unique<scheduler::impl::PhaseOffsets>();
+}
+
+std::unique_ptr<Scheduler> DefaultFactory::createScheduler(
+ SetVSyncEnabled setVSyncEnabled, const scheduler::RefreshRateConfigs& configs) {
+ return std::make_unique<Scheduler>(std::move(setVSyncEnabled), configs);
+}
+
+std::unique_ptr<SurfaceInterceptor> DefaultFactory::createSurfaceInterceptor(
+ SurfaceFlinger* flinger) {
+ return std::make_unique<android::impl::SurfaceInterceptor>(flinger);
+}
+
+sp<StartPropertySetThread> DefaultFactory::createStartPropertySetThread(
+ bool timestampPropertyValue) {
+ return new StartPropertySetThread(timestampPropertyValue);
+}
+
+sp<DisplayDevice> DefaultFactory::createDisplayDevice(DisplayDeviceCreationArgs&& creationArgs) {
+ return new DisplayDevice(std::move(creationArgs));
+}
+
+sp<GraphicBuffer> DefaultFactory::createGraphicBuffer(uint32_t width, uint32_t height,
+ PixelFormat format, uint32_t layerCount,
+ uint64_t usage, std::string requestorName) {
+ return new GraphicBuffer(width, height, format, layerCount, usage, requestorName);
+}
+
+void DefaultFactory::createBufferQueue(sp<IGraphicBufferProducer>* outProducer,
+ sp<IGraphicBufferConsumer>* outConsumer,
+ bool consumerIsSurfaceFlinger) {
+ BufferQueue::createBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
+}
+
+std::unique_ptr<surfaceflinger::NativeWindowSurface> DefaultFactory::createNativeWindowSurface(
+ const sp<IGraphicBufferProducer>& producer) {
+ return surfaceflinger::impl::createNativeWindowSurface(producer);
+}
+
+std::unique_ptr<compositionengine::CompositionEngine> DefaultFactory::createCompositionEngine() {
+ return compositionengine::impl::createCompositionEngine();
+}
+
+sp<ContainerLayer> DefaultFactory::createContainerLayer(const LayerCreationArgs& args) {
+ return new ContainerLayer(args);
+}
+
+sp<BufferQueueLayer> DefaultFactory::createBufferQueueLayer(const LayerCreationArgs& args) {
+ return new BufferQueueLayer(args);
+}
+
+sp<BufferStateLayer> DefaultFactory::createBufferStateLayer(const LayerCreationArgs& args) {
+ return new BufferStateLayer(args);
+}
+
+sp<ColorLayer> DefaultFactory::createColorLayer(const LayerCreationArgs& args) {
+ return new ColorLayer(args);
+}
+
+} // namespace android::surfaceflinger
diff --git a/services/surfaceflinger/SurfaceFlingerDefaultFactory.h b/services/surfaceflinger/SurfaceFlingerDefaultFactory.h
new file mode 100644
index 0000000..89e0679
--- /dev/null
+++ b/services/surfaceflinger/SurfaceFlingerDefaultFactory.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "SurfaceFlingerFactory.h"
+
+namespace android::surfaceflinger {
+
+// A default implementation of the factory which creates the standard
+// implementation types for each interface.
+class DefaultFactory : public surfaceflinger::Factory {
+public:
+ virtual ~DefaultFactory();
+
+ std::unique_ptr<DispSync> createDispSync(const char* name, bool hasSyncFramework) override;
+ std::unique_ptr<EventControlThread> createEventControlThread(SetVSyncEnabled) override;
+ std::unique_ptr<HWComposer> createHWComposer(const std::string& serviceName) override;
+ std::unique_ptr<MessageQueue> createMessageQueue() override;
+ std::unique_ptr<scheduler::PhaseOffsets> createPhaseOffsets() override;
+ std::unique_ptr<Scheduler> createScheduler(SetVSyncEnabled,
+ const scheduler::RefreshRateConfigs&) override;
+ std::unique_ptr<SurfaceInterceptor> createSurfaceInterceptor(SurfaceFlinger*) override;
+ sp<StartPropertySetThread> createStartPropertySetThread(bool timestampPropertyValue) override;
+ sp<DisplayDevice> createDisplayDevice(DisplayDeviceCreationArgs&&) override;
+ sp<GraphicBuffer> createGraphicBuffer(uint32_t width, uint32_t height, PixelFormat format,
+ uint32_t layerCount, uint64_t usage,
+ std::string requestorName) override;
+ void createBufferQueue(sp<IGraphicBufferProducer>* outProducer,
+ sp<IGraphicBufferConsumer>* outConsumer,
+ bool consumerIsSurfaceFlinger) override;
+ std::unique_ptr<surfaceflinger::NativeWindowSurface> createNativeWindowSurface(
+ const sp<IGraphicBufferProducer>&) override;
+ std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() override;
+ sp<BufferQueueLayer> createBufferQueueLayer(const LayerCreationArgs& args) override;
+ sp<BufferStateLayer> createBufferStateLayer(const LayerCreationArgs& args) override;
+ sp<ColorLayer> createColorLayer(const LayerCreationArgs& args) override;
+ sp<ContainerLayer> createContainerLayer(const LayerCreationArgs& args) override;
+};
+
+} // namespace android::surfaceflinger
diff --git a/services/surfaceflinger/SurfaceFlingerFactory.cpp b/services/surfaceflinger/SurfaceFlingerFactory.cpp
index 4ddc132..9b1f658 100644
--- a/services/surfaceflinger/SurfaceFlingerFactory.cpp
+++ b/services/surfaceflinger/SurfaceFlingerFactory.cpp
@@ -14,116 +14,13 @@
* limitations under the License.
*/
-#include <compositionengine/impl/CompositionEngine.h>
-#include <ui/GraphicBuffer.h>
-
-#include "BufferQueueLayer.h"
-#include "BufferStateLayer.h"
-#include "ColorLayer.h"
-#include "ContainerLayer.h"
-#include "DisplayDevice.h"
-#include "Layer.h"
-#include "NativeWindowSurface.h"
-#include "StartPropertySetThread.h"
#include "SurfaceFlinger.h"
-#include "SurfaceFlingerFactory.h"
-#include "SurfaceInterceptor.h"
-
-#include "DisplayHardware/ComposerHal.h"
-#include "Scheduler/DispSync.h"
-#include "Scheduler/EventControlThread.h"
-#include "Scheduler/MessageQueue.h"
-#include "Scheduler/PhaseOffsets.h"
-#include "Scheduler/Scheduler.h"
+#include "SurfaceFlingerDefaultFactory.h"
namespace android::surfaceflinger {
sp<SurfaceFlinger> createSurfaceFlinger() {
- class Factory final : public surfaceflinger::Factory {
- public:
- Factory() = default;
- ~Factory() = default;
-
- std::unique_ptr<DispSync> createDispSync(const char* name, bool hasSyncFramework) override {
- return std::make_unique<android::impl::DispSync>(name, hasSyncFramework);
- }
-
- std::unique_ptr<EventControlThread> createEventControlThread(
- SetVSyncEnabled setVSyncEnabled) override {
- return std::make_unique<android::impl::EventControlThread>(std::move(setVSyncEnabled));
- }
-
- std::unique_ptr<HWComposer> createHWComposer(const std::string& serviceName) override {
- return std::make_unique<android::impl::HWComposer>(
- std::make_unique<Hwc2::impl::Composer>(serviceName));
- }
-
- std::unique_ptr<MessageQueue> createMessageQueue() override {
- return std::make_unique<android::impl::MessageQueue>();
- }
-
- std::unique_ptr<scheduler::PhaseOffsets> createPhaseOffsets() override {
- return std::make_unique<scheduler::impl::PhaseOffsets>();
- }
-
- std::unique_ptr<Scheduler> createScheduler(
- SetVSyncEnabled setVSyncEnabled,
- const scheduler::RefreshRateConfigs& configs) override {
- return std::make_unique<Scheduler>(std::move(setVSyncEnabled), configs);
- }
-
- std::unique_ptr<SurfaceInterceptor> createSurfaceInterceptor(
- SurfaceFlinger* flinger) override {
- return std::make_unique<android::impl::SurfaceInterceptor>(flinger);
- }
-
- sp<StartPropertySetThread> createStartPropertySetThread(
- bool timestampPropertyValue) override {
- return new StartPropertySetThread(timestampPropertyValue);
- }
-
- sp<DisplayDevice> createDisplayDevice(DisplayDeviceCreationArgs&& creationArgs) override {
- return new DisplayDevice(std::move(creationArgs));
- }
-
- sp<GraphicBuffer> createGraphicBuffer(uint32_t width, uint32_t height, PixelFormat format,
- uint32_t layerCount, uint64_t usage,
- std::string requestorName) override {
- return new GraphicBuffer(width, height, format, layerCount, usage, requestorName);
- }
-
- void createBufferQueue(sp<IGraphicBufferProducer>* outProducer,
- sp<IGraphicBufferConsumer>* outConsumer,
- bool consumerIsSurfaceFlinger) override {
- BufferQueue::createBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
- }
-
- std::unique_ptr<surfaceflinger::NativeWindowSurface> createNativeWindowSurface(
- const sp<IGraphicBufferProducer>& producer) override {
- return surfaceflinger::impl::createNativeWindowSurface(producer);
- }
-
- std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() override {
- return compositionengine::impl::createCompositionEngine();
- }
-
- sp<ContainerLayer> createContainerLayer(const LayerCreationArgs& args) override {
- return new ContainerLayer(args);
- }
-
- sp<BufferQueueLayer> createBufferQueueLayer(const LayerCreationArgs& args) override {
- return new BufferQueueLayer(args);
- }
-
- sp<BufferStateLayer> createBufferStateLayer(const LayerCreationArgs& args) override {
- return new BufferStateLayer(args);
- }
-
- sp<ColorLayer> createColorLayer(const LayerCreationArgs& args) override {
- return new ColorLayer(args);
- }
- };
- static Factory factory;
+ static DefaultFactory factory;
return new SurfaceFlinger(factory);
}
diff --git a/services/surfaceflinger/TimeStats/TimeStats.cpp b/services/surfaceflinger/TimeStats/TimeStats.cpp
index 3df8360..3e47ec6 100644
--- a/services/surfaceflinger/TimeStats/TimeStats.cpp
+++ b/services/surfaceflinger/TimeStats/TimeStats.cpp
@@ -28,7 +28,6 @@
#include <utils/Trace.h>
#include <algorithm>
-#include <regex>
namespace android {
@@ -156,22 +155,6 @@
return static_cast<int32_t>(delta);
}
-// This regular expression captures the following for instance:
-// StatusBar in StatusBar#0
-// com.appname in com.appname/com.appname.activity#0
-// com.appname in SurfaceView - com.appname/com.appname.activity#0
-static const std::regex packageNameRegex("(?:SurfaceView[-\\s\\t]+)?([^/]+).*#\\d+");
-
-static std::string getPackageName(const std::string& layerName) {
- std::smatch match;
- if (std::regex_match(layerName.begin(), layerName.end(), match, packageNameRegex)) {
- // There must be a match for group 1 otherwise the whole string is not
- // matched and the above will return false
- return match[1];
- }
- return "";
-}
-
void TimeStats::flushAvailableRecordsToStatsLocked(int32_t layerID) {
ATRACE_CALL();
@@ -187,7 +170,6 @@
const std::string& layerName = layerRecord.layerName;
if (!mTimeStats.stats.count(layerName)) {
mTimeStats.stats[layerName].layerName = layerName;
- mTimeStats.stats[layerName].packageName = getPackageName(layerName);
}
TimeStatsHelper::TimeStatsLayer& timeStatsLayer = mTimeStats.stats[layerName];
timeStatsLayer.totalFrames++;
@@ -236,19 +218,13 @@
}
}
-// This regular expression captures the following layer names for instance:
-// 1) StatusBat#0
-// 2) NavigationBar#1
-// 3) co(m).*#0
-// 4) SurfaceView - co(m).*#0
-// Using [-\\s\t]+ for the conjunction part between SurfaceView and co(m).*
-// is a bit more robust in case there's a slight change.
-// The layer name would only consist of . / $ _ 0-9 a-z A-Z in most cases.
-static const std::regex layerNameRegex(
- "(((SurfaceView[-\\s\\t]+)?com?\\.[./$\\w]+)|((Status|Navigation)Bar))#\\d+");
+static constexpr const char* kPopupWindowPrefix = "PopupWindow";
+static const size_t kMinLenLayerName = std::strlen(kPopupWindowPrefix);
+// Avoid tracking the "PopupWindow:<random hash>#<number>" layers
static bool layerNameIsValid(const std::string& layerName) {
- return std::regex_match(layerName.begin(), layerName.end(), layerNameRegex);
+ return layerName.length() >= kMinLenLayerName &&
+ layerName.compare(0, kMinLenLayerName, kPopupWindowPrefix) != 0;
}
void TimeStats::setPostTime(int32_t layerID, uint64_t frameNumber, const std::string& layerName,
diff --git a/services/surfaceflinger/tests/unittests/Android.bp b/services/surfaceflinger/tests/unittests/Android.bp
index 8d98af6..2183d34 100644
--- a/services/surfaceflinger/tests/unittests/Android.bp
+++ b/services/surfaceflinger/tests/unittests/Android.bp
@@ -52,11 +52,10 @@
"RegionSamplingTest.cpp",
"TimeStatsTest.cpp",
"FrameTracerTest.cpp",
+ "TransactionApplicationTest.cpp",
"mock/DisplayHardware/MockComposer.cpp",
"mock/DisplayHardware/MockDisplay.cpp",
"mock/DisplayHardware/MockPowerAdvisor.cpp",
- "mock/gui/MockGraphicBufferConsumer.cpp",
- "mock/gui/MockGraphicBufferProducer.cpp",
"mock/MockDispSync.cpp",
"mock/MockEventControlThread.cpp",
"mock/MockEventThread.cpp",
@@ -71,6 +70,7 @@
"libgmock",
"libcompositionengine",
"libcompositionengine_mocks",
+ "libgui_mocks",
"libperfetto_client_experimental",
"librenderengine_mocks",
"libtimestats",
diff --git a/services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp b/services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp
index ee1f3aa..b1a4951 100644
--- a/services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp
+++ b/services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp
@@ -24,6 +24,8 @@
#include <compositionengine/mock/DisplaySurface.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
+#include <gui/mock/GraphicBufferConsumer.h>
+#include <gui/mock/GraphicBufferProducer.h>
#include <log/log.h>
#include <renderengine/mock/RenderEngine.h>
#include <ui/DebugUtils.h>
@@ -38,8 +40,6 @@
#include "mock/MockMessageQueue.h"
#include "mock/MockNativeWindowSurface.h"
#include "mock/MockSurfaceInterceptor.h"
-#include "mock/gui/MockGraphicBufferConsumer.h"
-#include "mock/gui/MockGraphicBufferProducer.h"
#include "mock/system/window/MockNativeWindow.h"
namespace android {
diff --git a/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h b/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
index 926b8ac..b85c1b6 100644
--- a/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
+++ b/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
@@ -35,7 +35,7 @@
#include "Scheduler/RefreshRateConfigs.h"
#include "StartPropertySetThread.h"
#include "SurfaceFlinger.h"
-#include "SurfaceFlingerFactory.h"
+#include "SurfaceFlingerDefaultFactory.h"
#include "SurfaceInterceptor.h"
#include "TestableScheduler.h"
@@ -232,6 +232,8 @@
auto& mutableLayerCurrentState(sp<Layer> layer) { return layer->mCurrentState; }
auto& mutableLayerDrawingState(sp<Layer> layer) { return layer->mDrawingState; }
+ auto& mutableStateLock() { return mFlinger->mStateLock; }
+
void setLayerSidebandStream(sp<Layer> layer, sp<NativeHandle> sidebandStream) {
layer->mDrawingState.sidebandStream = sidebandStream;
layer->mSidebandStream = sidebandStream;
@@ -320,6 +322,22 @@
return mFlinger->SurfaceFlinger::getDisplayNativePrimaries(displayToken, primaries);
}
+ auto& getTransactionQueue() { return mFlinger->mTransactionQueues; }
+
+ auto setTransactionState(const Vector<ComposerState>& states,
+ const Vector<DisplayState>& displays, uint32_t flags,
+ const sp<IBinder>& applyToken,
+ const InputWindowCommands& inputWindowCommands,
+ int64_t desiredPresentTime, const client_cache_t& uncacheBuffer,
+ bool hasListenerCallbacks,
+ std::vector<ListenerCallbacks>& listenerCallbacks) {
+ return mFlinger->setTransactionState(states, displays, flags, applyToken,
+ inputWindowCommands, desiredPresentTime, uncacheBuffer,
+ hasListenerCallbacks, listenerCallbacks);
+ }
+
+ auto flushTransactionQueues() { return mFlinger->flushTransactionQueues(); };
+
/* ------------------------------------------------------------------------
* Read-only access to private data to assert post-conditions.
*/
diff --git a/services/surfaceflinger/tests/unittests/TimeStatsTest.cpp b/services/surfaceflinger/tests/unittests/TimeStatsTest.cpp
index dee2cae..4eb9ec3 100644
--- a/services/surfaceflinger/tests/unittests/TimeStatsTest.cpp
+++ b/services/surfaceflinger/tests/unittests/TimeStatsTest.cpp
@@ -171,7 +171,7 @@
}
static std::string genLayerName(int32_t layerID) {
- return (layerID < 0 ? "invalid.dummy" : "com.dummy#") + std::to_string(layerID);
+ return (layerID < 0 ? "PopupWindow:b54fcd1#0" : "com.dummy#") + std::to_string(layerID);
}
void TimeStatsTest::setTimeStamp(TimeStamp type, int32_t id, uint64_t frameNumber, nsecs_t ts) {
diff --git a/services/surfaceflinger/tests/unittests/TransactionApplicationTest.cpp b/services/surfaceflinger/tests/unittests/TransactionApplicationTest.cpp
new file mode 100644
index 0000000..a465388
--- /dev/null
+++ b/services/surfaceflinger/tests/unittests/TransactionApplicationTest.cpp
@@ -0,0 +1,318 @@
+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#undef LOG_TAG
+#define LOG_TAG "CompositionTest"
+
+#include <compositionengine/Display.h>
+#include <compositionengine/mock/DisplaySurface.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <gui/SurfaceComposerClient.h>
+#include <log/log.h>
+#include <utils/String8.h>
+
+#include "TestableScheduler.h"
+#include "TestableSurfaceFlinger.h"
+#include "mock/MockDispSync.h"
+#include "mock/MockEventControlThread.h"
+#include "mock/MockEventThread.h"
+#include "mock/MockMessageQueue.h"
+
+namespace android {
+
+using testing::_;
+using testing::Return;
+
+using FakeHwcDisplayInjector = TestableSurfaceFlinger::FakeHwcDisplayInjector;
+
+class TransactionApplicationTest : public testing::Test {
+public:
+ TransactionApplicationTest() {
+ const ::testing::TestInfo* const test_info =
+ ::testing::UnitTest::GetInstance()->current_test_info();
+ ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
+
+ mFlinger.mutableEventQueue().reset(mMessageQueue);
+ setupScheduler();
+ }
+
+ ~TransactionApplicationTest() {
+ const ::testing::TestInfo* const test_info =
+ ::testing::UnitTest::GetInstance()->current_test_info();
+ ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
+ }
+
+ void setupScheduler() {
+ auto eventThread = std::make_unique<mock::EventThread>();
+ auto sfEventThread = std::make_unique<mock::EventThread>();
+
+ EXPECT_CALL(*eventThread, registerDisplayEventConnection(_));
+ EXPECT_CALL(*eventThread, createEventConnection(_, _))
+ .WillOnce(Return(
+ new EventThreadConnection(eventThread.get(), ResyncCallback(),
+ ISurfaceComposer::eConfigChangedSuppress)));
+
+ EXPECT_CALL(*sfEventThread, registerDisplayEventConnection(_));
+ EXPECT_CALL(*sfEventThread, createEventConnection(_, _))
+ .WillOnce(Return(
+ new EventThreadConnection(sfEventThread.get(), ResyncCallback(),
+ ISurfaceComposer::eConfigChangedSuppress)));
+
+ EXPECT_CALL(*mPrimaryDispSync, computeNextRefresh(0)).WillRepeatedly(Return(0));
+ EXPECT_CALL(*mPrimaryDispSync, getPeriod())
+ .WillRepeatedly(Return(FakeHwcDisplayInjector::DEFAULT_REFRESH_RATE));
+
+ mFlinger.setupScheduler(std::unique_ptr<mock::DispSync>(mPrimaryDispSync),
+ std::make_unique<mock::EventControlThread>(),
+ std::move(eventThread), std::move(sfEventThread));
+ }
+
+ TestableScheduler* mScheduler;
+ TestableSurfaceFlinger mFlinger;
+
+ std::unique_ptr<mock::EventThread> mEventThread = std::make_unique<mock::EventThread>();
+ mock::EventControlThread* mEventControlThread = new mock::EventControlThread();
+
+ mock::MessageQueue* mMessageQueue = new mock::MessageQueue();
+ mock::DispSync* mPrimaryDispSync = new mock::DispSync();
+
+ struct TransactionInfo {
+ Vector<ComposerState> states;
+ Vector<DisplayState> displays;
+ uint32_t flags = 0;
+ sp<IBinder> applyToken = IInterface::asBinder(TransactionCompletedListener::getIInstance());
+ InputWindowCommands inputWindowCommands;
+ int64_t desiredPresentTime = -1;
+ client_cache_t uncacheBuffer;
+ };
+
+ void checkEqual(TransactionInfo info, SurfaceFlinger::TransactionState state) {
+ EXPECT_EQ(0, info.states.size());
+ EXPECT_EQ(0, state.states.size());
+
+ EXPECT_EQ(0, info.displays.size());
+ EXPECT_EQ(0, state.displays.size());
+ EXPECT_EQ(info.flags, state.flags);
+ EXPECT_EQ(info.desiredPresentTime, state.desiredPresentTime);
+ }
+
+ void setupSingle(TransactionInfo& transaction, uint32_t flags, bool syncInputWindows,
+ int64_t desiredPresentTime) {
+ mTransactionNumber++;
+ transaction.flags |= flags; // ISurfaceComposer::eSynchronous;
+ transaction.inputWindowCommands.syncInputWindows = syncInputWindows;
+ transaction.desiredPresentTime = desiredPresentTime;
+ }
+
+ void NotPlacedOnTransactionQueue(uint32_t flags, bool syncInputWindows) {
+ ASSERT_EQ(0, mFlinger.getTransactionQueue().size());
+ // called in SurfaceFlinger::signalTransaction
+ EXPECT_CALL(*mMessageQueue, invalidate()).Times(1);
+ EXPECT_CALL(*mPrimaryDispSync, expectedPresentTime()).WillOnce(Return(systemTime()));
+ TransactionInfo transaction;
+ setupSingle(transaction, flags, syncInputWindows,
+ /*desiredPresentTime*/ -1);
+ nsecs_t applicationTime = systemTime();
+ mFlinger.setTransactionState(transaction.states, transaction.displays, transaction.flags,
+ transaction.applyToken, transaction.inputWindowCommands,
+ transaction.desiredPresentTime, transaction.uncacheBuffer,
+ mHasListenerCallbacks, mCallbacks);
+
+ // This transaction should not have been placed on the transaction queue.
+ // If transaction is synchronous or syncs input windows, SF
+ // applyTransactionState should time out (5s) wating for SF to commit
+ // the transaction or to receive a signal that syncInputWindows has
+ // completed. If this is animation, it should not time out waiting.
+ nsecs_t returnedTime = systemTime();
+ if (flags & ISurfaceComposer::eSynchronous || syncInputWindows) {
+ EXPECT_GE(returnedTime, applicationTime + s2ns(5));
+ } else {
+ EXPECT_LE(returnedTime, applicationTime + s2ns(5));
+ }
+ auto transactionQueue = mFlinger.getTransactionQueue();
+ EXPECT_EQ(0, transactionQueue.size());
+ }
+
+ void PlaceOnTransactionQueue(uint32_t flags, bool syncInputWindows) {
+ ASSERT_EQ(0, mFlinger.getTransactionQueue().size());
+ // called in SurfaceFlinger::signalTransaction
+ EXPECT_CALL(*mMessageQueue, invalidate()).Times(1);
+
+ // first check will see desired present time has not passed,
+ // but afterwards it will look like the desired present time has passed
+ nsecs_t time = systemTime();
+ EXPECT_CALL(*mPrimaryDispSync, expectedPresentTime())
+ .WillOnce(Return(time + nsecs_t(5 * 1e8)));
+ TransactionInfo transaction;
+ setupSingle(transaction, flags, syncInputWindows,
+ /*desiredPresentTime*/ time + s2ns(1));
+ nsecs_t applicationSentTime = systemTime();
+ mFlinger.setTransactionState(transaction.states, transaction.displays, transaction.flags,
+ transaction.applyToken, transaction.inputWindowCommands,
+ transaction.desiredPresentTime, transaction.uncacheBuffer,
+ mHasListenerCallbacks, mCallbacks);
+
+ nsecs_t returnedTime = systemTime();
+ EXPECT_LE(returnedTime, applicationSentTime + s2ns(5));
+ // This transaction should have been placed on the transaction queue
+ auto transactionQueue = mFlinger.getTransactionQueue();
+ EXPECT_EQ(1, transactionQueue.size());
+ }
+
+ void BlockedByPriorTransaction(uint32_t flags, bool syncInputWindows) {
+ ASSERT_EQ(0, mFlinger.getTransactionQueue().size());
+ // called in SurfaceFlinger::signalTransaction
+ nsecs_t time = systemTime();
+ EXPECT_CALL(*mMessageQueue, invalidate()).Times(1);
+ EXPECT_CALL(*mPrimaryDispSync, expectedPresentTime())
+ .WillOnce(Return(time + nsecs_t(5 * 1e8)));
+ // transaction that should go on the pending thread
+ TransactionInfo transactionA;
+ setupSingle(transactionA, /*flags*/ 0, /*syncInputWindows*/ false,
+ /*desiredPresentTime*/ time + s2ns(1));
+
+ // transaction that would not have gone on the pending thread if not
+ // blocked
+ TransactionInfo transactionB;
+ setupSingle(transactionB, flags, syncInputWindows,
+ /*desiredPresentTime*/ -1);
+
+ nsecs_t applicationSentTime = systemTime();
+ mFlinger.setTransactionState(transactionA.states, transactionA.displays, transactionA.flags,
+ transactionA.applyToken, transactionA.inputWindowCommands,
+ transactionA.desiredPresentTime, transactionA.uncacheBuffer,
+ mHasListenerCallbacks, mCallbacks);
+
+ // This thread should not have been blocked by the above transaction
+ // (5s is the timeout period that applyTransactionState waits for SF to
+ // commit the transaction)
+ EXPECT_LE(systemTime(), applicationSentTime + s2ns(5));
+
+ applicationSentTime = systemTime();
+ mFlinger.setTransactionState(transactionB.states, transactionB.displays, transactionB.flags,
+ transactionB.applyToken, transactionB.inputWindowCommands,
+ transactionB.desiredPresentTime, transactionB.uncacheBuffer,
+ mHasListenerCallbacks, mCallbacks);
+
+ // this thread should have been blocked by the above transaction
+ // if this is an animation, this thread should be blocked for 5s
+ // in setTransactionState waiting for transactionA to flush. Otherwise,
+ // the transaction should be placed on the pending queue
+ if (flags & ISurfaceComposer::eAnimation) {
+ EXPECT_GE(systemTime(), applicationSentTime + s2ns(5));
+ } else {
+ EXPECT_LE(systemTime(), applicationSentTime + s2ns(5));
+ }
+
+ // check that there is one binder on the pending queue.
+ auto transactionQueue = mFlinger.getTransactionQueue();
+ EXPECT_EQ(1, transactionQueue.size());
+
+ auto& [applyToken, transactionStates] = *(transactionQueue.begin());
+ EXPECT_EQ(2, transactionStates.size());
+
+ auto& transactionStateA = transactionStates.front();
+ transactionStates.pop();
+ checkEqual(transactionA, transactionStateA);
+ auto& transactionStateB = transactionStates.front();
+ checkEqual(transactionB, transactionStateB);
+ }
+
+ bool mHasListenerCallbacks = false;
+ std::vector<ListenerCallbacks> mCallbacks;
+ int mTransactionNumber = 0;
+};
+
+TEST_F(TransactionApplicationTest, Flush_RemovesFromQueue) {
+ ASSERT_EQ(0, mFlinger.getTransactionQueue().size());
+ // called in SurfaceFlinger::signalTransaction
+ EXPECT_CALL(*mMessageQueue, invalidate()).Times(1);
+
+ // nsecs_t time = systemTime();
+ EXPECT_CALL(*mPrimaryDispSync, expectedPresentTime())
+ .WillOnce(Return(nsecs_t(5 * 1e8)))
+ .WillOnce(Return(s2ns(2)));
+ TransactionInfo transactionA; // transaction to go on pending queue
+ setupSingle(transactionA, /*flags*/ 0, /*syncInputWindows*/ false,
+ /*desiredPresentTime*/ s2ns(1));
+ mFlinger.setTransactionState(transactionA.states, transactionA.displays, transactionA.flags,
+ transactionA.applyToken, transactionA.inputWindowCommands,
+ transactionA.desiredPresentTime, transactionA.uncacheBuffer,
+ mHasListenerCallbacks, mCallbacks);
+
+ auto& transactionQueue = mFlinger.getTransactionQueue();
+ ASSERT_EQ(1, transactionQueue.size());
+
+ auto& [applyToken, transactionStates] = *(transactionQueue.begin());
+ ASSERT_EQ(1, transactionStates.size());
+
+ auto& transactionState = transactionStates.front();
+ checkEqual(transactionA, transactionState);
+
+ // because flushing uses the cached expected present time, we send an empty
+ // transaction here (sending a null applyToken to fake it as from a
+ // different process) to re-query and reset the cached expected present time
+ TransactionInfo empty;
+ empty.applyToken = sp<IBinder>();
+ mFlinger.setTransactionState(empty.states, empty.displays, empty.flags, empty.applyToken,
+ empty.inputWindowCommands, empty.desiredPresentTime,
+ empty.uncacheBuffer, mHasListenerCallbacks, mCallbacks);
+
+ // flush transaction queue should flush as desiredPresentTime has
+ // passed
+ mFlinger.flushTransactionQueues();
+
+ EXPECT_EQ(0, transactionQueue.size());
+}
+
+TEST_F(TransactionApplicationTest, NotPlacedOnTransactionQueue_Synchronous) {
+ NotPlacedOnTransactionQueue(ISurfaceComposer::eSynchronous, /*syncInputWindows*/ false);
+}
+
+TEST_F(TransactionApplicationTest, NotPlacedOnTransactionQueue_Animation) {
+ NotPlacedOnTransactionQueue(ISurfaceComposer::eAnimation, /*syncInputWindows*/ false);
+}
+
+TEST_F(TransactionApplicationTest, NotPlacedOnTransactionQueue_SyncInputWindows) {
+ NotPlacedOnTransactionQueue(/*flags*/ 0, /*syncInputWindows*/ true);
+}
+
+TEST_F(TransactionApplicationTest, PlaceOnTransactionQueue_Synchronous) {
+ PlaceOnTransactionQueue(ISurfaceComposer::eSynchronous, /*syncInputWindows*/ false);
+}
+
+TEST_F(TransactionApplicationTest, PlaceOnTransactionQueue_Animation) {
+ PlaceOnTransactionQueue(ISurfaceComposer::eAnimation, /*syncInputWindows*/ false);
+}
+
+TEST_F(TransactionApplicationTest, PlaceOnTransactionQueue_SyncInputWindows) {
+ PlaceOnTransactionQueue(/*flags*/ 0, /*syncInputWindows*/ true);
+}
+
+TEST_F(TransactionApplicationTest, BlockWithPriorTransaction_Synchronous) {
+ BlockedByPriorTransaction(ISurfaceComposer::eSynchronous, /*syncInputWindows*/ false);
+}
+
+TEST_F(TransactionApplicationTest, BlockWithPriorTransaction_Animation) {
+ BlockedByPriorTransaction(ISurfaceComposer::eSynchronous, /*syncInputWindows*/ false);
+}
+
+TEST_F(TransactionApplicationTest, BlockWithPriorTransaction_SyncInputWindows) {
+ BlockedByPriorTransaction(/*flags*/ 0, /*syncInputWindows*/ true);
+}
+
+} // namespace android