Merge "Add color space connection"
diff --git a/cmds/dumpstate/dumpstate.cpp b/cmds/dumpstate/dumpstate.cpp
index dca0695..aba9807 100644
--- a/cmds/dumpstate/dumpstate.cpp
+++ b/cmds/dumpstate/dumpstate.cpp
@@ -1061,7 +1061,7 @@
RunCommand("VOLD DUMP", {"vdc", "dump"});
RunCommand("SECURE CONTAINERS", {"vdc", "asec", "list"});
- RunCommand("STORAGED TASKIOINFO", {"storaged", "-d"}, CommandOptions::WithTimeout(10).Build());
+ RunCommand("STORAGED TASKIOINFO", {"storaged", "-u"}, CommandOptions::WithTimeout(10).Build());
RunCommand("FILESYSTEMS & FREE SPACE", {"df"});
diff --git a/cmds/dumpsys/tests/dumpsys_test.cpp b/cmds/dumpsys/tests/dumpsys_test.cpp
index a66685d..01a2fa3 100644
--- a/cmds/dumpsys/tests/dumpsys_test.cpp
+++ b/cmds/dumpsys/tests/dumpsys_test.cpp
@@ -78,6 +78,7 @@
R<bool>(const hidl_string&,
const hidl_string&,
const sp<IServiceNotification>&));
+ MOCK_METHOD1(debugDump, R<void>(debugDump_cb));
};
diff --git a/cmds/installd/InstalldNativeService.cpp b/cmds/installd/InstalldNativeService.cpp
index 4589241..393ce74 100644
--- a/cmds/installd/InstalldNativeService.cpp
+++ b/cmds/installd/InstalldNativeService.cpp
@@ -961,6 +961,10 @@
add_cache_files(cache,
StringPrintf("%s/Android/data", create_data_media_path(uuid_, user).c_str()));
}
+ // Add files from /data/preloads/file_cache
+ if (uuid == nullptr) {
+ add_preloads_file_cache(cache, uuid_);
+ }
ATRACE_END();
ATRACE_BEGIN("clear");
@@ -1185,6 +1189,7 @@
return;
}
while ((p = fts_read(fts)) != NULL) {
+ p->fts_number = p->fts_parent->fts_number;
switch (p->fts_info) {
case FTS_D:
if (p->fts_level == 4
@@ -1193,7 +1198,6 @@
&& !strcmp(p->fts_parent->fts_parent->fts_parent->fts_name, "Android")) {
p->fts_number = 1;
}
- p->fts_number = p->fts_parent->fts_number;
// Fall through to count the directory
case FTS_DEFAULT:
case FTS_F:
@@ -1297,9 +1301,9 @@
ATRACE_END();
ATRACE_BEGIN("external");
- auto extPath = create_data_media_package_path(uuid_, userId, pkgname, "data");
+ auto extPath = create_data_media_package_path(uuid_, userId, "data", pkgname);
collectManualStats(extPath, &extStats);
- auto mediaPath = create_data_media_package_path(uuid_, userId, pkgname, "media");
+ auto mediaPath = create_data_media_package_path(uuid_, userId, "media", pkgname);
calculate_tree_size(mediaPath, &extStats.dataSize);
ATRACE_END();
}
diff --git a/cmds/installd/dexopt.cpp b/cmds/installd/dexopt.cpp
index 1565d0d..4c0f884 100644
--- a/cmds/installd/dexopt.cpp
+++ b/cmds/installd/dexopt.cpp
@@ -235,22 +235,24 @@
static const int MAX_INT_LEN = 12; // '-'+10dig+'\0' -OR- 0x+8dig
- char zip_fd_arg[strlen("--zip-fd=") + MAX_INT_LEN];
- char zip_location_arg[strlen("--zip-location=") + PKG_PATH_MAX];
- char input_vdex_fd_arg[strlen("--input-vdex-fd=") + MAX_INT_LEN];
- char output_vdex_fd_arg[strlen("--output-vdex-fd=") + MAX_INT_LEN];
- char oat_fd_arg[strlen("--oat-fd=") + MAX_INT_LEN];
- char oat_location_arg[strlen("--oat-location=") + PKG_PATH_MAX];
- char instruction_set_arg[strlen("--instruction-set=") + MAX_INSTRUCTION_SET_LEN];
- char instruction_set_variant_arg[strlen("--instruction-set-variant=") + kPropertyValueMax];
- char instruction_set_features_arg[strlen("--instruction-set-features=") + kPropertyValueMax];
- char dex2oat_Xms_arg[strlen("-Xms") + kPropertyValueMax];
- char dex2oat_Xmx_arg[strlen("-Xmx") + kPropertyValueMax];
- char dex2oat_compiler_filter_arg[strlen("--compiler-filter=") + kPropertyValueMax];
+ // clang FORTIFY doesn't let us use strlen in constant array bounds, so we
+ // use arraysize instead.
+ char zip_fd_arg[arraysize("--zip-fd=") + MAX_INT_LEN];
+ char zip_location_arg[arraysize("--zip-location=") + PKG_PATH_MAX];
+ char input_vdex_fd_arg[arraysize("--input-vdex-fd=") + MAX_INT_LEN];
+ char output_vdex_fd_arg[arraysize("--output-vdex-fd=") + MAX_INT_LEN];
+ char oat_fd_arg[arraysize("--oat-fd=") + MAX_INT_LEN];
+ char oat_location_arg[arraysize("--oat-location=") + PKG_PATH_MAX];
+ char instruction_set_arg[arraysize("--instruction-set=") + MAX_INSTRUCTION_SET_LEN];
+ char instruction_set_variant_arg[arraysize("--instruction-set-variant=") + kPropertyValueMax];
+ char instruction_set_features_arg[arraysize("--instruction-set-features=") + kPropertyValueMax];
+ char dex2oat_Xms_arg[arraysize("-Xms") + kPropertyValueMax];
+ char dex2oat_Xmx_arg[arraysize("-Xmx") + kPropertyValueMax];
+ char dex2oat_compiler_filter_arg[arraysize("--compiler-filter=") + kPropertyValueMax];
bool have_dex2oat_swap_fd = false;
- char dex2oat_swap_fd[strlen("--swap-fd=") + MAX_INT_LEN];
+ char dex2oat_swap_fd[arraysize("--swap-fd=") + MAX_INT_LEN];
bool have_dex2oat_image_fd = false;
- char dex2oat_image_fd[strlen("--app-image-fd=") + MAX_INT_LEN];
+ char dex2oat_image_fd[arraysize("--app-image-fd=") + MAX_INT_LEN];
sprintf(zip_fd_arg, "--zip-fd=%d", zip_fd);
sprintf(zip_location_arg, "--zip-location=%s", input_file_name);
diff --git a/cmds/installd/utils.cpp b/cmds/installd/utils.cpp
index 0b1cd7e..32c789d 100644
--- a/cmds/installd/utils.cpp
+++ b/cmds/installd/utils.cpp
@@ -1003,6 +1003,21 @@
closedir(d);
}
+void add_preloads_file_cache(cache_t* cache, const char* volume_uuid) {
+ char dirname[PATH_MAX];
+ DIR* subdir;
+ auto cache_path = StringPrintf("%s/preloads/file_cache", create_data_path(volume_uuid).c_str());
+ strcpy(dirname, cache_path.c_str());
+ CACHE_NOISY(ALOGI("add_preloads_file_cache: dirname=%s\n", dirname));
+ subdir = opendir(dirname);
+ if (subdir != NULL) {
+ size_t dirnameLen = strlen(dirname);
+ _add_cache_files(cache, NULL, dirname, subdir, dirname, dirname + dirnameLen,
+ PATH_MAX - dirnameLen);
+ closedir(subdir);
+ }
+}
+
static char *create_dir_path(char path[PATH_MAX], cache_dir_t* dir)
{
char *pos = path;
diff --git a/cmds/installd/utils.h b/cmds/installd/utils.h
index 5e396c7..9195cb8 100644
--- a/cmds/installd/utils.h
+++ b/cmds/installd/utils.h
@@ -143,6 +143,8 @@
void add_cache_files(cache_t* cache, const std::string& data_path);
+void add_preloads_file_cache(cache_t* cache, const char* volume_uuid);
+
void clear_cache_files(const std::string& data_path, cache_t* cache, int64_t free_size);
void finish_cache_collection(cache_t* cache);
diff --git a/cmds/lshal/Android.bp b/cmds/lshal/Android.bp
new file mode 100644
index 0000000..dd8104d
--- /dev/null
+++ b/cmds/lshal/Android.bp
@@ -0,0 +1,26 @@
+// Copyright (C) 2016 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.
+
+cc_binary {
+ name: "lshal",
+ shared_libs: [
+ "libutils",
+ "libhidlbase",
+ "android.hidl.manager@1.0",
+ "libhidltransport",
+ ],
+ srcs: [
+ "lshal.cpp"
+ ],
+}
diff --git a/cmds/lshal/lshal.cpp b/cmds/lshal/lshal.cpp
new file mode 100644
index 0000000..bc8bf39
--- /dev/null
+++ b/cmds/lshal/lshal.cpp
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2016 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 <getopt.h>
+
+#include <map>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+
+#include <android/hidl/manager/1.0/IServiceManager.h>
+#include <hidl/ServiceManagement.h>
+
+template <typename A, typename B, typename C, typename D>
+void printColumn(std::stringstream &stream,
+ const A &a, const B &b, const C &c, const D &d) {
+ using namespace ::std;
+ stream << left
+ << setw(70) << a << "\t"
+ << setw(20) << b << "\t"
+ << setw(10) << c << "\t"
+ << setw(5) << d << "\t"
+ << endl;
+}
+
+int dump() {
+ using namespace ::std;
+ using namespace ::android::hardware;
+ using namespace ::android::hidl::manager::V1_0;
+
+ std::map<std::string, ::android::sp<IServiceManager>> mapping = {
+ {"hwbinder", defaultServiceManager()},
+ {"passthrough", getPassthroughServiceManager()}
+ };
+
+ std::stringstream stream;
+
+ stream << "All services:" << endl;
+ stream << left;
+ printColumn(stream, "Interface", "Instance", "Transport", "Ref");
+
+ for (const auto &pair : mapping) {
+ const std::string &mode = pair.first;
+ const ::android::sp<IServiceManager> &manager = pair.second;
+
+ if (manager == nullptr) {
+ cerr << "Failed to get IServiceManager for " << mode << "!" << endl;
+ continue;
+ }
+
+ auto ret = manager->debugDump([&](const auto ®istered) {
+ for (const auto &info : registered) {
+ printColumn(stream,
+ info.interfaceName,
+ info.instanceName.empty() ? "N/A" : info.instanceName,
+ mode,
+ info.refCount == 0 ? "N/A" : std::to_string(info.refCount - 1));
+ }
+ });
+ if (!ret.isOk()) {
+ cerr << "Failed to list services for " << mode << ": "
+ << ret.description() << endl;
+ }
+ }
+ cout << stream.rdbuf();
+ return 0;
+}
+
+int usage() {
+ using namespace ::std;
+ cerr
+ << "usage: lshal" << endl
+ << " To dump all hals." << endl
+ << "or:" << endl
+ << " lshal [-h|--help]" << endl
+ << " -h, --help: show this help information." << endl;
+ return -1;
+}
+
+int main(int argc, char **argv) {
+ static struct option longOptions[] = {
+ {"help", no_argument, 0, 'h' },
+ { 0, 0, 0, 0 }
+ };
+
+ int optionIndex;
+ int c;
+ optind = 1;
+ for (;;) {
+ // using getopt_long in case we want to add other options in the future
+ c = getopt_long(argc, argv, "h", longOptions, &optionIndex);
+ if (c == -1) {
+ break;
+ }
+ switch (c) {
+ case 'h': // falls through
+ default: // see unrecognized options
+ return usage();
+ }
+ }
+ return dump();
+
+}
diff --git a/include/android/input.h b/include/android/input.h
index f928c6e..0829989 100644
--- a/include/android/input.h
+++ b/include/android/input.h
@@ -835,6 +835,8 @@
AINPUT_SOURCE_BLUETOOTH_STYLUS = 0x00008000 | AINPUT_SOURCE_STYLUS,
/** trackball */
AINPUT_SOURCE_TRACKBALL = 0x00010000 | AINPUT_SOURCE_CLASS_NAVIGATION,
+ /** mouse relative */
+ AINPUT_SOURCE_MOUSE_RELATIVE = 0x00020000 | AINPUT_SOURCE_CLASS_NAVIGATION,
/** touchpad */
AINPUT_SOURCE_TOUCHPAD = 0x00100000 | AINPUT_SOURCE_CLASS_POSITION,
/** navigation */
diff --git a/include/gui/ISurfaceComposer.h b/include/gui/ISurfaceComposer.h
index 824e5c4..8af4d46 100644
--- a/include/gui/ISurfaceComposer.h
+++ b/include/gui/ISurfaceComposer.h
@@ -78,6 +78,17 @@
*/
virtual sp<ISurfaceComposerClient> createConnection() = 0;
+ /** create a scoped connection with surface flinger.
+ * Surfaces produced with this connection will act
+ * as children of the passed in GBP. That is to say
+ * SurfaceFlinger will draw them relative and confined to
+ * drawing of buffers from the layer associated with parent.
+ * As this is graphically equivalent in reach to just drawing
+ * pixels into the parent buffers, it requires no special permission.
+ */
+ virtual sp<ISurfaceComposerClient> createScopedConnection(
+ const sp<IGraphicBufferProducer>& parent) = 0;
+
/* create a graphic buffer allocator
*/
virtual sp<IGraphicBufferAlloc> createGraphicBufferAlloc() = 0;
@@ -157,7 +168,7 @@
virtual status_t captureScreen(const sp<IBinder>& display,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform,
Rotation rotation = eRotateNone) = 0;
@@ -216,7 +227,8 @@
GET_ACTIVE_COLOR_MODE,
SET_ACTIVE_COLOR_MODE,
ENABLE_VSYNC_INJECTIONS,
- INJECT_VSYNC
+ INJECT_VSYNC,
+ CREATE_SCOPED_CONNECTION
};
virtual status_t onTransact(uint32_t code, const Parcel& data,
diff --git a/include/gui/ISurfaceComposerClient.h b/include/gui/ISurfaceComposerClient.h
index 4a4efb6..0a4d35d 100644
--- a/include/gui/ISurfaceComposerClient.h
+++ b/include/gui/ISurfaceComposerClient.h
@@ -60,6 +60,7 @@
virtual status_t createSurface(
const String8& name, uint32_t w, uint32_t h,
PixelFormat format, uint32_t flags,
+ const sp<IBinder>& parent,
sp<IBinder>* handle,
sp<IGraphicBufferProducer>* gbp) = 0;
diff --git a/include/gui/Surface.h b/include/gui/Surface.h
index 4be11b4..750e653 100644
--- a/include/gui/Surface.h
+++ b/include/gui/Surface.h
@@ -150,9 +150,7 @@
nsecs_t* outLastRefreshStartTime, nsecs_t* outGlCompositionDoneTime,
nsecs_t* outDisplayPresentTime, nsecs_t* outDisplayRetireTime,
nsecs_t* outDequeueReadyTime, nsecs_t* outReleaseTime);
-
- status_t getDisplayRefreshCyclePeriod(nsecs_t* outMinRefreshDuration,
- nsecs_t* outMaxRefreshDuration);
+ status_t getDisplayRefreshCycleDuration(nsecs_t* outRefreshDuration);
status_t getUniqueId(uint64_t* outId) const;
@@ -210,7 +208,7 @@
int dispatchSetAutoRefresh(va_list args);
int dispatchEnableFrameTimestamps(va_list args);
int dispatchGetFrameTimestamps(va_list args);
- int dispatchGetDisplayRefreshCyclePeriod(va_list args);
+ int dispatchGetDisplayRefreshCycleDuration(va_list args);
protected:
virtual int dequeueBuffer(ANativeWindowBuffer** buffer, int* fenceFd);
diff --git a/include/gui/SurfaceComposerClient.h b/include/gui/SurfaceComposerClient.h
index 183b42d..f537020 100644
--- a/include/gui/SurfaceComposerClient.h
+++ b/include/gui/SurfaceComposerClient.h
@@ -52,6 +52,7 @@
friend class Composer;
public:
SurfaceComposerClient();
+ SurfaceComposerClient(const sp<IGraphicBufferProducer>& parent);
virtual ~SurfaceComposerClient();
// Always make sure we could initialize
@@ -105,7 +106,8 @@
uint32_t w, // width in pixel
uint32_t h, // height in pixel
PixelFormat format, // pixel-format desired
- uint32_t flags = 0 // usage flags
+ uint32_t flags = 0, // usage flags
+ SurfaceControl* parent = nullptr // parent
);
//! Create a virtual display
@@ -142,7 +144,7 @@
status_t show(const sp<IBinder>& id);
status_t setFlags(const sp<IBinder>& id, uint32_t flags, uint32_t mask);
status_t setTransparentRegionHint(const sp<IBinder>& id, const Region& transparent);
- status_t setLayer(const sp<IBinder>& id, uint32_t layer);
+ status_t setLayer(const sp<IBinder>& id, int32_t layer);
status_t setLayerInfo(const sp<IBinder>& id, uint32_t type, uint32_t appid);
status_t setAlpha(const sp<IBinder>& id, float alpha=1.0f);
status_t setMatrix(const sp<IBinder>& id, float dsdx, float dtdx, float dsdy, float dtdy);
@@ -153,6 +155,8 @@
status_t setLayerStack(const sp<IBinder>& id, uint32_t layerStack);
status_t deferTransactionUntil(const sp<IBinder>& id,
const sp<IBinder>& handle, uint64_t frameNumber);
+ status_t reparentChildren(const sp<IBinder>& id,
+ const sp<IBinder>& newParentHandle);
status_t setOverrideScalingMode(const sp<IBinder>& id,
int32_t overrideScalingMode);
status_t setGeometryAppliesWithResize(const sp<IBinder>& id);
@@ -200,6 +204,7 @@
status_t mStatus;
sp<ISurfaceComposerClient> mClient;
Composer& mComposer;
+ wp<IGraphicBufferProducer> mParent;
};
// ---------------------------------------------------------------------------
@@ -213,12 +218,12 @@
const sp<IBinder>& display,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform);
static status_t captureToBuffer(
const sp<IBinder>& display,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform,
uint32_t rotation,
sp<GraphicBuffer>* outbuffer);
@@ -242,11 +247,11 @@
bool useIdentityTransform);
status_t update(const sp<IBinder>& display,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform);
status_t update(const sp<IBinder>& display,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform, uint32_t rotation);
sp<CpuConsumer> getCpuConsumer() const;
diff --git a/include/gui/SurfaceControl.h b/include/gui/SurfaceControl.h
index 456bde4..2dcbfa7 100644
--- a/include/gui/SurfaceControl.h
+++ b/include/gui/SurfaceControl.h
@@ -61,7 +61,7 @@
void disconnect();
status_t setLayerStack(uint32_t layerStack);
- status_t setLayer(uint32_t layer);
+ status_t setLayer(int32_t layer);
status_t setLayerInfo(uint32_t type, uint32_t appid);
status_t setPosition(float x, float y);
status_t setSize(uint32_t w, uint32_t h);
@@ -82,7 +82,9 @@
// Defers applying any changes made in this transaction until the Layer
// identified by handle reaches the given frameNumber
- status_t deferTransactionUntil(sp<IBinder> handle, uint64_t frameNumber);
+ status_t deferTransactionUntil(const sp<IBinder>& handle, uint64_t frameNumber);
+ // Reparents all children of this layer to the new parent handle.
+ status_t reparentChildren(const sp<IBinder>& newParentHandle);
// Set an override scaling mode as documented in <system/window.h>
// the override scaling mode will take precedence over any client
diff --git a/include/private/gui/LayerState.h b/include/private/gui/LayerState.h
index b648751..aac76d2 100644
--- a/include/private/gui/LayerState.h
+++ b/include/private/gui/LayerState.h
@@ -57,6 +57,7 @@
eOverrideScalingModeChanged = 0x00000800,
eGeometryAppliesWithResize = 0x00001000,
eLayerInfoChanged = 0x00002000,
+ eReparentChildren = 0x00004000,
};
layer_state_t()
@@ -84,7 +85,7 @@
uint32_t what;
float x;
float y;
- uint32_t z;
+ int32_t z;
uint32_t w;
uint32_t h;
uint32_t layerStack;
@@ -96,6 +97,7 @@
Rect crop;
Rect finalCrop;
sp<IBinder> handle;
+ sp<IBinder> reparentHandle;
uint64_t frameNumber;
int32_t overrideScalingMode;
uint32_t type;
diff --git a/libs/gui/ISurfaceComposer.cpp b/libs/gui/ISurfaceComposer.cpp
index fa2f59a..2a327da 100644
--- a/libs/gui/ISurfaceComposer.cpp
+++ b/libs/gui/ISurfaceComposer.cpp
@@ -64,6 +64,16 @@
return interface_cast<ISurfaceComposerClient>(reply.readStrongBinder());
}
+ virtual sp<ISurfaceComposerClient> createScopedConnection(
+ const sp<IGraphicBufferProducer>& parent)
+ {
+ Parcel data, reply;
+ data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
+ data.writeStrongBinder(IInterface::asBinder(parent));
+ remote()->transact(BnSurfaceComposer::CREATE_SCOPED_CONNECTION, data, &reply);
+ return interface_cast<ISurfaceComposerClient>(reply.readStrongBinder());
+ }
+
virtual sp<IGraphicBufferAlloc> createGraphicBufferAlloc()
{
Parcel data, reply;
@@ -104,7 +114,7 @@
virtual status_t captureScreen(const sp<IBinder>& display,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform,
ISurfaceComposer::Rotation rotation)
{
@@ -115,8 +125,8 @@
data.write(sourceCrop);
data.writeUint32(reqWidth);
data.writeUint32(reqHeight);
- data.writeUint32(minLayerZ);
- data.writeUint32(maxLayerZ);
+ data.writeInt32(minLayerZ);
+ data.writeInt32(maxLayerZ);
data.writeInt32(static_cast<int32_t>(useIdentityTransform));
data.writeInt32(static_cast<int32_t>(rotation));
remote()->transact(BnSurfaceComposer::CAPTURE_SCREEN, data, &reply);
@@ -489,6 +499,14 @@
reply->writeStrongBinder(b);
return NO_ERROR;
}
+ case CREATE_SCOPED_CONNECTION: {
+ CHECK_INTERFACE(ISurfaceComposer, data, reply);
+ sp<IGraphicBufferProducer> bufferProducer =
+ interface_cast<IGraphicBufferProducer>(data.readStrongBinder());
+ sp<IBinder> b = IInterface::asBinder(createScopedConnection(bufferProducer));
+ reply->writeStrongBinder(b);
+ return NO_ERROR;
+ }
case CREATE_GRAPHIC_BUFFER_ALLOC: {
CHECK_INTERFACE(ISurfaceComposer, data, reply);
sp<IBinder> b = IInterface::asBinder(createGraphicBufferAlloc());
@@ -544,8 +562,8 @@
data.read(sourceCrop);
uint32_t reqWidth = data.readUint32();
uint32_t reqHeight = data.readUint32();
- uint32_t minLayerZ = data.readUint32();
- uint32_t maxLayerZ = data.readUint32();
+ int32_t minLayerZ = data.readInt32();
+ int32_t maxLayerZ = data.readInt32();
bool useIdentityTransform = static_cast<bool>(data.readInt32());
int32_t rotation = data.readInt32();
diff --git a/libs/gui/ISurfaceComposerClient.cpp b/libs/gui/ISurfaceComposerClient.cpp
index 47cb047..b2036dc 100644
--- a/libs/gui/ISurfaceComposerClient.cpp
+++ b/libs/gui/ISurfaceComposerClient.cpp
@@ -56,7 +56,7 @@
virtual status_t createSurface(const String8& name, uint32_t width,
uint32_t height, PixelFormat format, uint32_t flags,
- sp<IBinder>* handle,
+ const sp<IBinder>& parent, sp<IBinder>* handle,
sp<IGraphicBufferProducer>* gbp) {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposerClient::getInterfaceDescriptor());
@@ -65,6 +65,9 @@
data.writeUint32(height);
data.writeInt32(static_cast<int32_t>(format));
data.writeUint32(flags);
+ if (parent != nullptr) {
+ data.writeStrongBinder(parent);
+ }
remote()->transact(CREATE_SURFACE, data, &reply);
*handle = reply.readStrongBinder();
*gbp = interface_cast<IGraphicBufferProducer>(reply.readStrongBinder());
@@ -145,10 +148,14 @@
uint32_t height = data.readUint32();
PixelFormat format = static_cast<PixelFormat>(data.readInt32());
uint32_t createFlags = data.readUint32();
+ sp<IBinder> parent = nullptr;
+ if (data.dataAvail() > 0) {
+ parent = data.readStrongBinder();
+ }
sp<IBinder> handle;
sp<IGraphicBufferProducer> gbp;
status_t result = createSurface(name, width, height, format,
- createFlags, &handle, &gbp);
+ createFlags, parent, &handle, &gbp);
reply->writeStrongBinder(handle);
reply->writeStrongBinder(IInterface::asBinder(gbp));
reply->writeInt32(result);
diff --git a/libs/gui/LayerState.cpp b/libs/gui/LayerState.cpp
index 3949186..fbf76a1 100644
--- a/libs/gui/LayerState.cpp
+++ b/libs/gui/LayerState.cpp
@@ -28,7 +28,7 @@
output.writeUint32(what);
output.writeFloat(x);
output.writeFloat(y);
- output.writeUint32(z);
+ output.writeInt32(z);
output.writeUint32(w);
output.writeUint32(h);
output.writeUint32(layerStack);
@@ -40,6 +40,7 @@
output.write(crop);
output.write(finalCrop);
output.writeStrongBinder(handle);
+ output.writeStrongBinder(reparentHandle);
output.writeUint64(frameNumber);
output.writeInt32(overrideScalingMode);
output.writeUint32(type);
@@ -54,7 +55,7 @@
what = input.readUint32();
x = input.readFloat();
y = input.readFloat();
- z = input.readUint32();
+ z = input.readInt32();
w = input.readUint32();
h = input.readUint32();
layerStack = input.readUint32();
@@ -70,6 +71,7 @@
input.read(crop);
input.read(finalCrop);
handle = input.readStrongBinder();
+ reparentHandle = input.readStrongBinder();
frameNumber = input.readUint64();
overrideScalingMode = input.readInt32();
type = input.readUint32();
diff --git a/libs/gui/Surface.cpp b/libs/gui/Surface.cpp
index 851a495..c2ed91a 100644
--- a/libs/gui/Surface.cpp
+++ b/libs/gui/Surface.cpp
@@ -262,15 +262,13 @@
return NO_ERROR;
}
-status_t Surface::getDisplayRefreshCyclePeriod(nsecs_t* outMinRefreshDuration,
- nsecs_t* outMaxRefreshDuration) {
+status_t Surface::getDisplayRefreshCycleDuration(nsecs_t* outRefreshDuration) {
ATRACE_CALL();
DisplayStatInfo stats;
status_t err = composerService()->getDisplayStats(NULL, &stats);
- *outMinRefreshDuration = stats.vsyncPeriod;
- *outMaxRefreshDuration = stats.vsyncPeriod;
+ *outRefreshDuration = stats.vsyncPeriod;
return NO_ERROR;
}
@@ -841,8 +839,8 @@
case NATIVE_WINDOW_GET_FRAME_TIMESTAMPS:
res = dispatchGetFrameTimestamps(args);
break;
- case NATIVE_WINDOW_GET_REFRESH_CYCLE_PERIOD:
- res = dispatchGetDisplayRefreshCyclePeriod(args);
+ case NATIVE_WINDOW_GET_REFRESH_CYCLE_DURATION:
+ res = dispatchGetDisplayRefreshCycleDuration(args);
break;
default:
res = NAME_NOT_FOUND;
@@ -989,11 +987,9 @@
outDisplayRetireTime, outDequeueReadyTime, outReleaseTime);
}
-int Surface::dispatchGetDisplayRefreshCyclePeriod(va_list args) {
- nsecs_t* outMinRefreshDuration = va_arg(args, int64_t*);
- nsecs_t* outMaxRefreshDuration = va_arg(args, int64_t*);
- return getDisplayRefreshCyclePeriod(outMinRefreshDuration,
- outMaxRefreshDuration);
+int Surface::dispatchGetDisplayRefreshCycleDuration(va_list args) {
+ nsecs_t* outRefreshDuration = va_arg(args, int64_t*);
+ return getDisplayRefreshCycleDuration(outRefreshDuration);
}
int Surface::connect(int api) {
diff --git a/libs/gui/SurfaceComposerClient.cpp b/libs/gui/SurfaceComposerClient.cpp
index 3346a83..ece07a3 100644
--- a/libs/gui/SurfaceComposerClient.cpp
+++ b/libs/gui/SurfaceComposerClient.cpp
@@ -148,7 +148,7 @@
status_t setSize(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id,
uint32_t w, uint32_t h);
status_t setLayer(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id,
- uint32_t z);
+ int32_t z);
status_t setLayerInfo(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id,
uint32_t type, uint32_t appid);
status_t setFlags(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id,
@@ -170,6 +170,9 @@
status_t deferTransactionUntil(const sp<SurfaceComposerClient>& client,
const sp<IBinder>& id, const sp<IBinder>& handle,
uint64_t frameNumber);
+ status_t reparentChildren(const sp<SurfaceComposerClient>& client,
+ const sp<IBinder>& id,
+ const sp<IBinder>& newParentHandle);
status_t setOverrideScalingMode(const sp<SurfaceComposerClient>& client,
const sp<IBinder>& id, int32_t overrideScalingMode);
status_t setGeometryAppliesWithResize(const sp<SurfaceComposerClient>& client,
@@ -327,7 +330,7 @@
}
status_t Composer::setLayer(const sp<SurfaceComposerClient>& client,
- const sp<IBinder>& id, uint32_t z) {
+ const sp<IBinder>& id, int32_t z) {
Mutex::Autolock _l(mLock);
layer_state_t* s = getLayerStateLocked(client, id);
if (!s)
@@ -455,6 +458,20 @@
return NO_ERROR;
}
+status_t Composer::reparentChildren(
+ const sp<SurfaceComposerClient>& client,
+ const sp<IBinder>& id,
+ const sp<IBinder>& newParentHandle) {
+ Mutex::Autolock lock(mLock);
+ layer_state_t* s = getLayerStateLocked(client, id);
+ if (!s) {
+ return BAD_INDEX;
+ }
+ s->what |= layer_state_t::eReparentChildren;
+ s->reparentHandle = newParentHandle;
+ return NO_ERROR;
+}
+
status_t Composer::setOverrideScalingMode(
const sp<SurfaceComposerClient>& client,
const sp<IBinder>& id, int32_t overrideScalingMode) {
@@ -564,10 +581,18 @@
{
}
+SurfaceComposerClient::SurfaceComposerClient(const sp<IGraphicBufferProducer>& root)
+ : mStatus(NO_INIT), mComposer(Composer::getInstance()), mParent(root)
+{
+}
+
void SurfaceComposerClient::onFirstRef() {
sp<ISurfaceComposer> sm(ComposerService::getComposerService());
if (sm != 0) {
- sp<ISurfaceComposerClient> conn = sm->createConnection();
+ auto rootProducer = mParent.promote();
+ sp<ISurfaceComposerClient> conn;
+ conn = (rootProducer != nullptr) ? sm->createScopedConnection(rootProducer) :
+ sm->createConnection();
if (conn != 0) {
mClient = conn;
mStatus = NO_ERROR;
@@ -610,13 +635,19 @@
uint32_t w,
uint32_t h,
PixelFormat format,
- uint32_t flags)
+ uint32_t flags,
+ SurfaceControl* parent)
{
sp<SurfaceControl> sur;
if (mStatus == NO_ERROR) {
sp<IBinder> handle;
+ sp<IBinder> parentHandle;
sp<IGraphicBufferProducer> gbp;
- status_t err = mClient->createSurface(name, w, h, format, flags,
+
+ if (parent != nullptr) {
+ parentHandle = parent->getHandle();
+ }
+ status_t err = mClient->createSurface(name, w, h, format, flags, parentHandle,
&handle, &gbp);
ALOGE_IF(err, "SurfaceComposerClient::createSurface error %s", strerror(-err));
if (err == NO_ERROR) {
@@ -714,7 +745,7 @@
return getComposer().setSize(this, id, w, h);
}
-status_t SurfaceComposerClient::setLayer(const sp<IBinder>& id, uint32_t z) {
+status_t SurfaceComposerClient::setLayer(const sp<IBinder>& id, int32_t z) {
return getComposer().setLayer(this, id, z);
}
@@ -762,6 +793,11 @@
return getComposer().deferTransactionUntil(this, id, handle, frameNumber);
}
+status_t SurfaceComposerClient::reparentChildren(const sp<IBinder>& id,
+ const sp<IBinder>& newParentHandle) {
+ return getComposer().reparentChildren(this, id, newParentHandle);
+}
+
status_t SurfaceComposerClient::setOverrideScalingMode(
const sp<IBinder>& id, int32_t overrideScalingMode) {
return getComposer().setOverrideScalingMode(
@@ -871,7 +907,7 @@
const sp<IBinder>& display,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ, bool useIdentityTransform) {
+ int32_t minLayerZ, int32_t maxLayerZ, bool useIdentityTransform) {
sp<ISurfaceComposer> s(ComposerService::getComposerService());
if (s == NULL) return NO_INIT;
return s->captureScreen(display, producer, sourceCrop,
@@ -880,7 +916,7 @@
status_t ScreenshotClient::captureToBuffer(const sp<IBinder>& display,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ, bool useIdentityTransform,
+ int32_t minLayerZ, int32_t maxLayerZ, bool useIdentityTransform,
uint32_t rotation,
sp<GraphicBuffer>* outBuffer) {
sp<ISurfaceComposer> s(ComposerService::getComposerService());
@@ -926,7 +962,7 @@
status_t ScreenshotClient::update(const sp<IBinder>& display,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform, uint32_t rotation) {
sp<ISurfaceComposer> s(ComposerService::getComposerService());
if (s == NULL) return NO_INIT;
@@ -953,7 +989,7 @@
status_t ScreenshotClient::update(const sp<IBinder>& display,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform) {
return ScreenshotClient::update(display, sourceCrop, reqWidth, reqHeight,
@@ -962,14 +998,16 @@
status_t ScreenshotClient::update(const sp<IBinder>& display, Rect sourceCrop,
bool useIdentityTransform) {
- return ScreenshotClient::update(display, sourceCrop, 0, 0, 0, -1U,
+ return ScreenshotClient::update(display, sourceCrop, 0, 0,
+ INT32_MIN, INT32_MAX,
useIdentityTransform, ISurfaceComposer::eRotateNone);
}
status_t ScreenshotClient::update(const sp<IBinder>& display, Rect sourceCrop,
uint32_t reqWidth, uint32_t reqHeight, bool useIdentityTransform) {
return ScreenshotClient::update(display, sourceCrop, reqWidth, reqHeight,
- 0, -1U, useIdentityTransform, ISurfaceComposer::eRotateNone);
+ INT32_MIN, INT32_MAX,
+ useIdentityTransform, ISurfaceComposer::eRotateNone);
}
void ScreenshotClient::release() {
diff --git a/libs/gui/SurfaceControl.cpp b/libs/gui/SurfaceControl.cpp
index b47e434..2d05b78 100644
--- a/libs/gui/SurfaceControl.cpp
+++ b/libs/gui/SurfaceControl.cpp
@@ -102,7 +102,7 @@
if (err < 0) return err;
return mClient->setLayerStack(mHandle, layerStack);
}
-status_t SurfaceControl::setLayer(uint32_t layer) {
+status_t SurfaceControl::setLayer(int32_t layer) {
status_t err = validate();
if (err < 0) return err;
return mClient->setLayer(mHandle, layer);
@@ -168,13 +168,19 @@
return mClient->setFinalCrop(mHandle, crop);
}
-status_t SurfaceControl::deferTransactionUntil(sp<IBinder> handle,
+status_t SurfaceControl::deferTransactionUntil(const sp<IBinder>& handle,
uint64_t frameNumber) {
status_t err = validate();
if (err < 0) return err;
return mClient->deferTransactionUntil(mHandle, handle, frameNumber);
}
+status_t SurfaceControl::reparentChildren(const sp<IBinder>& newParentHandle) {
+ status_t err = validate();
+ if (err < 0) return err;
+ return mClient->reparentChildren(mHandle, newParentHandle);
+}
+
status_t SurfaceControl::setOverrideScalingMode(int32_t overrideScalingMode) {
status_t err = validate();
if (err < 0) return err;
diff --git a/libs/gui/tests/Surface_test.cpp b/libs/gui/tests/Surface_test.cpp
index e40b4eb..412c0f6 100644
--- a/libs/gui/tests/Surface_test.cpp
+++ b/libs/gui/tests/Surface_test.cpp
@@ -333,6 +333,10 @@
}
sp<ISurfaceComposerClient> createConnection() override { return nullptr; }
+ sp<ISurfaceComposerClient> createScopedConnection(
+ const sp<IGraphicBufferProducer>& /* parent */) override {
+ return nullptr;
+ }
sp<IGraphicBufferAlloc> createGraphicBufferAlloc() override {
return nullptr;
}
@@ -398,7 +402,7 @@
status_t captureScreen(const sp<IBinder>& /*display*/,
const sp<IGraphicBufferProducer>& /*producer*/,
Rect /*sourceCrop*/, uint32_t /*reqWidth*/, uint32_t /*reqHeight*/,
- uint32_t /*minLayerZ*/, uint32_t /*maxLayerZ*/,
+ int32_t /*minLayerZ*/, int32_t /*maxLayerZ*/,
bool /*useIdentityTransform*/,
Rotation /*rotation*/) override { return NO_ERROR; }
status_t clearAnimationFrameStats() override { return NO_ERROR; }
diff --git a/services/inputflinger/InputDispatcher.cpp b/services/inputflinger/InputDispatcher.cpp
index 8771d45..b8ca812 100644
--- a/services/inputflinger/InputDispatcher.cpp
+++ b/services/inputflinger/InputDispatcher.cpp
@@ -902,7 +902,7 @@
ALOGD(" Pointer %d: id=%d, toolType=%d, "
"x=%f, y=%f, pressure=%f, size=%f, "
"touchMajor=%f, touchMinor=%f, toolMajor=%f, toolMinor=%f, "
- "orientation=%f, relativeX=%f, relativeY=%f",
+ "orientation=%f",
i, entry->pointerProperties[i].id,
entry->pointerProperties[i].toolType,
entry->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X),
@@ -913,9 +913,7 @@
entry->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR),
entry->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR),
entry->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR),
- entry->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION),
- entry->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X),
- entry->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y));
+ entry->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION));
}
#endif
}
diff --git a/services/inputflinger/InputReader.cpp b/services/inputflinger/InputReader.cpp
index c1e6365..e381f63 100644
--- a/services/inputflinger/InputReader.cpp
+++ b/services/inputflinger/InputReader.cpp
@@ -2478,6 +2478,11 @@
// Configure device mode.
switch (mParameters.mode) {
+ case Parameters::MODE_POINTER_RELATIVE:
+ // Should not happen during first time configuration.
+ ALOGE("Cannot start a device in MODE_POINTER_RELATIVE, starting in MODE_POINTER");
+ mParameters.mode = Parameters::MODE_POINTER;
+ // fall through.
case Parameters::MODE_POINTER:
mSource = AINPUT_SOURCE_MOUSE;
mXPrecision = 1.0f;
@@ -2499,6 +2504,31 @@
mHWheelScale = 1.0f;
}
+ if ((!changes && config->pointerCapture)
+ || (changes & InputReaderConfiguration::CHANGE_POINTER_CAPTURE)) {
+ if (config->pointerCapture) {
+ if (mParameters.mode == Parameters::MODE_POINTER) {
+ mParameters.mode = Parameters::MODE_POINTER_RELATIVE;
+ mSource = AINPUT_SOURCE_MOUSE_RELATIVE;
+ // Keep PointerController around in order to preserve the pointer position.
+ mPointerController->fade(PointerControllerInterface::TRANSITION_IMMEDIATE);
+ } else {
+ ALOGE("Cannot request pointer capture, device is not in MODE_POINTER");
+ }
+ } else {
+ if (mParameters.mode == Parameters::MODE_POINTER_RELATIVE) {
+ mParameters.mode = Parameters::MODE_POINTER;
+ mSource = AINPUT_SOURCE_MOUSE;
+ } else {
+ ALOGE("Cannot release pointer capture, device is not in MODE_POINTER_RELATIVE");
+ }
+ }
+ bumpGeneration();
+ if (changes) {
+ getDevice()->notifyReset(when);
+ }
+ }
+
if (!changes || (changes & InputReaderConfiguration::CHANGE_POINTER_SPEED)) {
mPointerVelocityControl.setParameters(config->pointerVelocityControlParameters);
mWheelXVelocityControl.setParameters(config->wheelVelocityControlParameters);
@@ -2550,6 +2580,9 @@
case Parameters::MODE_POINTER:
dump.append(INDENT4 "Mode: pointer\n");
break;
+ case Parameters::MODE_POINTER_RELATIVE:
+ dump.append(INDENT4 "Mode: relative pointer\n");
+ break;
case Parameters::MODE_NAVIGATION:
dump.append(INDENT4 "Mode: navigation\n");
break;
@@ -2636,7 +2669,7 @@
mPointerVelocityControl.move(when, &deltaX, &deltaY);
int32_t displayId;
- if (mPointerController != NULL) {
+ if (mSource == AINPUT_SOURCE_MOUSE) {
if (moved || scrolled || buttonsChanged) {
mPointerController->setPresentation(
PointerControllerInterface::PRESENTATION_POINTER);
@@ -2687,7 +2720,7 @@
int32_t motionEventAction;
if (downChanged) {
motionEventAction = down ? AMOTION_EVENT_ACTION_DOWN : AMOTION_EVENT_ACTION_UP;
- } else if (down || mPointerController == NULL) {
+ } else if (down || (mSource != AINPUT_SOURCE_MOUSE)) {
motionEventAction = AMOTION_EVENT_ACTION_MOVE;
} else {
motionEventAction = AMOTION_EVENT_ACTION_HOVER_MOVE;
@@ -2732,7 +2765,7 @@
// Send hover move after UP to tell the application that the mouse is hovering now.
if (motionEventAction == AMOTION_EVENT_ACTION_UP
- && mPointerController != NULL) {
+ && (mSource == AINPUT_SOURCE_MOUSE)) {
NotifyMotionArgs hoverArgs(when, getDeviceId(), mSource, policyFlags,
AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 0,
metaState, currentButtonState, AMOTION_EVENT_EDGE_FLAG_NONE,
@@ -5422,8 +5455,6 @@
mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, x);
mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, y);
mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 1.0f);
- mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, deltaX);
- mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, deltaY);
} else if (currentFingerCount == 0) {
// Case 3. No fingers down and button is not pressed. (NEUTRAL)
if (mPointerGesture.lastGestureMode != PointerGesture::NEUTRAL) {
@@ -5582,10 +5613,6 @@
mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, y);
mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE,
down ? 1.0f : 0.0f);
- mPointerGesture.currentGestureCoords[0].setAxisValue(
- AMOTION_EVENT_AXIS_RELATIVE_X, deltaX);
- mPointerGesture.currentGestureCoords[0].setAxisValue(
- AMOTION_EVENT_AXIS_RELATIVE_Y, deltaY);
if (lastFingerCount == 0 && currentFingerCount != 0) {
mPointerGesture.resetTap();
@@ -5832,10 +5859,6 @@
mPointerGesture.referenceGestureX);
mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y,
mPointerGesture.referenceGestureY);
- mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X,
- commonDeltaX);
- mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y,
- commonDeltaY);
mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 1.0f);
} else if (mPointerGesture.currentGestureMode == PointerGesture::FREEFORM) {
// FREEFORM mode.
@@ -5932,10 +5955,6 @@
AMOTION_EVENT_AXIS_Y, mPointerGesture.referenceGestureY + deltaY);
mPointerGesture.currentGestureCoords[i].setAxisValue(
AMOTION_EVENT_AXIS_PRESSURE, 1.0f);
- mPointerGesture.currentGestureCoords[i].setAxisValue(
- AMOTION_EVENT_AXIS_RELATIVE_X, deltaX);
- mPointerGesture.currentGestureCoords[i].setAxisValue(
- AMOTION_EVENT_AXIS_RELATIVE_Y, deltaY);
}
if (mPointerGesture.activeGestureId < 0) {
@@ -6058,8 +6077,6 @@
mPointerSimple.currentCoords.setAxisValue(AMOTION_EVENT_AXIS_Y, y);
mPointerSimple.currentCoords.setAxisValue(AMOTION_EVENT_AXIS_PRESSURE,
hovering ? 0.0f : 1.0f);
- mPointerSimple.currentCoords.setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, x);
- mPointerSimple.currentCoords.setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, y);
mPointerSimple.currentProperties.id = 0;
mPointerSimple.currentProperties.toolType =
mCurrentCookedState.cookedPointerData.pointerProperties[currentIndex].toolType;
diff --git a/services/inputflinger/InputReader.h b/services/inputflinger/InputReader.h
index 8e2fe95..3171526 100644
--- a/services/inputflinger/InputReader.h
+++ b/services/inputflinger/InputReader.h
@@ -144,6 +144,9 @@
// The presence of an external stylus has changed.
CHANGE_EXTERNAL_STYLUS_PRESENCE = 1 << 7,
+ // The pointer capture mode has changed.
+ CHANGE_POINTER_CAPTURE = 1 << 8,
+
// All devices must be reopened.
CHANGE_MUST_REOPEN = 1 << 31,
};
@@ -231,6 +234,9 @@
// True to show the location of touches on the touch screen as spots.
bool showTouches;
+ // True if pointer capture is enabled.
+ bool pointerCapture;
+
InputReaderConfiguration() :
virtualKeyQuietTime(0),
pointerVelocityControlParameters(1.0f, 500.0f, 3000.0f, 3.0f),
@@ -1200,6 +1206,7 @@
struct Parameters {
enum Mode {
MODE_POINTER,
+ MODE_POINTER_RELATIVE,
MODE_NAVIGATION,
};
diff --git a/services/inputflinger/tests/InputReader_test.cpp b/services/inputflinger/tests/InputReader_test.cpp
index a7fe4f6..2e0bcd1 100644
--- a/services/inputflinger/tests/InputReader_test.cpp
+++ b/services/inputflinger/tests/InputReader_test.cpp
@@ -182,6 +182,10 @@
transform = t;
}
+ void setPointerCapture(bool enabled) {
+ mConfig.pointerCapture = enabled;
+ }
+
private:
virtual void getReaderConfiguration(InputReaderConfiguration* outConfig) {
*outConfig = mConfig;
@@ -744,6 +748,10 @@
mGlobalMetaState = state;
}
+ uint32_t getGeneration() {
+ return mGeneration;
+ }
+
private:
virtual void updateGlobalMetaState() {
mUpdateGlobalMetaStateWasCalled = true;
@@ -1425,17 +1433,20 @@
mFakeEventHub->addConfigurationProperty(DEVICE_ID, String8(key), String8(value));
}
+ void configureDevice(uint32_t changes) {
+ mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), changes);
+ }
+
void addMapperAndConfigure(InputMapper* mapper) {
mDevice->addMapper(mapper);
- mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), 0);
+ configureDevice(0);
mDevice->reset(ARBITRARY_TIME);
}
void setDisplayInfoAndReconfigure(int32_t displayId, int32_t width, int32_t height,
int32_t orientation) {
mFakePolicy->setDisplayInfo(displayId, width, height, orientation);
- mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(),
- InputReaderConfiguration::CHANGE_DISPLAY_INFO);
+ configureDevice(InputReaderConfiguration::CHANGE_DISPLAY_INFO);
}
static void process(InputMapper* mapper, nsecs_t when, int32_t deviceId, int32_t type,
@@ -2617,6 +2628,96 @@
process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, 20);
process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0);
ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
+ ASSERT_EQ(AINPUT_SOURCE_MOUSE, args.source);
+ ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, args.action);
+ ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
+ 110.0f, 220.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
+ ASSERT_NO_FATAL_FAILURE(assertPosition(mFakePointerController, 110.0f, 220.0f));
+}
+
+TEST_F(CursorInputMapperTest, Process_PointerCapture) {
+ CursorInputMapper* mapper = new CursorInputMapper(mDevice);
+ addConfigurationProperty("cursor.mode", "pointer");
+ mFakePolicy->setPointerCapture(true);
+ addMapperAndConfigure(mapper);
+
+ NotifyDeviceResetArgs resetArgs;
+ ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs));
+ ASSERT_EQ(ARBITRARY_TIME, resetArgs.eventTime);
+ ASSERT_EQ(DEVICE_ID, resetArgs.deviceId);
+
+ mFakePointerController->setBounds(0, 0, 800 - 1, 480 - 1);
+ mFakePointerController->setPosition(100, 200);
+ mFakePointerController->setButtonState(0);
+
+ NotifyMotionArgs args;
+
+ // Move.
+ process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, 10);
+ process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, 20);
+ process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0);
+ ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
+ ASSERT_EQ(AINPUT_SOURCE_MOUSE_RELATIVE, args.source);
+ ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
+ ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
+ 10.0f, 20.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
+ ASSERT_NO_FATAL_FAILURE(assertPosition(mFakePointerController, 100.0f, 200.0f));
+
+ // Button press.
+ process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_KEY, BTN_MOUSE, 1);
+ process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0);
+ ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
+ ASSERT_EQ(AINPUT_SOURCE_MOUSE_RELATIVE, args.source);
+ ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action);
+ ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
+ 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
+ ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
+ ASSERT_EQ(AINPUT_SOURCE_MOUSE_RELATIVE, args.source);
+ ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_PRESS, args.action);
+ ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
+ 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
+
+ // Button release.
+ process(mapper, ARBITRARY_TIME + 2, DEVICE_ID, EV_KEY, BTN_MOUSE, 0);
+ process(mapper, ARBITRARY_TIME + 2, DEVICE_ID, EV_SYN, SYN_REPORT, 0);
+ ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
+ ASSERT_EQ(AINPUT_SOURCE_MOUSE_RELATIVE, args.source);
+ ASSERT_EQ(AMOTION_EVENT_ACTION_BUTTON_RELEASE, args.action);
+ ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
+ 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
+ ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
+ ASSERT_EQ(AINPUT_SOURCE_MOUSE_RELATIVE, args.source);
+ ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action);
+ ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
+ 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
+
+ // Another move.
+ process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, 30);
+ process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, 40);
+ process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0);
+ ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
+ ASSERT_EQ(AINPUT_SOURCE_MOUSE_RELATIVE, args.source);
+ ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, args.action);
+ ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
+ 30.0f, 40.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
+ ASSERT_NO_FATAL_FAILURE(assertPosition(mFakePointerController, 100.0f, 200.0f));
+
+ // Disable pointer capture and check that the device generation got bumped
+ // and events are generated the usual way.
+ const uint32_t generation = mFakeContext->getGeneration();
+ mFakePolicy->setPointerCapture(false);
+ configureDevice(InputReaderConfiguration::CHANGE_POINTER_CAPTURE);
+ ASSERT_TRUE(mFakeContext->getGeneration() != generation);
+
+ ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs));
+ ASSERT_EQ(ARBITRARY_TIME, resetArgs.eventTime);
+ ASSERT_EQ(DEVICE_ID, resetArgs.deviceId);
+
+ process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_X, 10);
+ process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_REL, REL_Y, 20);
+ process(mapper, ARBITRARY_TIME, DEVICE_ID, EV_SYN, SYN_REPORT, 0);
+ ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));
+ ASSERT_EQ(AINPUT_SOURCE_MOUSE, args.source);
ASSERT_EQ(AMOTION_EVENT_ACTION_HOVER_MOVE, args.action);
ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
110.0f, 220.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
diff --git a/services/surfaceflinger/Android.mk b/services/surfaceflinger/Android.mk
index fcc9241..0ea1407 100644
--- a/services/surfaceflinger/Android.mk
+++ b/services/surfaceflinger/Android.mk
@@ -15,6 +15,7 @@
Layer.cpp \
LayerDim.cpp \
LayerRejecter.cpp \
+ LayerVector.cpp \
MessageQueue.cpp \
MonitoredProducer.cpp \
SurfaceFlingerConsumer.cpp \
@@ -47,6 +48,10 @@
LOCAL_CFLAGS := -DLOG_TAG=\"SurfaceFlinger\"
LOCAL_CFLAGS += -DGL_GLEXT_PROTOTYPES -DEGL_EGLEXT_PROTOTYPES
+ifeq ($(TARGET_IN_VR_MODE),true)
+ LOCAL_CFLAGS += -DIN_VR_MODE
+endif
+
ifeq ($(TARGET_USES_HWC2),true)
LOCAL_CFLAGS += -DUSE_HWC2
LOCAL_SRC_FILES += \
@@ -129,6 +134,7 @@
LOCAL_STATIC_LIBRARIES := libhwcomposer-command-buffer libtrace_proto libvkjson
LOCAL_SHARED_LIBRARIES := \
+ android.dvr.composer@1.0 \
android.hardware.graphics.allocator@2.0 \
android.hardware.graphics.composer@2.1 \
libcutils \
diff --git a/services/surfaceflinger/Client.cpp b/services/surfaceflinger/Client.cpp
index e14a59b..f63784e 100644
--- a/services/surfaceflinger/Client.cpp
+++ b/services/surfaceflinger/Client.cpp
@@ -35,7 +35,13 @@
// ---------------------------------------------------------------------------
Client::Client(const sp<SurfaceFlinger>& flinger)
- : mFlinger(flinger)
+ : Client(flinger, nullptr)
+{
+}
+
+Client::Client(const sp<SurfaceFlinger>& flinger, const sp<Layer>& parentLayer)
+ : mFlinger(flinger),
+ mParentLayer(parentLayer)
{
}
@@ -47,6 +53,10 @@
}
}
+void Client::setParentLayer(const sp<Layer>& parentLayer) {
+ mParentLayer = parentLayer;
+}
+
status_t Client::initCheck() const {
return NO_ERROR;
}
@@ -90,12 +100,17 @@
const int pid = ipc->getCallingPid();
const int uid = ipc->getCallingUid();
const int self_pid = getpid();
- if (CC_UNLIKELY(pid != self_pid && uid != AID_GRAPHICS && uid != AID_SYSTEM && uid != 0)) {
+ // If we are called from another non root process without the GRAPHICS, SYSTEM, or ROOT
+ // uid we require the sAccessSurfaceFlinger permission.
+ // We grant an exception in the case that the Client has a "parent layer", as its
+ // effects will be scoped to that layer.
+ if (CC_UNLIKELY(pid != self_pid && uid != AID_GRAPHICS && uid != AID_SYSTEM && uid != 0)
+ && (mParentLayer.promote() == nullptr)) {
// we're called from a different process, do the real check
if (!PermissionCache::checkCallingPermission(sAccessSurfaceFlinger))
{
ALOGE("Permission Denial: "
- "can't openGlobalTransaction pid=%d, uid=%d", pid, uid);
+ "can't openGlobalTransaction pid=%d, uid<=%d", pid, uid);
return PERMISSION_DENIED;
}
}
@@ -106,14 +121,30 @@
status_t Client::createSurface(
const String8& name,
uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
+ const sp<IBinder>& parentHandle,
sp<IBinder>* handle,
sp<IGraphicBufferProducer>* gbp)
{
+ sp<Layer> parent = nullptr;
+ if (parentHandle != nullptr) {
+ parent = getLayerUser(parentHandle);
+ if (parent == nullptr) {
+ return NAME_NOT_FOUND;
+ }
+ }
+ if (parent == nullptr && mParentLayer != nullptr) {
+ parent = mParentLayer.promote();
+ // If we had a parent, but it died, we've lost all
+ // our capabilities.
+ if (parent == nullptr) {
+ return NAME_NOT_FOUND;
+ }
+ }
+
/*
* createSurface must be called from the GL thread so that it can
* have access to the GL context.
*/
-
class MessageCreateLayer : public MessageBase {
SurfaceFlinger* flinger;
Client* client;
@@ -124,26 +155,29 @@
uint32_t w, h;
PixelFormat format;
uint32_t flags;
+ sp<Layer>* parent;
public:
MessageCreateLayer(SurfaceFlinger* flinger,
const String8& name, Client* client,
uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
sp<IBinder>* handle,
- sp<IGraphicBufferProducer>* gbp)
+ sp<IGraphicBufferProducer>* gbp,
+ sp<Layer>* parent)
: flinger(flinger), client(client),
handle(handle), gbp(gbp), result(NO_ERROR),
- name(name), w(w), h(h), format(format), flags(flags) {
+ name(name), w(w), h(h), format(format), flags(flags),
+ parent(parent) {
}
status_t getResult() const { return result; }
virtual bool handler() {
result = flinger->createLayer(name, client, w, h, format, flags,
- handle, gbp);
+ handle, gbp, parent);
return true;
}
};
sp<MessageBase> msg = new MessageCreateLayer(mFlinger.get(),
- name, this, w, h, format, flags, handle, gbp);
+ name, this, w, h, format, flags, handle, gbp, &parent);
mFlinger->postMessageSync(msg);
return static_cast<MessageCreateLayer*>( msg.get() )->getResult();
}
diff --git a/services/surfaceflinger/Client.h b/services/surfaceflinger/Client.h
index 9c7d050..7328c22 100644
--- a/services/surfaceflinger/Client.h
+++ b/services/surfaceflinger/Client.h
@@ -38,8 +38,9 @@
class Client : public BnSurfaceComposerClient
{
public:
- explicit Client(const sp<SurfaceFlinger>& flinger);
- ~Client();
+ explicit Client(const sp<SurfaceFlinger>& flinger);
+ Client(const sp<SurfaceFlinger>& flinger, const sp<Layer>& parentLayer);
+ ~Client();
status_t initCheck() const;
@@ -50,11 +51,14 @@
sp<Layer> getLayerUser(const sp<IBinder>& handle) const;
+ void setParentLayer(const sp<Layer>& parentLayer);
+
private:
// ISurfaceComposerClient interface
virtual status_t createSurface(
const String8& name,
uint32_t w, uint32_t h,PixelFormat format, uint32_t flags,
+ const sp<IBinder>& parent,
sp<IBinder>* handle,
sp<IGraphicBufferProducer>* gbp);
@@ -75,6 +79,8 @@
// protected by mLock
DefaultKeyedVector< wp<IBinder>, wp<Layer> > mLayers;
+ wp<Layer> mParentLayer;
+
// thread-safe
mutable Mutex mLock;
};
diff --git a/services/surfaceflinger/DisplayHardware/ComposerHal.cpp b/services/surfaceflinger/DisplayHardware/ComposerHal.cpp
index 2f2f3a9..1bd9616 100644
--- a/services/surfaceflinger/DisplayHardware/ComposerHal.cpp
+++ b/services/surfaceflinger/DisplayHardware/ComposerHal.cpp
@@ -17,6 +17,7 @@
#undef LOG_TAG
#define LOG_TAG "HwcComposer"
+#include <android/dvr/composer/1.0/IVrComposerClient.h>
#include <inttypes.h>
#include <log/log.h>
@@ -24,6 +25,7 @@
namespace android {
+using dvr::composer::V1_0::IVrComposerClient;
using hardware::Return;
using hardware::hidl_vec;
using hardware::hidl_handle;
@@ -102,10 +104,37 @@
} // anonymous namespace
-Composer::Composer()
- : mWriter(kWriterInitialSize)
+Composer::CommandWriter::CommandWriter(uint32_t initialMaxSize)
+ : CommandWriterBase(initialMaxSize) {}
+
+Composer::CommandWriter::~CommandWriter()
{
- mComposer = IComposer::getService("hwcomposer");
+}
+
+void Composer::CommandWriter::setLayerInfo(uint32_t type, uint32_t appId)
+{
+ constexpr uint16_t kSetLayerInfoLength = 2;
+ beginCommand(
+ static_cast<IComposerClient::Command>(
+ IVrComposerClient::VrCommand::SET_LAYER_INFO),
+ kSetLayerInfoLength);
+ write(type);
+ write(appId);
+ endCommand();
+}
+
+Composer::Composer() : mWriter(kWriterInitialSize)
+{
+#if defined(IN_VR_MODE)
+ mIsInVrMode = true;
+#endif
+
+ if (mIsInVrMode) {
+ mComposer = IComposer::getService("vr_hwcomposer");
+ } else {
+ mComposer = IComposer::getService("hwcomposer");
+ }
+
if (mComposer == nullptr) {
LOG_ALWAYS_FATAL("failed to get hwcomposer service");
}
@@ -589,6 +618,18 @@
return Error::NONE;
}
+Error Composer::setLayerInfo(Display display, Layer layer, uint32_t type,
+ uint32_t appId)
+{
+ if (mIsInVrMode)
+ {
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerInfo(type, appId);
+ }
+ return Error::NONE;
+}
+
Error Composer::execute()
{
// prepare input command queue
diff --git a/services/surfaceflinger/DisplayHardware/ComposerHal.h b/services/surfaceflinger/DisplayHardware/ComposerHal.h
index 5ce5869..329d787 100644
--- a/services/surfaceflinger/DisplayHardware/ComposerHal.h
+++ b/services/surfaceflinger/DisplayHardware/ComposerHal.h
@@ -215,8 +215,17 @@
Error setLayerVisibleRegion(Display display, Layer layer,
const std::vector<IComposerClient::Rect>& visible);
Error setLayerZOrder(Display display, Layer layer, uint32_t z);
-
+ Error setLayerInfo(Display display, Layer layer, uint32_t type,
+ uint32_t appId);
private:
+ class CommandWriter : public CommandWriterBase {
+ public:
+ CommandWriter(uint32_t initialMaxSize);
+ ~CommandWriter() override;
+
+ void setLayerInfo(uint32_t type, uint32_t appId);
+ };
+
// Many public functions above simply write a command into the command
// queue to batch the calls. validateDisplay and presentDisplay will call
// this function to execute the command queue.
@@ -228,8 +237,10 @@
// 64KiB minus a small space for metadata such as read/write pointers
static constexpr size_t kWriterInitialSize =
64 * 1024 / sizeof(uint32_t) - 16;
- CommandWriterBase mWriter;
+ CommandWriter mWriter;
CommandReader mReader;
+
+ bool mIsInVrMode = false;
};
} // namespace Hwc2
diff --git a/services/surfaceflinger/DisplayHardware/HWC2.cpp b/services/surfaceflinger/DisplayHardware/HWC2.cpp
index c89ca83..6ff5ea1 100644
--- a/services/surfaceflinger/DisplayHardware/HWC2.cpp
+++ b/services/surfaceflinger/DisplayHardware/HWC2.cpp
@@ -1424,4 +1424,16 @@
return static_cast<Error>(intError);
}
+Error Layer::setInfo(uint32_t type, uint32_t appId)
+{
+#ifdef BYPASS_IHWC
+ (void)type;
+ (void)appId;
+ int32_t intError = 0;
+#else
+ auto intError = mDevice.mComposer->setLayerInfo(mDisplayId, mId, type, appId);
+#endif
+ return static_cast<Error>(intError);
+}
+
} // namespace HWC2
diff --git a/services/surfaceflinger/DisplayHardware/HWC2.h b/services/surfaceflinger/DisplayHardware/HWC2.h
index 5b894ba..256b05d 100644
--- a/services/surfaceflinger/DisplayHardware/HWC2.h
+++ b/services/surfaceflinger/DisplayHardware/HWC2.h
@@ -405,6 +405,7 @@
[[clang::warn_unused_result]] Error setVisibleRegion(
const android::Region& region);
[[clang::warn_unused_result]] Error setZOrder(uint32_t z);
+ [[clang::warn_unused_result]] Error setInfo(uint32_t type, uint32_t appId);
private:
std::weak_ptr<Display> mDisplay;
diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp
index b388448..e57c19a 100644
--- a/services/surfaceflinger/Layer.cpp
+++ b/services/surfaceflinger/Layer.cpp
@@ -140,6 +140,8 @@
mCurrentState.sequence = 0;
mCurrentState.requested = mCurrentState.active;
mCurrentState.dataSpace = HAL_DATASPACE_UNKNOWN;
+ mCurrentState.appId = 0;
+ mCurrentState.type = 0;
// drawing state & current state are identical
mDrawingState = mCurrentState;
@@ -160,7 +162,7 @@
sp<IGraphicBufferProducer> producer;
sp<IGraphicBufferConsumer> consumer;
BufferQueue::createBufferQueue(&producer, &consumer, nullptr, true);
- mProducer = new MonitoredProducer(producer, mFlinger);
+ mProducer = new MonitoredProducer(producer, mFlinger, this);
mSurfaceFlingerConsumer = new SurfaceFlingerConsumer(consumer, mTextureName, this);
mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0));
mSurfaceFlingerConsumer->setContentsChangedListener(this);
@@ -280,6 +282,9 @@
// it's removed from the drawing state list)
void Layer::onRemoved() {
mSurfaceFlingerConsumer->abandon();
+ for (const auto& child : mCurrentChildren) {
+ child->onRemoved();
+ }
}
// ---------------------------------------------------------------------------
@@ -362,6 +367,40 @@
return Region(win).subtract(exclude).getBounds();
}
+Rect Layer::computeScreenBounds(bool reduceTransparentRegion) const {
+ const Layer::State& s(getDrawingState());
+ Rect win(s.active.w, s.active.h);
+
+ if (!s.crop.isEmpty()) {
+ win.intersect(s.crop, &win);
+ }
+
+ Transform t = getTransform();
+ win = t.transform(win);
+
+ const sp<Layer>& p = getParent();
+ // Now we need to calculate the parent bounds, so we can clip ourselves to those.
+ // When calculating the parent bounds for purposes of clipping,
+ // we don't need to constrain the parent to its transparent region.
+ // The transparent region is an optimization based on the
+ // buffer contents of the layer, but does not affect the space allocated to
+ // it by policy, and thus children should be allowed to extend into the
+ // parent's transparent region. In fact one of the main uses, is to reduce
+ // buffer allocation size in cases where a child window sits behind a main window
+ // (by marking the hole in the parent window as a transparent region)
+ if (p != nullptr) {
+ Rect bounds = p->computeScreenBounds(false);
+ bounds.intersect(win, &win);
+ }
+
+ if (reduceTransparentRegion) {
+ auto const screenTransparentRegion = t.transform(s.activeTransparentRegion);
+ win = reduce(win, screenTransparentRegion);
+ }
+
+ return win;
+}
+
Rect Layer::computeBounds() const {
const Layer::State& s(getDrawingState());
return computeBounds(s.activeTransparentRegion);
@@ -374,15 +413,25 @@
if (!s.crop.isEmpty()) {
win.intersect(s.crop, &win);
}
+
+ Rect bounds = win;
+ const auto& p = getParent();
+ if (p != nullptr) {
+ bounds = p->computeScreenBounds();
+ }
+
+ Transform t = getTransform();
+ if (p != nullptr) {
+ win = t.transform(win);
+ win.intersect(bounds, &win);
+ win = t.inverse().transform(win);
+ }
+
// subtract the transparent region and snap to the bounds
return reduce(win, activeTransparentRegion);
}
-gfx::FloatRect Layer::computeCrop(const sp<const DisplayDevice>& hw) const {
- // the content crop is the area of the content that gets scaled to the
- // layer's size.
- gfx::FloatRect crop = getContentCrop().toFloatRect();
-
+Rect Layer::computeInitialCrop(const sp<const DisplayDevice>& hw) const {
// the crop is the area of the window that gets cropped, but not
// scaled in any ways.
const State& s(getDrawingState());
@@ -399,7 +448,8 @@
activeCrop = s.crop;
}
- activeCrop = s.active.transform.transform(activeCrop);
+ Transform t = getTransform();
+ activeCrop = t.transform(activeCrop);
if (!activeCrop.intersect(hw->getViewport(), &activeCrop)) {
activeCrop.clear();
}
@@ -408,7 +458,27 @@
activeCrop.clear();
}
}
- activeCrop = s.active.transform.inverse().transform(activeCrop);
+ return activeCrop;
+}
+
+gfx::FloatRect Layer::computeCrop(const sp<const DisplayDevice>& hw) const {
+ // the content crop is the area of the content that gets scaled to the
+ // layer's size. This is in buffer space.
+ gfx::FloatRect crop = getContentCrop().toFloatRect();
+
+ // In addition there is a WM-specified crop we pull from our drawing state.
+ const State& s(getDrawingState());
+
+ // Screen space to make reduction to parent crop clearer.
+ Rect activeCrop = computeInitialCrop(hw);
+ const auto& p = getParent();
+ if (p != nullptr) {
+ auto parentCrop = p->computeInitialCrop(hw);
+ activeCrop.intersect(parentCrop, &activeCrop);
+ }
+ Transform t = getTransform();
+ // Back to layer space to work with the content crop.
+ activeCrop = t.inverse().transform(activeCrop);
// This needs to be here as transform.transform(Rect) computes the
// transformed rect and then takes the bounding box of the result before
@@ -482,7 +552,7 @@
}
#ifdef USE_HWC2
-void Layer::setGeometry(const sp<const DisplayDevice>& displayDevice)
+void Layer::setGeometry(const sp<const DisplayDevice>& displayDevice, uint32_t z)
#else
void Layer::setGeometry(
const sp<const DisplayDevice>& hw,
@@ -535,9 +605,10 @@
// apply the layer's transform, followed by the display's global transform
// here we're guaranteed that the layer's transform preserves rects
Region activeTransparentRegion(s.activeTransparentRegion);
+ Transform t = getTransform();
if (!s.crop.isEmpty()) {
Rect activeCrop(s.crop);
- activeCrop = s.active.transform.transform(activeCrop);
+ activeCrop = t.transform(activeCrop);
#ifdef USE_HWC2
if(!activeCrop.intersect(displayDevice->getViewport(), &activeCrop)) {
#else
@@ -545,7 +616,7 @@
#endif
activeCrop.clear();
}
- activeCrop = s.active.transform.inverse().transform(activeCrop, true);
+ activeCrop = t.inverse().transform(activeCrop, true);
// This needs to be here as transform.transform(Rect) computes the
// transformed rect and then takes the bounding box of the result before
// returning. This means
@@ -564,7 +635,8 @@
activeTransparentRegion.orSelf(Rect(activeCrop.right, activeCrop.top,
s.active.w, activeCrop.bottom));
}
- Rect frame(s.active.transform.transform(computeBounds(activeTransparentRegion)));
+
+ Rect frame(t.transform(computeBounds(activeTransparentRegion)));
if (!s.finalCrop.isEmpty()) {
if(!frame.intersect(s.finalCrop, &frame)) {
frame.clear();
@@ -602,10 +674,14 @@
"%s (%d)", mName.string(), s.alpha, to_string(error).c_str(),
static_cast<int32_t>(error));
- error = hwcLayer->setZOrder(s.z);
+ error = hwcLayer->setZOrder(z);
ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set Z %u: %s (%d)",
- mName.string(), s.z, to_string(error).c_str(),
+ mName.string(), z, to_string(error).c_str(),
static_cast<int32_t>(error));
+
+ error = hwcLayer->setInfo(s.type, s.appId);
+ ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set info (%d)",
+ mName.string(), static_cast<int32_t>(error));
#else
if (!frame.intersect(hw->getViewport(), &frame)) {
frame.clear();
@@ -625,7 +701,7 @@
*/
const Transform bufferOrientation(mCurrentTransform);
- Transform transform(tr * s.active.transform * bufferOrientation);
+ Transform transform(tr * t * bufferOrientation);
if (mSurfaceFlingerConsumer->getTransformToDisplayInverse()) {
/*
@@ -811,7 +887,7 @@
}
// Subtract the transparent region and snap to the bounds
Rect bounds = reduce(win, s.activeTransparentRegion);
- Rect frame(s.active.transform.transform(bounds));
+ Rect frame(getTransform().transform(bounds));
frame.intersect(displayDevice->getViewport(), &frame);
if (!s.finalCrop.isEmpty()) {
frame.intersect(s.finalCrop, &frame);
@@ -860,7 +936,7 @@
}
// subtract the transparent region and snap to the bounds
Rect bounds = reduce(win, s.activeTransparentRegion);
- Rect frame(s.active.transform.transform(bounds));
+ Rect frame(getTransform().transform(bounds));
frame.intersect(hw->getViewport(), &frame);
if (!s.finalCrop.isEmpty()) {
frame.intersect(s.finalCrop, &frame);
@@ -903,15 +979,14 @@
// figure out if there is something below us
Region under;
- const SurfaceFlinger::LayerVector& drawingLayers(
- mFlinger->mDrawingState.layersSortedByZ);
- const size_t count = drawingLayers.size();
- for (size_t i=0 ; i<count ; ++i) {
- const sp<Layer>& layer(drawingLayers[i]);
- if (layer.get() == static_cast<Layer const*>(this))
- break;
+ bool finished = false;
+ mFlinger->mDrawingState.layersSortedByZ.traverseInZOrder([&](Layer* layer) {
+ if (finished || layer == static_cast<Layer const*>(this)) {
+ finished = true;
+ return;
+ }
under.orSelf( hw->getTransform().transform(layer->visibleRegion) );
- }
+ });
// if not everything below us is covered, we plug the holes!
Region holes(clip.subtract(under));
if (!holes.isEmpty()) {
@@ -1023,12 +1098,13 @@
*/
Rect win(computeBounds());
+ Transform t = getTransform();
if (!s.finalCrop.isEmpty()) {
- win = s.active.transform.transform(win);
+ win = t.transform(win);
if (!win.intersect(s.finalCrop, &win)) {
win.clear();
}
- win = s.active.transform.inverse().transform(win);
+ win = t.inverse().transform(win);
if (!win.intersect(computeBounds(), &win)) {
win.clear();
}
@@ -1228,25 +1304,21 @@
bool useIdentityTransform) const
{
const Layer::State& s(getDrawingState());
- const Transform tr(hw->getTransform());
+ const Transform hwTransform(hw->getTransform());
const uint32_t hw_h = hw->getHeight();
- Rect win(s.active.w, s.active.h);
- if (!s.crop.isEmpty()) {
- win.intersect(s.crop, &win);
- }
- // subtract the transparent region and snap to the bounds
- win = reduce(win, s.activeTransparentRegion);
+ Rect win = computeBounds();
vec2 lt = vec2(win.left, win.top);
vec2 lb = vec2(win.left, win.bottom);
vec2 rb = vec2(win.right, win.bottom);
vec2 rt = vec2(win.right, win.top);
+ Transform layerTransform = getTransform();
if (!useIdentityTransform) {
- lt = s.active.transform.transform(lt);
- lb = s.active.transform.transform(lb);
- rb = s.active.transform.transform(rb);
- rt = s.active.transform.transform(rt);
+ lt = layerTransform.transform(lt);
+ lb = layerTransform.transform(lb);
+ rb = layerTransform.transform(rb);
+ rt = layerTransform.transform(rt);
}
if (!s.finalCrop.isEmpty()) {
@@ -1257,10 +1329,10 @@
}
Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>());
- position[0] = tr.transform(lt);
- position[1] = tr.transform(lb);
- position[2] = tr.transform(rb);
- position[3] = tr.transform(rt);
+ position[0] = hwTransform.transform(lt);
+ position[1] = hwTransform.transform(lb);
+ position[2] = hwTransform.transform(rb);
+ position[3] = hwTransform.transform(rt);
for (size_t i=0 ; i<4 ; i++) {
position[i].y = hw_h - position[i].y;
}
@@ -1542,11 +1614,7 @@
// that transactions for layers depending on this layer's frames becoming
// visible are not blocked
if (c.flags & layer_state_t::eLayerHidden) {
- Mutex::Autolock lock(mLocalSyncPointMutex);
- for (auto& point : mLocalSyncPoints) {
- point->setFrameAvailable();
- }
- mLocalSyncPoints.clear();
+ clearSyncPoints();
}
// Commit the transaction
@@ -1585,7 +1653,19 @@
return true;
}
-bool Layer::setLayer(uint32_t z) {
+bool Layer::setChildLayer(const sp<Layer>& childLayer, int32_t z) {
+ ssize_t idx = mCurrentChildren.indexOf(childLayer);
+ if (idx < 0) {
+ return false;
+ }
+ if (childLayer->setLayer(z)) {
+ mCurrentChildren.removeAt(idx);
+ mCurrentChildren.add(childLayer);
+ }
+ return true;
+}
+
+bool Layer::setLayer(int32_t z) {
if (mCurrentState.z == z)
return false;
mCurrentState.sequence++;
@@ -1594,6 +1674,7 @@
setTransactionFlags(eTransactionNeeded);
return true;
}
+
bool Layer::setSize(uint32_t w, uint32_t h) {
if (mCurrentState.requested.w == w && mCurrentState.requested.h == h)
return false;
@@ -1672,6 +1753,13 @@
return true;
}
+void Layer::setInfo(uint32_t type, uint32_t appId) {
+ mCurrentState.appId = appId;
+ mCurrentState.type = type;
+ mCurrentState.modified = true;
+ setTransactionFlags(eTransactionNeeded);
+}
+
uint32_t Layer::getEffectiveScalingMode() const {
if (mOverrideScalingMode >= 0) {
return mOverrideScalingMode;
@@ -1699,6 +1787,14 @@
return true;
}
+uint32_t Layer::getLayerStack() const {
+ auto p = getParent();
+ if (p == nullptr) {
+ return getDrawingState().layerStack;
+ }
+ return p->getLayerStack();
+}
+
void Layer::deferTransactionUntil(const sp<IBinder>& handle,
uint64_t frameNumber) {
mCurrentState.handle = handle;
@@ -1827,13 +1923,22 @@
}
#endif
+bool Layer::isHiddenByPolicy() const {
+ const Layer::State& s(mDrawingState);
+ const auto& parent = getParent();
+ if (parent != nullptr && parent->isHiddenByPolicy()) {
+ return true;
+ }
+ return s.flags & layer_state_t::eLayerHidden;
+}
+
bool Layer::isVisible() const {
const Layer::State& s(mDrawingState);
#ifdef USE_HWC2
- return !(s.flags & layer_state_t::eLayerHidden) && s.alpha > 0.0f
+ return !(isHiddenByPolicy()) && s.alpha > 0.0f
&& (mActiveBuffer != NULL || mSidebandStream != NULL);
#else
- return !(s.flags & layer_state_t::eLayerHidden) && s.alpha
+ return !(isHiddenByPolicy()) && s.alpha
&& (mActiveBuffer != NULL || mSidebandStream != NULL);
#endif
}
@@ -1878,7 +1983,7 @@
recomputeVisibleRegions = true;
const State& s(getDrawingState());
- return s.active.transform.transform(Region(Rect(s.active.w, s.active.h)));
+ return getTransform().transform(Region(Rect(s.active.w, s.active.h)));
}
Region outDirtyRegion;
@@ -2067,7 +2172,7 @@
Region dirtyRegion(Rect(s.active.w, s.active.h));
// transform the dirty region to window-manager space
- outDirtyRegion = (s.active.transform.transform(dirtyRegion));
+ outDirtyRegion = (getTransform().transform(dirtyRegion));
return outDirtyRegion;
}
@@ -2130,7 +2235,9 @@
"alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n"
#endif
" client=%p\n",
- s.layerStack, s.z, s.active.transform.tx(), s.active.transform.ty(), s.active.w, s.active.h,
+ getLayerStack(), s.z,
+ s.active.transform.tx(), s.active.transform.ty(),
+ s.active.w, s.active.h,
s.crop.left, s.crop.top,
s.crop.right, s.crop.bottom,
s.finalCrop.left, s.finalCrop.top,
@@ -2263,6 +2370,116 @@
return mSurfaceFlingerConsumer->getTransformToDisplayInverse();
}
+void Layer::addChild(const sp<Layer>& layer) {
+ mCurrentChildren.add(layer);
+ layer->setParent(this);
+}
+
+ssize_t Layer::removeChild(const sp<Layer>& layer) {
+ layer->setParent(nullptr);
+ return mCurrentChildren.remove(layer);
+}
+
+bool Layer::reparentChildren(const sp<IBinder>& newParentHandle) {
+ sp<Handle> handle = nullptr;
+ sp<Layer> newParent = nullptr;
+ if (newParentHandle == nullptr) {
+ return false;
+ }
+ handle = static_cast<Handle*>(newParentHandle.get());
+ newParent = handle->owner.promote();
+ if (newParent == nullptr) {
+ ALOGE("Unable to promote Layer handle");
+ return false;
+ }
+
+ for (const sp<Layer>& child : mCurrentChildren) {
+ newParent->addChild(child);
+
+ sp<Client> client(child->mClientRef.promote());
+ if (client != nullptr) {
+ client->setParentLayer(newParent);
+ }
+ }
+ mCurrentChildren.clear();
+
+ return true;
+}
+
+void Layer::setParent(const sp<Layer>& layer) {
+ mParent = layer;
+}
+
+void Layer::clearSyncPoints() {
+ for (const auto& child : mCurrentChildren) {
+ child->clearSyncPoints();
+ }
+
+ Mutex::Autolock lock(mLocalSyncPointMutex);
+ for (auto& point : mLocalSyncPoints) {
+ point->setFrameAvailable();
+ }
+ mLocalSyncPoints.clear();
+}
+
+int32_t Layer::getZ() const {
+ return mDrawingState.z;
+}
+
+/**
+ * Negatively signed children are before 'this' in Z-order.
+ */
+void Layer::traverseInZOrder(const std::function<void(Layer*)>& exec) {
+ size_t i = 0;
+ for (; i < mDrawingChildren.size(); i++) {
+ const auto& child = mDrawingChildren[i];
+ if (child->getZ() >= 0)
+ break;
+ child->traverseInZOrder(exec);
+ }
+ exec(this);
+ for (; i < mDrawingChildren.size(); i++) {
+ const auto& child = mDrawingChildren[i];
+ child->traverseInZOrder(exec);
+ }
+}
+
+/**
+ * Positively signed children are before 'this' in reverse Z-order.
+ */
+void Layer::traverseInReverseZOrder(const std::function<void(Layer*)>& exec) {
+ int32_t i = 0;
+ for (i = mDrawingChildren.size()-1; i>=0; i--) {
+ const auto& child = mDrawingChildren[i];
+ if (child->getZ() < 0) {
+ break;
+ }
+ child->traverseInReverseZOrder(exec);
+ }
+ exec(this);
+ for (; i>=0; i--) {
+ const auto& child = mDrawingChildren[i];
+ child->traverseInReverseZOrder(exec);
+ }
+}
+
+Transform Layer::getTransform() const {
+ Transform t;
+ const auto& p = getParent();
+ if (p != nullptr) {
+ t = p->getTransform();
+ }
+ return t * getDrawingState().active.transform;
+}
+
+void Layer::commitChildList() {
+ for (size_t i = 0; i < mCurrentChildren.size(); i++) {
+ const auto& child = mCurrentChildren[i];
+ child->commitChildList();
+ }
+ mDrawingChildren = mCurrentChildren;
+}
+
// ---------------------------------------------------------------------------
}; // namespace android
diff --git a/services/surfaceflinger/Layer.h b/services/surfaceflinger/Layer.h
index 1654a51..7335be7 100644
--- a/services/surfaceflinger/Layer.h
+++ b/services/surfaceflinger/Layer.h
@@ -42,6 +42,7 @@
#include "FrameTracker.h"
#include "Client.h"
+#include "LayerVector.h"
#include "MonitoredProducer.h"
#include "SurfaceFlinger.h"
#include "SurfaceFlingerConsumer.h"
@@ -109,7 +110,7 @@
struct State {
Geometry active;
Geometry requested;
- uint32_t z;
+ int32_t z;
uint32_t layerStack;
#ifdef USE_HWC2
float alpha;
@@ -140,6 +141,9 @@
Region activeTransparentRegion;
Region requestedTransparentRegion;
android_dataspace dataSpace;
+
+ uint32_t appId;
+ uint32_t type;
};
// -----------------------------------------------------------------------
@@ -154,7 +158,7 @@
// modify current state
bool setPosition(float x, float y, bool immediate);
- bool setLayer(uint32_t z);
+ bool setLayer(int32_t z);
bool setSize(uint32_t w, uint32_t h);
#ifdef USE_HWC2
bool setAlpha(float alpha);
@@ -168,8 +172,11 @@
bool setFinalCrop(const Rect& crop);
bool setLayerStack(uint32_t layerStack);
bool setDataSpace(android_dataspace dataSpace);
+ uint32_t getLayerStack() const;
void deferTransactionUntil(const sp<IBinder>& handle, uint64_t frameNumber);
bool setOverrideScalingMode(int32_t overrideScalingMode);
+ void setInfo(uint32_t type, uint32_t appId);
+ bool reparentChildren(const sp<IBinder>& layer);
// If we have received a new buffer this frame, we will pass its surface
// damage down to hardware composer. Otherwise, we must send a region with
@@ -219,6 +226,14 @@
virtual bool isVisible() const;
/*
+ * isHiddenByPolicy - true if this layer has been forced invisible.
+ * just because this is false, doesn't mean isVisible() is true.
+ * For example if this layer has no active buffer, it may not be hidden by
+ * policy, but it still can not be visible.
+ */
+ virtual bool isHiddenByPolicy() const;
+
+ /*
* isFixedSize - true if content has a fixed size
*/
virtual bool isFixedSize() const;
@@ -234,7 +249,7 @@
// -----------------------------------------------------------------------
#ifdef USE_HWC2
- void setGeometry(const sp<const DisplayDevice>& displayDevice);
+ void setGeometry(const sp<const DisplayDevice>& displayDevice, uint32_t z);
void forceClientComposition(int32_t hwcId);
void setPerFrameData(const sp<const DisplayDevice>& displayDevice);
@@ -422,6 +437,26 @@
bool getTransformToDisplayInverse() const;
+ Transform getTransform() const;
+
+ void traverseInReverseZOrder(const std::function<void(Layer*)>& exec);
+ void traverseInZOrder(const std::function<void(Layer*)>& exec);
+
+ void addChild(const sp<Layer>& layer);
+ // Returns index if removed, or negative value otherwise
+ // for symmetry with Vector::remove
+ ssize_t removeChild(const sp<Layer>& layer);
+ sp<Layer> getParent() const { return mParent.promote(); }
+ bool hasParent() const { return getParent() != nullptr; }
+
+ Rect computeScreenBounds(bool reduceTransparentRegion = true) const;
+ bool setChildLayer(const sp<Layer>& childLayer, int32_t z);
+
+ // Copy the current list of children to the drawing state. Called by
+ // SurfaceFlinger to complete a transaction.
+ void commitChildList();
+
+ int32_t getZ() const;
protected:
// constant
sp<SurfaceFlinger> mFlinger;
@@ -462,7 +497,12 @@
bool needsFiltering(const sp<const DisplayDevice>& hw) const;
uint32_t getEffectiveUsage(uint32_t usage) const;
+
gfx::FloatRect computeCrop(const sp<const DisplayDevice>& hw) const;
+ // Compute the initial crop as specified by parent layers and the SurfaceControl
+ // for this layer. Does not include buffer crop from the IGraphicBufferProducer
+ // client, as that should not affect child clipping. Returns in screen space.
+ Rect computeInitialCrop(const sp<const DisplayDevice>& hw) const;
bool isCropped() const;
static bool getOpacityForFormat(uint32_t format);
@@ -478,6 +518,8 @@
// Loads the corresponding system property once per process
static bool latchUnsignaledBuffers();
+ void setParent(const sp<Layer>& layer);
+
// -----------------------------------------------------------------------
class SyncPoint
@@ -532,6 +574,8 @@
void popPendingState(State* stateToCommit);
bool applyPendingStates(State* stateToCommit);
+ void clearSyncPoints();
+
// Returns mCurrentScaling mode (originating from the
// Client) or mOverrideScalingMode mode (originating from
// the Surface Controller) if set.
@@ -662,6 +706,13 @@
bool mAutoRefresh;
bool mFreezePositionUpdates;
+
+ // Child list about to be committed/used for editing.
+ LayerVector mCurrentChildren;
+ // Child list used for rendering.
+ LayerVector mDrawingChildren;
+
+ wp<Layer> mParent;
};
// ---------------------------------------------------------------------------
diff --git a/services/surfaceflinger/LayerDim.cpp b/services/surfaceflinger/LayerDim.cpp
index 4d5b3db..daebf8a 100644
--- a/services/surfaceflinger/LayerDim.cpp
+++ b/services/surfaceflinger/LayerDim.cpp
@@ -59,7 +59,7 @@
bool LayerDim::isVisible() const {
const Layer::State& s(getDrawingState());
- return !(s.flags & layer_state_t::eLayerHidden) && s.alpha;
+ return !isHiddenByPolicy() && s.alpha;
}
diff --git a/services/surfaceflinger/LayerVector.cpp b/services/surfaceflinger/LayerVector.cpp
new file mode 100644
index 0000000..7ba6ad3
--- /dev/null
+++ b/services/surfaceflinger/LayerVector.cpp
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2016 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 "LayerVector.h"
+#include "Layer.h"
+
+namespace android {
+LayerVector::LayerVector(const LayerVector& rhs) : SortedVector<sp<Layer>>(rhs) {
+}
+
+int LayerVector::do_compare(const void* lhs, const void* rhs) const
+{
+ // sort layers per layer-stack, then by z-order and finally by sequence
+ const auto& l = *reinterpret_cast<const sp<Layer>*>(lhs);
+ const auto& r = *reinterpret_cast<const sp<Layer>*>(rhs);
+
+ uint32_t ls = l->getCurrentState().layerStack;
+ uint32_t rs = r->getCurrentState().layerStack;
+ if (ls != rs)
+ return ls - rs;
+
+ uint32_t lz = l->getCurrentState().z;
+ uint32_t rz = r->getCurrentState().z;
+ if (lz != rz)
+ return lz - rz;
+
+ return l->sequence - r->sequence;
+}
+
+void LayerVector::traverseInZOrder(const std::function<void(Layer*)>& consume) const {
+ for (size_t i = 0; i < size(); i++) {
+ (*this)[i]->traverseInZOrder(consume);
+ }
+}
+
+void LayerVector::traverseInReverseZOrder(const std::function<void(Layer*)>& consume) const {
+ for (auto i = static_cast<int64_t>(size()) - 1; i >= 0; i--) {
+ (*this)[i]->traverseInReverseZOrder(consume);
+ }
+}
+} // namespace android
diff --git a/services/surfaceflinger/LayerVector.h b/services/surfaceflinger/LayerVector.h
new file mode 100644
index 0000000..7dfa4a0
--- /dev/null
+++ b/services/surfaceflinger/LayerVector.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+#ifndef ANDROID_SURFACE_FLINGER_LAYER_VECTOR_H
+#define ANDROID_SURFACE_FLINGER_LAYER_VECTOR_H
+
+#include <utils/SortedVector.h>
+#include <utils/RefBase.h>
+
+#include <functional>
+
+namespace android {
+class Layer;
+
+/*
+ * Used by the top-level SurfaceFlinger state and individual layers
+ * to track layers they own sorted according to Z-order. Provides traversal
+ * functions for traversing all owned layers, and their descendents.
+ */
+class LayerVector : public SortedVector<sp<Layer>> {
+public:
+ LayerVector() = default;
+ LayerVector(const LayerVector& rhs);
+ // Sorts layer by layer-stack, Z order, and finally creation order (sequence).
+ int do_compare(const void* lhs, const void* rhs) const override;
+
+ void traverseInReverseZOrder(const std::function<void(Layer*)>& consume) const;
+ void traverseInZOrder(const std::function<void(Layer*)>& consume) const;
+};
+}
+
+#endif /* ANDROID_SURFACE_FLINGER_LAYER_VECTOR_H_ */
diff --git a/services/surfaceflinger/MonitoredProducer.cpp b/services/surfaceflinger/MonitoredProducer.cpp
index 8bf6e82..2ba1b33 100644
--- a/services/surfaceflinger/MonitoredProducer.cpp
+++ b/services/surfaceflinger/MonitoredProducer.cpp
@@ -17,13 +17,16 @@
#include "MessageQueue.h"
#include "MonitoredProducer.h"
#include "SurfaceFlinger.h"
+#include "Layer.h"
namespace android {
MonitoredProducer::MonitoredProducer(const sp<IGraphicBufferProducer>& producer,
- const sp<SurfaceFlinger>& flinger) :
+ const sp<SurfaceFlinger>& flinger,
+ const wp<Layer>& layer) :
mProducer(producer),
- mFlinger(flinger) {}
+ mFlinger(flinger),
+ mLayer(layer) {}
MonitoredProducer::~MonitoredProducer() {
// Remove ourselves from SurfaceFlinger's list. We do this asynchronously
@@ -159,5 +162,9 @@
return this;
}
+sp<Layer> MonitoredProducer::getLayer() const {
+ return mLayer.promote();
+}
+
// ---------------------------------------------------------------------------
}; // namespace android
diff --git a/services/surfaceflinger/MonitoredProducer.h b/services/surfaceflinger/MonitoredProducer.h
index becc740..a3ec29d 100644
--- a/services/surfaceflinger/MonitoredProducer.h
+++ b/services/surfaceflinger/MonitoredProducer.h
@@ -24,13 +24,15 @@
class IProducerListener;
class NativeHandle;
class SurfaceFlinger;
+class Layer;
// MonitoredProducer wraps an IGraphicBufferProducer so that SurfaceFlinger will
// be notified upon its destruction
class MonitoredProducer : public BnGraphicBufferProducer {
public:
MonitoredProducer(const sp<IGraphicBufferProducer>& producer,
- const sp<SurfaceFlinger>& flinger);
+ const sp<SurfaceFlinger>& flinger,
+ const wp<Layer>& layer);
virtual ~MonitoredProducer();
// From IGraphicBufferProducer
@@ -67,9 +69,14 @@
virtual void getFrameTimestamps(FrameEventHistoryDelta *outDelta) override;
virtual status_t getUniqueId(uint64_t* outId) const override;
+ // The Layer which created this producer, and on which queued Buffer's will be displayed.
+ sp<Layer> getLayer() const;
+
private:
sp<IGraphicBufferProducer> mProducer;
sp<SurfaceFlinger> mFlinger;
+ // The Layer which created this producer, and on which queued Buffer's will be displayed.
+ wp<Layer> mLayer;
};
}; // namespace android
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index 5f25ef5..8cc8e31 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -69,7 +69,9 @@
#include "EventControlThread.h"
#include "EventThread.h"
#include "Layer.h"
+#include "LayerVector.h"
#include "LayerDim.h"
+#include "MonitoredProducer.h"
#include "SurfaceFlinger.h"
#include "DisplayHardware/FramebufferSurface.h"
@@ -133,6 +135,7 @@
mTransactionPending(false),
mAnimTransactionPending(false),
mLayersRemoved(false),
+ mLayersAdded(false),
mRepaintEverything(0),
mRenderEngine(NULL),
mBootTime(systemTime()),
@@ -158,7 +161,8 @@
mHasPoweredOff(false),
mFrameBuckets(),
mTotalTime(0),
- mLastSwapTime(0)
+ mLastSwapTime(0),
+ mNumLayers(0)
{
ALOGI("SurfaceFlinger is starting");
@@ -218,15 +222,29 @@
startBootAnim();
}
-sp<ISurfaceComposerClient> SurfaceFlinger::createConnection()
-{
- sp<ISurfaceComposerClient> bclient;
- sp<Client> client(new Client(this));
+static sp<ISurfaceComposerClient> initClient(const sp<Client>& client) {
status_t err = client->initCheck();
if (err == NO_ERROR) {
- bclient = client;
+ return client;
}
- return bclient;
+ return nullptr;
+}
+
+sp<ISurfaceComposerClient> SurfaceFlinger::createConnection() {
+ return initClient(new Client(this));
+}
+
+sp<ISurfaceComposerClient> SurfaceFlinger::createScopedConnection(
+ const sp<IGraphicBufferProducer>& gbp) {
+ if (authenticateSurfaceTexture(gbp) == false) {
+ return nullptr;
+ }
+ const auto& layer = (static_cast<MonitoredProducer*>(gbp.get()))->getLayer();
+ if (layer == nullptr) {
+ return nullptr;
+ }
+
+ return initClient(new Client(this, layer));
}
sp<IBinder> SurfaceFlinger::createDisplay(const String8& displayName,
@@ -1211,13 +1229,12 @@
ALOGV("preComposition");
bool needExtraInvalidate = false;
- const LayerVector& layers(mDrawingState.layersSortedByZ);
- const size_t count = layers.size();
- for (size_t i=0 ; i<count ; i++) {
- if (layers[i]->onPreComposition(refreshStartTime)) {
+ mDrawingState.traverseInZOrder([&](Layer* layer) {
+ if (layer->onPreComposition(refreshStartTime)) {
needExtraInvalidate = true;
}
- }
+ });
+
if (needExtraInvalidate) {
signalLayerUpdate();
}
@@ -1258,18 +1275,14 @@
} else {
retireFenceTime = &displayFenceTime;
}
-
- const LayerVector& layers(mDrawingState.layersSortedByZ);
- const size_t count = layers.size();
- for (size_t i=0 ; i<count ; i++) {
- bool frameLatched =
- layers[i]->onPostComposition(glCompositionDoneFenceTime,
- *presentFenceTime, *retireFenceTime);
+ mDrawingState.traverseInZOrder([&](Layer* layer) {
+ bool frameLatched = layer->onPostComposition(glCompositionDoneFenceTime,
+ *presentFenceTime, *retireFenceTime);
if (frameLatched) {
- recordBufferingStats(layers[i]->getName().string(),
- layers[i]->getOccupancyHistory(false));
+ recordBufferingStats(layer->getName().string(),
+ layer->getOccupancyHistory(false));
}
- }
+ });
if (displayFence->isValid()) {
if (mPrimaryDispSync.addPresentFence(displayFence)) {
@@ -1332,7 +1345,6 @@
mVisibleRegionsDirty = false;
invalidateHwcGeometry();
- const LayerVector& layers(mDrawingState.layersSortedByZ);
for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
Region opaqueRegion;
Region dirtyRegion;
@@ -1341,15 +1353,12 @@
const Transform& tr(displayDevice->getTransform());
const Rect bounds(displayDevice->getBounds());
if (displayDevice->isDisplayOn()) {
- SurfaceFlinger::computeVisibleRegions(layers,
+ computeVisibleRegions(
displayDevice->getLayerStack(), dirtyRegion,
opaqueRegion);
- const size_t count = layers.size();
- for (size_t i=0 ; i<count ; i++) {
- const sp<Layer>& layer(layers[i]);
- const Layer::State& s(layer->getDrawingState());
- if (s.layerStack == displayDevice->getLayerStack()) {
+ mDrawingState.traverseInZOrder([&](Layer* layer) {
+ if (layer->getLayerStack() == displayDevice->getLayerStack()) {
Region drawRegion(tr.transform(
layer->visibleNonTransparentRegion));
drawRegion.andSelf(bounds);
@@ -1362,7 +1371,7 @@
nullptr);
}
}
- }
+ });
}
displayDevice->setVisibleLayersSortedByZ(layersSortedByZ);
displayDevice->undefinedRegion.set(bounds);
@@ -1416,7 +1425,8 @@
const Vector<sp<Layer>>& currentLayers(
displayDevice->getVisibleLayersSortedByZ());
bool foundLayerWithoutHwc = false;
- for (auto& layer : currentLayers) {
+ for (size_t i = 0; i < currentLayers.size(); i++) {
+ const auto& layer = currentLayers[i];
if (!layer->hasHwcLayer(hwcId)) {
auto hwcLayer = mHwc->createLayer(hwcId);
if (hwcLayer) {
@@ -1428,7 +1438,7 @@
}
}
- layer->setGeometry(displayDevice);
+ layer->setGeometry(displayDevice, i);
if (mDebugDisableHWC || mDebugRegion) {
layer->forceClientComposition(hwcId);
}
@@ -1567,13 +1577,10 @@
void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)
{
- const LayerVector& currentLayers(mCurrentState.layersSortedByZ);
- const size_t count = currentLayers.size();
-
// Notify all layers of available frames
- for (size_t i = 0; i < count; ++i) {
- currentLayers[i]->notifyAvailableFrames();
- }
+ mCurrentState.traverseInZOrder([](Layer* layer) {
+ layer->notifyAvailableFrames();
+ });
/*
* Traversal of the children
@@ -1581,15 +1588,14 @@
*/
if (transactionFlags & eTraversalNeeded) {
- for (size_t i=0 ; i<count ; i++) {
- const sp<Layer>& layer(currentLayers[i]);
+ mCurrentState.traverseInZOrder([&](Layer* layer) {
uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
- if (!trFlags) continue;
+ if (!trFlags) return;
const uint32_t flags = layer->doTransaction(0);
if (flags & Layer::eVisibleRegion)
mVisibleRegionsDirty = true;
- }
+ });
}
/*
@@ -1782,13 +1788,13 @@
//
sp<const DisplayDevice> disp;
uint32_t currentlayerStack = 0;
- for (size_t i=0; i<count; i++) {
+ bool first = true;
+ mCurrentState.traverseInZOrder([&](Layer* layer) {
// NOTE: we rely on the fact that layers are sorted by
// layerStack first (so we don't have to traverse the list
// of displays for every layer).
- const sp<Layer>& layer(currentLayers[i]);
- uint32_t layerStack = layer->getDrawingState().layerStack;
- if (i==0 || currentlayerStack != layerStack) {
+ uint32_t layerStack = layer->getLayerStack();
+ if (first || currentlayerStack != layerStack) {
currentlayerStack = layerStack;
// figure out if this layerstack is mirrored
// (more than one display) if so, pick the default display,
@@ -1816,7 +1822,9 @@
disp = getDefaultDisplayDevice();
}
layer->updateTransformHint(disp);
- }
+
+ first = false;
+ });
}
@@ -1824,9 +1832,9 @@
* Perform our own transaction if needed
*/
- const LayerVector& layers(mDrawingState.layersSortedByZ);
- if (currentLayers.size() > layers.size()) {
- // layers have been added
+ if (mLayersAdded) {
+ mLayersAdded = false;
+ // Layers have been added.
mVisibleRegionsDirty = true;
}
@@ -1835,20 +1843,17 @@
if (mLayersRemoved) {
mLayersRemoved = false;
mVisibleRegionsDirty = true;
- const size_t count = layers.size();
- for (size_t i=0 ; i<count ; i++) {
- const sp<Layer>& layer(layers[i]);
- if (currentLayers.indexOf(layer) < 0) {
+ mDrawingState.traverseInZOrder([&](Layer* layer) {
+ if (mLayersPendingRemoval.indexOf(layer) >= 0) {
// this layer is not visible anymore
// TODO: we could traverse the tree from front to back and
// compute the actual visible region
// TODO: we could cache the transformed region
- const Layer::State& s(layer->getDrawingState());
- Region visibleReg = s.active.transform.transform(
- Region(Rect(s.active.w, s.active.h)));
- invalidateLayerStack(s.layerStack, visibleReg);
+ Region visibleReg;
+ visibleReg.set(layer->computeScreenBounds());
+ invalidateLayerStack(layer->getLayerStack(), visibleReg);
}
- }
+ });
}
commitTransaction();
@@ -1874,10 +1879,10 @@
{
if (!mLayersPendingRemoval.isEmpty()) {
// Notify removed layers now that they can't be drawn from
- for (size_t i = 0; i < mLayersPendingRemoval.size(); i++) {
- recordBufferingStats(mLayersPendingRemoval[i]->getName().string(),
- mLayersPendingRemoval[i]->getOccupancyHistory(true));
- mLayersPendingRemoval[i]->onRemoved();
+ for (const auto& l : mLayersPendingRemoval) {
+ recordBufferingStats(l->getName().string(),
+ l->getOccupancyHistory(true));
+ l->onRemoved();
}
mLayersPendingRemoval.clear();
}
@@ -1887,13 +1892,15 @@
mAnimCompositionPending = mAnimTransactionPending;
mDrawingState = mCurrentState;
+ mDrawingState.traverseInZOrder([](Layer* layer) {
+ layer->commitChildList();
+ });
mTransactionPending = false;
mAnimTransactionPending = false;
mTransactionCV.broadcast();
}
-void SurfaceFlinger::computeVisibleRegions(
- const LayerVector& currentLayers, uint32_t layerStack,
+void SurfaceFlinger::computeVisibleRegions(uint32_t layerStack,
Region& outDirtyRegion, Region& outOpaqueRegion)
{
ATRACE_CALL();
@@ -1905,16 +1912,13 @@
outDirtyRegion.clear();
- size_t i = currentLayers.size();
- while (i--) {
- const sp<Layer>& layer = currentLayers[i];
-
+ mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
// start with the whole surface at its current location
const Layer::State& s(layer->getDrawingState());
// only consider the layers on the given layer stack
- if (s.layerStack != layerStack)
- continue;
+ if (layer->getLayerStack() != layerStack)
+ return;
/*
* opaqueRegion: area of a surface that is fully opaque.
@@ -1949,12 +1953,12 @@
// handle hidden surfaces by setting the visible region to empty
if (CC_LIKELY(layer->isVisible())) {
const bool translucent = !layer->isOpaque(s);
- Rect bounds(s.active.transform.transform(layer->computeBounds()));
+ Rect bounds(layer->computeScreenBounds());
visibleRegion.set(bounds);
+ Transform tr = layer->getTransform();
if (!visibleRegion.isEmpty()) {
// Remove the transparent area from the visible region
if (translucent) {
- const Transform tr(s.active.transform);
if (tr.preserveRects()) {
// transform the transparent region
transparentRegion = tr.transform(s.activeTransparentRegion);
@@ -1966,7 +1970,7 @@
}
// compute the opaque region
- const int32_t layerOrientation = s.active.transform.getOrientation();
+ const int32_t layerOrientation = tr.getOrientation();
if (s.alpha == 1.0f && !translucent &&
((layerOrientation & Transform::ROT_INVALID) == false)) {
// the opaque region is the layer's footprint
@@ -2023,7 +2027,7 @@
layer->setCoveredRegion(coveredRegion);
layer->setVisibleNonTransparentRegion(
visibleRegion.subtract(transparentRegion));
- }
+ });
outOpaqueRegion = aboveOpaqueLayers;
}
@@ -2045,7 +2049,6 @@
nsecs_t latchTime = systemTime();
bool visibleRegions = false;
- const LayerVector& layers(mDrawingState.layersSortedByZ);
bool frameQueued = false;
// Store the set of layers that need updates. This set must not change as
@@ -2057,24 +2060,23 @@
// 3.) Layer 1 is latched.
// Display is now waiting on Layer 1's frame, which is behind layer 0's
// second frame. But layer 0's second frame could be waiting on display.
- for (size_t i = 0, count = layers.size(); i<count ; i++) {
- const sp<Layer>& layer(layers[i]);
+ mDrawingState.traverseInZOrder([&](Layer* layer) {
if (layer->hasQueuedFrame()) {
frameQueued = true;
if (layer->shouldPresentNow(mPrimaryDispSync)) {
- mLayersWithQueuedFrames.push_back(layer.get());
+ mLayersWithQueuedFrames.push_back(layer);
} else {
layer->useEmptyDamage();
}
} else {
layer->useEmptyDamage();
}
- }
+ });
+
for (auto& layer : mLayersWithQueuedFrames) {
const Region dirty(layer->latchBuffer(visibleRegions, latchTime));
layer->useSurfaceDamage();
- const Layer::State& s(layer->getDrawingState());
- invalidateLayerStack(s.layerStack, dirty);
+ invalidateLayerStack(layer->getLayerStack(), dirty);
}
mVisibleRegionsDirty |= visibleRegions;
@@ -2296,16 +2298,23 @@
status_t SurfaceFlinger::addClientLayer(const sp<Client>& client,
const sp<IBinder>& handle,
const sp<IGraphicBufferProducer>& gbc,
- const sp<Layer>& lbc)
+ const sp<Layer>& lbc,
+ const sp<Layer>& parent)
{
// add this layer to the current state list
{
Mutex::Autolock _l(mStateLock);
- if (mCurrentState.layersSortedByZ.size() >= MAX_LAYERS) {
+ if (mNumLayers >= MAX_LAYERS) {
return NO_MEMORY;
}
- mCurrentState.layersSortedByZ.add(lbc);
+ if (parent == nullptr) {
+ mCurrentState.layersSortedByZ.add(lbc);
+ } else {
+ parent->addChild(lbc);
+ }
mGraphicBufferProducerList.add(IInterface::asBinder(gbc));
+ mLayersAdded = true;
+ mNumLayers++;
}
// attach this layer to the client
@@ -2322,14 +2331,22 @@
return NO_ERROR;
}
- ssize_t index = mCurrentState.layersSortedByZ.remove(layer);
- if (index >= 0) {
- mLayersPendingRemoval.push(layer);
- mLayersRemoved = true;
- setTransactionFlags(eTransactionNeeded);
- return NO_ERROR;
+ const auto& p = layer->getParent();
+ const ssize_t index = (p != nullptr) ? p->removeChild(layer) :
+ mCurrentState.layersSortedByZ.remove(layer);
+
+ if (index < 0) {
+ ALOGE("Failed to find layer (%s) in layer parent (%s).",
+ layer->getName().string(),
+ (p != nullptr) ? p->getName().string() : "no-parent");
+ return BAD_VALUE;
}
- return status_t(index);
+
+ mLayersPendingRemoval.add(layer);
+ mLayersRemoved = true;
+ mNumLayers--;
+ setTransactionFlags(eTransactionNeeded);
+ return NO_ERROR;
}
uint32_t SurfaceFlinger::peekTransactionFlags() {
@@ -2504,13 +2521,20 @@
}
if (what & layer_state_t::eLayerChanged) {
// NOTE: index needs to be calculated before we update the state
- ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
- if (layer->setLayer(s.z) && idx >= 0) {
- mCurrentState.layersSortedByZ.removeAt(idx);
- mCurrentState.layersSortedByZ.add(layer);
- // we need traversal (state changed)
- // AND transaction (list changed)
- flags |= eTransactionNeeded|eTraversalNeeded;
+ const auto& p = layer->getParent();
+ if (p == nullptr) {
+ ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
+ if (layer->setLayer(s.z) && idx >= 0) {
+ mCurrentState.layersSortedByZ.removeAt(idx);
+ mCurrentState.layersSortedByZ.add(layer);
+ // we need traversal (state changed)
+ // AND transaction (list changed)
+ flags |= eTransactionNeeded|eTraversalNeeded;
+ }
+ } else {
+ if (p->setChildLayer(layer, s.z)) {
+ flags |= eTransactionNeeded|eTraversalNeeded;
+ }
}
}
if (what & layer_state_t::eSizeChanged) {
@@ -2543,9 +2567,17 @@
flags |= eTraversalNeeded;
}
if (what & layer_state_t::eLayerStackChanged) {
- // NOTE: index needs to be calculated before we update the state
ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
- if (layer->setLayerStack(s.layerStack) && idx >= 0) {
+ // We only allow setting layer stacks for top level layers,
+ // everything else inherits layer stack from its parent.
+ if (layer->hasParent()) {
+ ALOGE("Attempt to set layer stack on layer with parent (%s) is invalid",
+ layer->getName().string());
+ } else if (idx < 0) {
+ ALOGE("Attempt to set layer stack on layer without parent (%s) that "
+ "that also does not appear in the top level layer list. Something"
+ " has gone wrong.", layer->getName().string());
+ } else if (layer->setLayerStack(s.layerStack)) {
mCurrentState.layersSortedByZ.removeAt(idx);
mCurrentState.layersSortedByZ.add(layer);
// we need traversal (state changed)
@@ -2558,11 +2590,19 @@
// We don't trigger a traversal here because if no other state is
// changed, we don't want this to cause any more work
}
+ if (what & layer_state_t::eReparentChildren) {
+ if (layer->reparentChildren(s.reparentHandle)) {
+ flags |= eTransactionNeeded|eTraversalNeeded;
+ }
+ }
if (what & layer_state_t::eOverrideScalingModeChanged) {
layer->setOverrideScalingMode(s.overrideScalingMode);
// We don't trigger a traversal here because if no other state is
// changed, we don't want this to cause any more work
}
+ if (what & layer_state_t::eLayerInfoChanged) {
+ layer->setInfo(s.type, s.appid);
+ }
}
return flags;
}
@@ -2571,7 +2611,8 @@
const String8& name,
const sp<Client>& client,
uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
- sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp)
+ sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp,
+ sp<Layer>* parent)
{
if (int32_t(w|h) < 0) {
ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
@@ -2603,7 +2644,7 @@
return result;
}
- result = addClientLayer(client, *handle, *gbp, layer);
+ result = addClientLayer(client, *handle, *gbp, layer, *parent);
if (result != NO_ERROR) {
return result;
}
@@ -2891,12 +2932,9 @@
void SurfaceFlinger::listLayersLocked(const Vector<String16>& /* args */,
size_t& /* index */, String8& result) const
{
- const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
- const size_t count = currentLayers.size();
- for (size_t i=0 ; i<count ; i++) {
- const sp<Layer>& layer(currentLayers[i]);
+ mCurrentState.traverseInZOrder([&](Layer* layer) {
result.appendFormat("%s\n", layer->getName().string());
- }
+ });
}
void SurfaceFlinger::dumpStatsLocked(const Vector<String16>& args, size_t& index,
@@ -2915,14 +2953,11 @@
if (name.isEmpty()) {
mAnimFrameTracker.dumpStats(result);
} else {
- const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
- const size_t count = currentLayers.size();
- for (size_t i=0 ; i<count ; i++) {
- const sp<Layer>& layer(currentLayers[i]);
+ mCurrentState.traverseInZOrder([&](Layer* layer) {
if (name == layer->getName()) {
layer->dumpFrameStats(result);
}
- }
+ });
}
}
@@ -2935,14 +2970,11 @@
index++;
}
- const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
- const size_t count = currentLayers.size();
- for (size_t i=0 ; i<count ; i++) {
- const sp<Layer>& layer(currentLayers[i]);
+ mCurrentState.traverseInZOrder([&](Layer* layer) {
if (name.isEmpty() || (name == layer->getName())) {
layer->clearFrameStats();
}
- }
+ });
mAnimFrameTracker.clearStats();
}
@@ -2950,12 +2982,9 @@
// This should only be called from the main thread. Otherwise it would need
// the lock and should use mCurrentState rather than mDrawingState.
void SurfaceFlinger::logFrameStats() {
- const LayerVector& drawingLayers = mDrawingState.layersSortedByZ;
- const size_t count = drawingLayers.size();
- for (size_t i=0 ; i<count ; i++) {
- const sp<Layer>& layer(drawingLayers[i]);
+ mDrawingState.traverseInZOrder([&](Layer* layer) {
layer->logFrameStats();
- }
+ });
mAnimFrameTracker.logAndResetStats(String8("<win-anim>"));
}
@@ -3112,15 +3141,12 @@
/*
* Dump the visible layer list
*/
- const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
- const size_t count = currentLayers.size();
colorizer.bold(result);
- result.appendFormat("Visible layers (count = %zu)\n", count);
+ result.appendFormat("Visible layers (count = %zu)\n", mNumLayers);
colorizer.reset(result);
- for (size_t i=0 ; i<count ; i++) {
- const sp<Layer>& layer(currentLayers[i]);
+ mCurrentState.traverseInZOrder([&](Layer* layer) {
layer->dump(result, colorizer);
- }
+ });
/*
* Dump Display state
@@ -3198,10 +3224,9 @@
result.appendFormat("Display %d HWC layers:\n", hwcId);
Layer::miniDumpHeader(result);
- for (size_t l = 0; l < count; l++) {
- const sp<Layer>& layer(currentLayers[l]);
+ mCurrentState.traverseInZOrder([&](Layer* layer) {
layer->miniDump(result, hwcId);
- }
+ });
result.append("\n");
}
@@ -3263,7 +3288,6 @@
switch (code) {
case CREATE_CONNECTION:
case CREATE_DISPLAY:
- case SET_TRANSACTION_STATE:
case BOOT_FINISHED:
case CLEAR_ANIMATION_FRAME_STATS:
case GET_ANIMATION_FRAME_STATS:
@@ -3281,6 +3305,17 @@
}
break;
}
+ /*
+ * Calling setTransactionState is safe, because you need to have been
+ * granted a reference to Client* and Handle* to do anything with it.
+ *
+ * Creating a scoped connection is safe, as per discussion in ISurfaceComposer.h
+ */
+ case SET_TRANSACTION_STATE:
+ case CREATE_SCOPED_CONNECTION:
+ {
+ return OK;
+ }
case CAPTURE_SCREEN:
{
// codes that require permission check
@@ -3582,7 +3617,7 @@
status_t SurfaceFlinger::captureScreen(const sp<IBinder>& display,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform, ISurfaceComposer::Rotation rotation) {
if (CC_UNLIKELY(display == 0))
@@ -3633,7 +3668,7 @@
const sp<IBinder>& display,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform,
Transform::orientation_flags rotation,
bool isLocalScreenshot)
@@ -3682,7 +3717,7 @@
void SurfaceFlinger::renderScreenImplLocked(
const sp<const DisplayDevice>& hw,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool yswap, bool useIdentityTransform, Transform::orientation_flags rotation)
{
ATRACE_CALL();
@@ -3726,20 +3761,24 @@
// redraw the screen entirely...
engine.clearWithColor(0, 0, 0, 1);
- const LayerVector& layers( mDrawingState.layersSortedByZ );
- const size_t count = layers.size();
- for (size_t i=0 ; i<count ; ++i) {
- const sp<Layer>& layer(layers[i]);
- const Layer::State& state(layer->getDrawingState());
- if (state.layerStack == hw->getLayerStack()) {
- if (state.z >= minLayerZ && state.z <= maxLayerZ) {
- if (layer->isVisible()) {
- if (filtering) layer->setFiltering(true);
- layer->draw(hw, useIdentityTransform);
- if (filtering) layer->setFiltering(false);
- }
- }
+ // We loop through the first level of layers without traversing,
+ // as we need to interpret min/max layer Z in the top level Z space.
+ for (const auto& layer : mDrawingState.layersSortedByZ) {
+ if (layer->getLayerStack() != hw->getLayerStack()) {
+ continue;
}
+ const Layer::State& state(layer->getDrawingState());
+ if (state.z < minLayerZ || state.z > maxLayerZ) {
+ continue;
+ }
+ layer->traverseInZOrder([&](Layer* layer) {
+ if (!layer->isVisible()) {
+ return;
+ }
+ if (filtering) layer->setFiltering(true);
+ layer->draw(hw, useIdentityTransform);
+ if (filtering) layer->setFiltering(false);
+ });
}
hw->setViewportAndProjection();
@@ -3750,7 +3789,7 @@
const sp<const DisplayDevice>& hw,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform, Transform::orientation_flags rotation,
bool isLocalScreenshot)
{
@@ -3774,16 +3813,16 @@
reqHeight = (!reqHeight) ? hw_h : reqHeight;
bool secureLayerIsVisible = false;
- const LayerVector& layers(mDrawingState.layersSortedByZ);
- const size_t count = layers.size();
- for (size_t i = 0 ; i < count ; ++i) {
- const sp<Layer>& layer(layers[i]);
+ for (const auto& layer : mDrawingState.layersSortedByZ) {
const Layer::State& state(layer->getDrawingState());
- if (state.layerStack == hw->getLayerStack() && state.z >= minLayerZ &&
- state.z <= maxLayerZ && layer->isVisible() &&
- layer->isSecure()) {
- secureLayerIsVisible = true;
+ if ((layer->getLayerStack() != hw->getLayerStack()) ||
+ (state.z < minLayerZ || state.z > maxLayerZ)) {
+ continue;
}
+ layer->traverseInZOrder([&](Layer *layer) {
+ secureLayerIsVisible = secureLayerIsVisible || (layer->isVisible() &&
+ layer->isSecure());
+ });
}
if (!isLocalScreenshot && secureLayerIsVisible) {
@@ -3911,7 +3950,7 @@
}
void SurfaceFlinger::checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr,
- const sp<const DisplayDevice>& hw, uint32_t minLayerZ, uint32_t maxLayerZ) {
+ const sp<const DisplayDevice>& hw, int32_t minLayerZ, int32_t maxLayerZ) {
if (DEBUG_SCREENSHOTS) {
for (size_t y=0 ; y<h ; y++) {
uint32_t const * p = (uint32_t const *)vaddr + y*s;
@@ -3922,49 +3961,32 @@
ALOGE("*** we just took a black screenshot ***\n"
"requested minz=%d, maxz=%d, layerStack=%d",
minLayerZ, maxLayerZ, hw->getLayerStack());
- const LayerVector& layers( mDrawingState.layersSortedByZ );
- const size_t count = layers.size();
- for (size_t i=0 ; i<count ; ++i) {
- const sp<Layer>& layer(layers[i]);
+
+ size_t i = 0;
+ for (const auto& layer : mDrawingState.layersSortedByZ) {
const Layer::State& state(layer->getDrawingState());
- const bool visible = (state.layerStack == hw->getLayerStack())
- && (state.z >= minLayerZ && state.z <= maxLayerZ)
- && (layer->isVisible());
- ALOGE("%c index=%zu, name=%s, layerStack=%d, z=%d, visible=%d, flags=%x, alpha=%.3f",
- visible ? '+' : '-',
- i, layer->getName().string(), state.layerStack, state.z,
+ if (layer->getLayerStack() == hw->getLayerStack() && state.z >= minLayerZ &&
+ state.z <= maxLayerZ) {
+ layer->traverseInZOrder([&](Layer* layer) {
+ ALOGE("%c index=%zu, name=%s, layerStack=%d, z=%d, visible=%d, flags=%x, alpha=%.3f",
+ layer->isVisible() ? '+' : '-',
+ i, layer->getName().string(), layer->getLayerStack(), state.z,
layer->isVisible(), state.flags, state.alpha);
+ i++;
+ });
+ }
}
}
}
// ---------------------------------------------------------------------------
-SurfaceFlinger::LayerVector::LayerVector() {
+void SurfaceFlinger::State::traverseInZOrder(const std::function<void(Layer*)>& consume) const {
+ layersSortedByZ.traverseInZOrder(consume);
}
-SurfaceFlinger::LayerVector::LayerVector(const LayerVector& rhs)
- : SortedVector<sp<Layer> >(rhs) {
-}
-
-int SurfaceFlinger::LayerVector::do_compare(const void* lhs,
- const void* rhs) const
-{
- // sort layers per layer-stack, then by z-order and finally by sequence
- const sp<Layer>& l(*reinterpret_cast<const sp<Layer>*>(lhs));
- const sp<Layer>& r(*reinterpret_cast<const sp<Layer>*>(rhs));
-
- uint32_t ls = l->getCurrentState().layerStack;
- uint32_t rs = r->getCurrentState().layerStack;
- if (ls != rs)
- return ls - rs;
-
- uint32_t lz = l->getCurrentState().z;
- uint32_t rz = r->getCurrentState().z;
- if (lz != rz)
- return lz - rz;
-
- return l->sequence - r->sequence;
+void SurfaceFlinger::State::traverseInReverseZOrder(const std::function<void(Layer*)>& consume) const {
+ layersSortedByZ.traverseInReverseZOrder(consume);
}
}; // namespace android
diff --git a/services/surfaceflinger/SurfaceFlinger.h b/services/surfaceflinger/SurfaceFlinger.h
index f7f9ef5..45a5268 100644
--- a/services/surfaceflinger/SurfaceFlinger.h
+++ b/services/surfaceflinger/SurfaceFlinger.h
@@ -55,6 +55,7 @@
#include "DisplayDevice.h"
#include "DispSync.h"
#include "FrameTracker.h"
+#include "LayerVector.h"
#include "MessageQueue.h"
#include "SurfaceInterceptor.h"
@@ -168,16 +169,13 @@
* Internal data structures
*/
- class LayerVector : public SortedVector< sp<Layer> > {
+ class State {
public:
- LayerVector();
- LayerVector(const LayerVector& rhs);
- virtual int do_compare(const void* lhs, const void* rhs) const;
- };
-
- struct State {
LayerVector layersSortedByZ;
DefaultKeyedVector< wp<IBinder>, DisplayDeviceState> displays;
+
+ void traverseInZOrder(const std::function<void(Layer*)>& consume) const;
+ void traverseInReverseZOrder(const std::function<void(Layer*)>& consume) const;
};
/* ------------------------------------------------------------------------
@@ -191,6 +189,7 @@
* ISurfaceComposer interface
*/
virtual sp<ISurfaceComposerClient> createConnection();
+ virtual sp<ISurfaceComposerClient> createScopedConnection(const sp<IGraphicBufferProducer>& gbp);
virtual sp<IGraphicBufferAlloc> createGraphicBufferAlloc();
virtual sp<IBinder> createDisplay(const String8& displayName, bool secure);
virtual void destroyDisplay(const sp<IBinder>& display);
@@ -206,7 +205,7 @@
virtual status_t captureScreen(const sp<IBinder>& display,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform, ISurfaceComposer::Rotation rotation);
virtual status_t getDisplayStats(const sp<IBinder>& display,
DisplayStatInfo* stats);
@@ -295,7 +294,8 @@
*/
status_t createLayer(const String8& name, const sp<Client>& client,
uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
- sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp);
+ sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp,
+ sp<Layer>* parent);
status_t createNormalLayer(const sp<Client>& client, const String8& name,
uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
@@ -322,7 +322,8 @@
status_t addClientLayer(const sp<Client>& client,
const sp<IBinder>& handle,
const sp<IGraphicBufferProducer>& gbc,
- const sp<Layer>& lbc);
+ const sp<Layer>& lbc,
+ const sp<Layer>& parent);
/* ------------------------------------------------------------------------
* Boot animation, on/off animations and screen capture
@@ -333,14 +334,14 @@
void renderScreenImplLocked(
const sp<const DisplayDevice>& hw,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool yswap, bool useIdentityTransform, Transform::orientation_flags rotation);
status_t captureScreenImplLocked(
const sp<const DisplayDevice>& hw,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform, Transform::orientation_flags rotation,
bool isLocalScreenshot);
@@ -397,8 +398,7 @@
* Compositing
*/
void invalidateHwcGeometry();
- static void computeVisibleRegions(
- const LayerVector& currentLayers, uint32_t layerStack,
+ void computeVisibleRegions(uint32_t layerStack,
Region& dirtyRegion, Region& opaqueRegion);
void preComposition(nsecs_t refreshStartTime);
@@ -426,6 +426,7 @@
void enableHardwareVsync();
void resyncToHardwareVsync(bool makeAvailable);
void disableHardwareVsync(bool makeUnavailable);
+
public:
void resyncWithRateLimit();
private:
@@ -441,7 +442,7 @@
void appendSfConfigString(String8& result) const;
void checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr,
const sp<const DisplayDevice>& hw,
- uint32_t minLayerZ, uint32_t maxLayerZ);
+ int32_t minLayerZ, int32_t maxLayerZ);
void logFrameStats();
@@ -467,11 +468,12 @@
Condition mTransactionCV;
bool mTransactionPending;
bool mAnimTransactionPending;
- Vector< sp<Layer> > mLayersPendingRemoval;
+ SortedVector< sp<Layer> > mLayersPendingRemoval;
SortedVector< wp<IBinder> > mGraphicBufferProducerList;
// protected by mStateLock (but we could use another lock)
bool mLayersRemoved;
+ bool mLayersAdded;
// access must be protected by mInvalidateLock
volatile int32_t mRepaintEverything;
@@ -568,6 +570,8 @@
nsecs_t mTotalTime;
std::atomic<nsecs_t> mLastSwapTime;
+ size_t mNumLayers;
+
// Double- vs. triple-buffering stats
struct BufferingStats {
BufferingStats()
diff --git a/services/surfaceflinger/SurfaceFlinger_hwc1.cpp b/services/surfaceflinger/SurfaceFlinger_hwc1.cpp
index fcf0185..2cd02a0 100644
--- a/services/surfaceflinger/SurfaceFlinger_hwc1.cpp
+++ b/services/surfaceflinger/SurfaceFlinger_hwc1.cpp
@@ -72,7 +72,9 @@
#include "EventControlThread.h"
#include "EventThread.h"
#include "Layer.h"
+#include "LayerVector.h"
#include "LayerDim.h"
+#include "MonitoredProducer.h"
#include "SurfaceFlinger.h"
#include "DisplayHardware/FramebufferSurface.h"
@@ -136,6 +138,7 @@
mTransactionPending(false),
mAnimTransactionPending(false),
mLayersRemoved(false),
+ mLayersAdded(false),
mRepaintEverything(0),
mRenderEngine(NULL),
mBootTime(systemTime()),
@@ -161,7 +164,8 @@
mHasPoweredOff(false),
mFrameBuckets(),
mTotalTime(0),
- mLastSwapTime(0)
+ mLastSwapTime(0),
+ mNumLayers(0)
{
ALOGI("SurfaceFlinger is starting");
@@ -216,15 +220,29 @@
startBootAnim();
}
-sp<ISurfaceComposerClient> SurfaceFlinger::createConnection()
-{
- sp<ISurfaceComposerClient> bclient;
- sp<Client> client(new Client(this));
+static sp<ISurfaceComposerClient> initClient(const sp<Client>& client) {
status_t err = client->initCheck();
if (err == NO_ERROR) {
- bclient = client;
+ return client;
}
- return bclient;
+ return nullptr;
+}
+
+sp<ISurfaceComposerClient> SurfaceFlinger::createConnection() {
+ return initClient(new Client(this));
+}
+
+sp<ISurfaceComposerClient> SurfaceFlinger::createScopedConnection(
+ const sp<IGraphicBufferProducer>& gbp) {
+ if (authenticateSurfaceTexture(gbp) == false) {
+ return nullptr;
+ }
+ const auto& layer = (static_cast<MonitoredProducer*>(gbp.get()))->getLayer();
+ if (layer == nullptr) {
+ return nullptr;
+ }
+
+ return initClient(new Client(this, layer));
}
sp<IBinder> SurfaceFlinger::createDisplay(const String8& displayName,
@@ -1126,13 +1144,12 @@
void SurfaceFlinger::preComposition(nsecs_t refreshStartTime)
{
bool needExtraInvalidate = false;
- const LayerVector& layers(mDrawingState.layersSortedByZ);
- const size_t count = layers.size();
- for (size_t i=0 ; i<count ; i++) {
- if (layers[i]->onPreComposition(refreshStartTime)) {
+ mDrawingState.traverseInZOrder([&](Layer* layer) {
+ if (layer->onPreComposition(refreshStartTime)) {
needExtraInvalidate = true;
}
- }
+ });
+
if (needExtraInvalidate) {
signalLayerUpdate();
}
@@ -1159,16 +1176,15 @@
mDisplayTimeline.push(retireFenceTime);
mDisplayTimeline.updateSignalTimes();
- const LayerVector& layers(mDrawingState.layersSortedByZ);
- const size_t count = layers.size();
- for (size_t i=0 ; i<count ; i++) {
- bool frameLatched = layers[i]->onPostComposition(
- glCompositionDoneFenceTime, presentFenceTime, retireFenceTime);
+ mDrawingState.traverseInZOrder([&](Layer* layer) {
+ bool frameLatched = layer->onPostComposition(glCompositionDoneFenceTime,
+ presentFenceTime, retireFenceTime);
+
if (frameLatched) {
- recordBufferingStats(layers[i]->getName().string(),
- layers[i]->getOccupancyHistory(false));
+ recordBufferingStats(layer->getName().string(),
+ layer->getOccupancyHistory(false));
}
- }
+ });
if (displayFence->isValid()) {
if (mPrimaryDispSync.addPresentFence(displayFence)) {
@@ -1226,7 +1242,6 @@
mVisibleRegionsDirty = false;
invalidateHwcGeometry();
- const LayerVector& layers(mDrawingState.layersSortedByZ);
for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
Region opaqueRegion;
Region dirtyRegion;
@@ -1235,14 +1250,11 @@
const Transform& tr(hw->getTransform());
const Rect bounds(hw->getBounds());
if (hw->isDisplayOn()) {
- SurfaceFlinger::computeVisibleRegions(layers,
- hw->getLayerStack(), dirtyRegion, opaqueRegion);
+ computeVisibleRegions(hw->getLayerStack(), dirtyRegion,
+ opaqueRegion);
- const size_t count = layers.size();
- for (size_t i=0 ; i<count ; i++) {
- const sp<Layer>& layer(layers[i]);
- const Layer::State& s(layer->getDrawingState());
- if (s.layerStack == hw->getLayerStack()) {
+ mDrawingState.traverseInZOrder([&](Layer* layer) {
+ if (layer->getLayerStack() == hw->getLayerStack()) {
Region drawRegion(tr.transform(
layer->visibleNonTransparentRegion));
drawRegion.andSelf(bounds);
@@ -1250,7 +1262,7 @@
layersSortedByZ.add(layer);
}
}
- }
+ });
}
hw->setVisibleLayersSortedByZ(layersSortedByZ);
hw->undefinedRegion.set(bounds);
@@ -1473,13 +1485,10 @@
void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)
{
- const LayerVector& currentLayers(mCurrentState.layersSortedByZ);
- const size_t count = currentLayers.size();
-
// Notify all layers of available frames
- for (size_t i = 0; i < count; ++i) {
- currentLayers[i]->notifyAvailableFrames();
- }
+ mCurrentState.traverseInZOrder([](Layer* layer) {
+ layer->notifyAvailableFrames();
+ });
/*
* Traversal of the children
@@ -1487,15 +1496,14 @@
*/
if (transactionFlags & eTraversalNeeded) {
- for (size_t i=0 ; i<count ; i++) {
- const sp<Layer>& layer(currentLayers[i]);
+ mCurrentState.traverseInZOrder([&](Layer* layer) {
uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
- if (!trFlags) continue;
+ if (!trFlags) return;
const uint32_t flags = layer->doTransaction(0);
if (flags & Layer::eVisibleRegion)
mVisibleRegionsDirty = true;
- }
+ });
}
/*
@@ -1682,13 +1690,13 @@
//
sp<const DisplayDevice> disp;
uint32_t currentlayerStack = 0;
- for (size_t i=0; i<count; i++) {
+ bool first = true;
+ mCurrentState.traverseInZOrder([&](Layer* layer) {
// NOTE: we rely on the fact that layers are sorted by
// layerStack first (so we don't have to traverse the list
// of displays for every layer).
- const sp<Layer>& layer(currentLayers[i]);
- uint32_t layerStack = layer->getDrawingState().layerStack;
- if (i==0 || currentlayerStack != layerStack) {
+ uint32_t layerStack = layer->getLayerStack();
+ if (first || currentlayerStack != layerStack) {
currentlayerStack = layerStack;
// figure out if this layerstack is mirrored
// (more than one display) if so, pick the default display,
@@ -1716,7 +1724,9 @@
disp = getDefaultDisplayDevice();
}
layer->updateTransformHint(disp);
- }
+
+ first = false;
+ });
}
@@ -1724,9 +1734,9 @@
* Perform our own transaction if needed
*/
- const LayerVector& layers(mDrawingState.layersSortedByZ);
- if (currentLayers.size() > layers.size()) {
- // layers have been added
+ if (mLayersAdded) {
+ mLayersAdded = false;
+ // Layers have been added.
mVisibleRegionsDirty = true;
}
@@ -1735,20 +1745,17 @@
if (mLayersRemoved) {
mLayersRemoved = false;
mVisibleRegionsDirty = true;
- const size_t count = layers.size();
- for (size_t i=0 ; i<count ; i++) {
- const sp<Layer>& layer(layers[i]);
- if (currentLayers.indexOf(layer) < 0) {
+ mDrawingState.traverseInZOrder([&](Layer* layer) {
+ if (mLayersPendingRemoval.indexOf(layer) >= 0) {
// this layer is not visible anymore
// TODO: we could traverse the tree from front to back and
// compute the actual visible region
// TODO: we could cache the transformed region
- const Layer::State& s(layer->getDrawingState());
- Region visibleReg = s.active.transform.transform(
- Region(Rect(s.active.w, s.active.h)));
- invalidateLayerStack(s.layerStack, visibleReg);
+ Region visibleReg;
+ visibleReg.set(layer->computeScreenBounds());
+ invalidateLayerStack(layer->getLayerStack(), visibleReg);
}
- }
+ });
}
commitTransaction();
@@ -1786,10 +1793,10 @@
{
if (!mLayersPendingRemoval.isEmpty()) {
// Notify removed layers now that they can't be drawn from
- for (size_t i = 0; i < mLayersPendingRemoval.size(); i++) {
- recordBufferingStats(mLayersPendingRemoval[i]->getName().string(),
- mLayersPendingRemoval[i]->getOccupancyHistory(true));
- mLayersPendingRemoval[i]->onRemoved();
+ for (const auto& l : mLayersPendingRemoval) {
+ recordBufferingStats(l->getName().string(),
+ l->getOccupancyHistory(true));
+ l->onRemoved();
}
mLayersPendingRemoval.clear();
}
@@ -1799,13 +1806,15 @@
mAnimCompositionPending = mAnimTransactionPending;
mDrawingState = mCurrentState;
+ mDrawingState.traverseInZOrder([](Layer* layer) {
+ layer->commitChildList();
+ });
mTransactionPending = false;
mAnimTransactionPending = false;
mTransactionCV.broadcast();
}
-void SurfaceFlinger::computeVisibleRegions(
- const LayerVector& currentLayers, uint32_t layerStack,
+void SurfaceFlinger::computeVisibleRegions(uint32_t layerStack,
Region& outDirtyRegion, Region& outOpaqueRegion)
{
ATRACE_CALL();
@@ -1816,16 +1825,13 @@
outDirtyRegion.clear();
- size_t i = currentLayers.size();
- while (i--) {
- const sp<Layer>& layer = currentLayers[i];
-
+ mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
// start with the whole surface at its current location
const Layer::State& s(layer->getDrawingState());
// only consider the layers on the given layer stack
- if (s.layerStack != layerStack)
- continue;
+ if (layer->getLayerStack() != layerStack)
+ return;
/*
* opaqueRegion: area of a surface that is fully opaque.
@@ -1860,12 +1866,12 @@
// handle hidden surfaces by setting the visible region to empty
if (CC_LIKELY(layer->isVisible())) {
const bool translucent = !layer->isOpaque(s);
- Rect bounds(s.active.transform.transform(layer->computeBounds()));
+ Rect bounds(layer->computeScreenBounds());
visibleRegion.set(bounds);
+ Transform tr = layer->getTransform();
if (!visibleRegion.isEmpty()) {
// Remove the transparent area from the visible region
if (translucent) {
- const Transform tr(s.active.transform);
if (tr.preserveRects()) {
// transform the transparent region
transparentRegion = tr.transform(s.activeTransparentRegion);
@@ -1877,7 +1883,7 @@
}
// compute the opaque region
- const int32_t layerOrientation = s.active.transform.getOrientation();
+ const int32_t layerOrientation = tr.getOrientation();
if (s.alpha==255 && !translucent &&
((layerOrientation & Transform::ROT_INVALID) == false)) {
// the opaque region is the layer's footprint
@@ -1934,7 +1940,7 @@
layer->setCoveredRegion(coveredRegion);
layer->setVisibleNonTransparentRegion(
visibleRegion.subtract(transparentRegion));
- }
+ });
outOpaqueRegion = aboveOpaqueLayers;
}
@@ -1955,7 +1961,6 @@
Region dirtyRegion;
bool visibleRegions = false;
- const LayerVector& layers(mDrawingState.layersSortedByZ);
bool frameQueued = false;
// Store the set of layers that need updates. This set must not change as
@@ -1968,25 +1973,23 @@
// Display is now waiting on Layer 1's frame, which is behind layer 0's
// second frame. But layer 0's second frame could be waiting on display.
Vector<Layer*> layersWithQueuedFrames;
- for (size_t i = 0, count = layers.size(); i<count ; i++) {
- const sp<Layer>& layer(layers[i]);
+ mDrawingState.traverseInZOrder([&](Layer* layer) {
if (layer->hasQueuedFrame()) {
frameQueued = true;
if (layer->shouldPresentNow(mPrimaryDispSync)) {
- layersWithQueuedFrames.push_back(layer.get());
+ layersWithQueuedFrames.push_back(layer);
} else {
layer->useEmptyDamage();
}
} else {
layer->useEmptyDamage();
}
- }
+ });
for (size_t i = 0, count = layersWithQueuedFrames.size() ; i<count ; i++) {
Layer* layer = layersWithQueuedFrames[i];
const Region dirty(layer->latchBuffer(visibleRegions, latchTime));
layer->useSurfaceDamage();
- const Layer::State& s(layer->getDrawingState());
- invalidateLayerStack(s.layerStack, dirty);
+ invalidateLayerStack(layer->getLayerStack(), dirty);
}
mVisibleRegionsDirty |= visibleRegions;
@@ -2202,16 +2205,23 @@
status_t SurfaceFlinger::addClientLayer(const sp<Client>& client,
const sp<IBinder>& handle,
const sp<IGraphicBufferProducer>& gbc,
- const sp<Layer>& lbc)
+ const sp<Layer>& lbc,
+ const sp<Layer>& parent)
{
// add this layer to the current state list
{
Mutex::Autolock _l(mStateLock);
- if (mCurrentState.layersSortedByZ.size() >= MAX_LAYERS) {
+ if (mNumLayers >= MAX_LAYERS) {
return NO_MEMORY;
}
- mCurrentState.layersSortedByZ.add(lbc);
+ if (parent == nullptr) {
+ mCurrentState.layersSortedByZ.add(lbc);
+ } else {
+ parent->addChild(lbc);
+ }
mGraphicBufferProducerList.add(IInterface::asBinder(gbc));
+ mLayersAdded = true;
+ mNumLayers++;
}
// attach this layer to the client
@@ -2228,14 +2238,22 @@
return NO_ERROR;
}
- ssize_t index = mCurrentState.layersSortedByZ.remove(layer);
- if (index >= 0) {
- mLayersPendingRemoval.push(layer);
- mLayersRemoved = true;
- setTransactionFlags(eTransactionNeeded);
- return NO_ERROR;
+ const auto& p = layer->getParent();
+ const ssize_t index = (p != nullptr) ? p->removeChild(layer) :
+ mCurrentState.layersSortedByZ.remove(layer);
+
+ if (index < 0) {
+ ALOGE("Failed to find layer (%s) in layer parent (%s).",
+ layer->getName().string(),
+ (p != nullptr) ? p->getName().string() : "no-parent");
+ return BAD_VALUE;
}
- return status_t(index);
+
+ mLayersPendingRemoval.add(layer);
+ mLayersRemoved = true;
+ mNumLayers--;
+ setTransactionFlags(eTransactionNeeded);
+ return NO_ERROR;
}
uint32_t SurfaceFlinger::peekTransactionFlags() {
@@ -2410,13 +2428,20 @@
}
if (what & layer_state_t::eLayerChanged) {
// NOTE: index needs to be calculated before we update the state
- ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
- if (layer->setLayer(s.z) && idx >= 0) {
- mCurrentState.layersSortedByZ.removeAt(idx);
- mCurrentState.layersSortedByZ.add(layer);
- // we need traversal (state changed)
- // AND transaction (list changed)
- flags |= eTransactionNeeded|eTraversalNeeded;
+ const auto& p = layer->getParent();
+ if (p == nullptr) {
+ ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
+ if (layer->setLayer(s.z) && idx >= 0) {
+ mCurrentState.layersSortedByZ.removeAt(idx);
+ mCurrentState.layersSortedByZ.add(layer);
+ // we need traversal (state changed)
+ // AND transaction (list changed)
+ flags |= eTransactionNeeded|eTraversalNeeded;
+ }
+ } else {
+ if (p->setChildLayer(layer, s.z)) {
+ flags |= eTransactionNeeded|eTraversalNeeded;
+ }
}
}
if (what & layer_state_t::eSizeChanged) {
@@ -2449,9 +2474,17 @@
flags |= eTraversalNeeded;
}
if (what & layer_state_t::eLayerStackChanged) {
- // NOTE: index needs to be calculated before we update the state
ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
- if (layer->setLayerStack(s.layerStack) && idx >= 0) {
+ // We only allow setting layer stacks for top level layers,
+ // everything else inherits layer stack from its parent.
+ if (layer->hasParent()) {
+ ALOGE("Attempt to set layer stack on layer with parent (%s) is invalid",
+ layer->getName().string());
+ } else if (idx < 0) {
+ ALOGE("Attempt to set layer stack on layer without parent (%s) that "
+ "that also does not appear in the top level layer list. Something"
+ " has gone wrong.", layer->getName().string());
+ } else if (layer->setLayerStack(s.layerStack)) {
mCurrentState.layersSortedByZ.removeAt(idx);
mCurrentState.layersSortedByZ.add(layer);
// we need traversal (state changed)
@@ -2464,6 +2497,11 @@
// We don't trigger a traversal here because if no other state is
// changed, we don't want this to cause any more work
}
+ if (what & layer_state_t::eReparentChildren) {
+ if (layer->reparentChildren(s.reparentHandle)) {
+ flags |= eTransactionNeeded|eTraversalNeeded;
+ }
+ }
if (what & layer_state_t::eOverrideScalingModeChanged) {
layer->setOverrideScalingMode(s.overrideScalingMode);
// We don't trigger a traversal here because if no other state is
@@ -2477,7 +2515,8 @@
const String8& name,
const sp<Client>& client,
uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
- sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp)
+ sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp,
+ sp<Layer>* parent)
{
if (int32_t(w|h) < 0) {
ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
@@ -2509,7 +2548,7 @@
return result;
}
- result = addClientLayer(client, *handle, *gbp, layer);
+ result = addClientLayer(client, *handle, *gbp, layer, *parent);
if (result != NO_ERROR) {
return result;
}
@@ -2797,12 +2836,9 @@
void SurfaceFlinger::listLayersLocked(const Vector<String16>& /* args */,
size_t& /* index */, String8& result) const
{
- const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
- const size_t count = currentLayers.size();
- for (size_t i=0 ; i<count ; i++) {
- const sp<Layer>& layer(currentLayers[i]);
+ mCurrentState.traverseInZOrder([&](Layer* layer) {
result.appendFormat("%s\n", layer->getName().string());
- }
+ });
}
void SurfaceFlinger::dumpStatsLocked(const Vector<String16>& args, size_t& index,
@@ -2821,14 +2857,11 @@
if (name.isEmpty()) {
mAnimFrameTracker.dumpStats(result);
} else {
- const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
- const size_t count = currentLayers.size();
- for (size_t i=0 ; i<count ; i++) {
- const sp<Layer>& layer(currentLayers[i]);
+ mCurrentState.traverseInZOrder([&](Layer* layer) {
if (name == layer->getName()) {
layer->dumpFrameStats(result);
}
- }
+ });
}
}
@@ -2841,14 +2874,11 @@
index++;
}
- const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
- const size_t count = currentLayers.size();
- for (size_t i=0 ; i<count ; i++) {
- const sp<Layer>& layer(currentLayers[i]);
+ mCurrentState.traverseInZOrder([&](Layer* layer) {
if (name.isEmpty() || (name == layer->getName())) {
layer->clearFrameStats();
}
- }
+ });
mAnimFrameTracker.clearStats();
}
@@ -2856,12 +2886,9 @@
// This should only be called from the main thread. Otherwise it would need
// the lock and should use mCurrentState rather than mDrawingState.
void SurfaceFlinger::logFrameStats() {
- const LayerVector& drawingLayers = mDrawingState.layersSortedByZ;
- const size_t count = drawingLayers.size();
- for (size_t i=0 ; i<count ; i++) {
- const sp<Layer>& layer(drawingLayers[i]);
+ mDrawingState.traverseInZOrder([&](Layer* layer) {
layer->logFrameStats();
- }
+ });
mAnimFrameTracker.logAndResetStats(String8("<win-anim>"));
}
@@ -3015,15 +3042,12 @@
/*
* Dump the visible layer list
*/
- const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
- const size_t count = currentLayers.size();
colorizer.bold(result);
- result.appendFormat("Visible layers (count = %zu)\n", count);
+ result.appendFormat("Visible layers (count = %zu)\n", mNumLayers);
colorizer.reset(result);
- for (size_t i=0 ; i<count ; i++) {
- const sp<Layer>& layer(currentLayers[i]);
+ mCurrentState.traverseInZOrder([&](Layer* layer) {
layer->dump(result, colorizer);
- }
+ });
/*
* Dump Display state
@@ -3149,7 +3173,6 @@
switch (code) {
case CREATE_CONNECTION:
case CREATE_DISPLAY:
- case SET_TRANSACTION_STATE:
case BOOT_FINISHED:
case CLEAR_ANIMATION_FRAME_STATS:
case GET_ANIMATION_FRAME_STATS:
@@ -3168,6 +3191,17 @@
}
break;
}
+ /*
+ * Calling setTransactionState is safe, because you need to have been
+ * granted a reference to Client* and Handle* to do anything with it.
+ *
+ * Creating a scoped connection is safe, as per discussion in ISurfaceComposer.h
+ */
+ case SET_TRANSACTION_STATE:
+ case CREATE_SCOPED_CONNECTION:
+ {
+ break;
+ }
case CAPTURE_SCREEN:
{
// codes that require permission check
@@ -3459,7 +3493,7 @@
status_t SurfaceFlinger::captureScreen(const sp<IBinder>& display,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform, ISurfaceComposer::Rotation rotation) {
if (CC_UNLIKELY(display == 0))
@@ -3500,7 +3534,7 @@
sp<IGraphicBufferProducer> producer;
Rect sourceCrop;
uint32_t reqWidth, reqHeight;
- uint32_t minLayerZ,maxLayerZ;
+ int32_t minLayerZ,maxLayerZ;
bool useIdentityTransform;
Transform::orientation_flags rotation;
status_t result;
@@ -3510,7 +3544,7 @@
const sp<IBinder>& display,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform,
Transform::orientation_flags rotation,
bool isLocalScreenshot)
@@ -3559,7 +3593,7 @@
void SurfaceFlinger::renderScreenImplLocked(
const sp<const DisplayDevice>& hw,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool yswap, bool useIdentityTransform, Transform::orientation_flags rotation)
{
ATRACE_CALL();
@@ -3603,20 +3637,24 @@
// redraw the screen entirely...
engine.clearWithColor(0, 0, 0, 1);
- const LayerVector& layers( mDrawingState.layersSortedByZ );
- const size_t count = layers.size();
- for (size_t i=0 ; i<count ; ++i) {
- const sp<Layer>& layer(layers[i]);
- const Layer::State& state(layer->getDrawingState());
- if (state.layerStack == hw->getLayerStack()) {
- if (state.z >= minLayerZ && state.z <= maxLayerZ) {
- if (layer->isVisible()) {
- if (filtering) layer->setFiltering(true);
- layer->draw(hw, useIdentityTransform);
- if (filtering) layer->setFiltering(false);
- }
- }
+ // We loop through the first level of layers without traversing,
+ // as we need to interpret min/max layer Z in the top level Z space.
+ for (const auto& layer : mDrawingState.layersSortedByZ) {
+ if (layer->getLayerStack() != hw->getLayerStack()) {
+ continue;
}
+ const Layer::State& state(layer->getDrawingState());
+ if (state.z < minLayerZ || state.z > maxLayerZ) {
+ continue;
+ }
+ layer->traverseInZOrder([&](Layer* layer) {
+ if (!layer->isVisible()) {
+ return;
+ }
+ if (filtering) layer->setFiltering(true);
+ layer->draw(hw, useIdentityTransform);
+ if (filtering) layer->setFiltering(false);
+ });
}
// compositionComplete is needed for older driver
@@ -3629,7 +3667,7 @@
const sp<const DisplayDevice>& hw,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform, Transform::orientation_flags rotation,
bool isLocalScreenshot)
{
@@ -3653,16 +3691,16 @@
reqHeight = (!reqHeight) ? hw_h : reqHeight;
bool secureLayerIsVisible = false;
- const LayerVector& layers(mDrawingState.layersSortedByZ);
- const size_t count = layers.size();
- for (size_t i = 0 ; i < count ; ++i) {
- const sp<Layer>& layer(layers[i]);
+ for (const auto& layer : mDrawingState.layersSortedByZ) {
const Layer::State& state(layer->getDrawingState());
- if (state.layerStack == hw->getLayerStack() && state.z >= minLayerZ &&
- state.z <= maxLayerZ && layer->isVisible() &&
- layer->isSecure()) {
- secureLayerIsVisible = true;
+ if ((layer->getLayerStack() != hw->getLayerStack()) ||
+ (state.z < minLayerZ || state.z > maxLayerZ)) {
+ continue;
}
+ layer->traverseInZOrder([&](Layer *layer) {
+ secureLayerIsVisible = secureLayerIsVisible || (layer->isVisible() &&
+ layer->isSecure());
+ });
}
if (!isLocalScreenshot && secureLayerIsVisible) {
@@ -3782,7 +3820,7 @@
}
void SurfaceFlinger::checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr,
- const sp<const DisplayDevice>& hw, uint32_t minLayerZ, uint32_t maxLayerZ) {
+ const sp<const DisplayDevice>& hw, int32_t minLayerZ, int32_t maxLayerZ) {
if (DEBUG_SCREENSHOTS) {
for (size_t y=0 ; y<h ; y++) {
uint32_t const * p = (uint32_t const *)vaddr + y*s;
@@ -3793,49 +3831,31 @@
ALOGE("*** we just took a black screenshot ***\n"
"requested minz=%d, maxz=%d, layerStack=%d",
minLayerZ, maxLayerZ, hw->getLayerStack());
- const LayerVector& layers( mDrawingState.layersSortedByZ );
- const size_t count = layers.size();
- for (size_t i=0 ; i<count ; ++i) {
- const sp<Layer>& layer(layers[i]);
+ size_t i = 0;
+ for (const auto& layer : mDrawingState.layersSortedByZ) {
const Layer::State& state(layer->getDrawingState());
- const bool visible = (state.layerStack == hw->getLayerStack())
- && (state.z >= minLayerZ && state.z <= maxLayerZ)
- && (layer->isVisible());
- ALOGE("%c index=%zu, name=%s, layerStack=%d, z=%d, visible=%d, flags=%x, alpha=%x",
- visible ? '+' : '-',
- i, layer->getName().string(), state.layerStack, state.z,
+ if (layer->getLayerStack() == hw->getLayerStack() && state.z >= minLayerZ &&
+ state.z <= maxLayerZ) {
+ layer->traverseInZOrder([&](Layer* layer) {
+ ALOGE("%c index=%zu, name=%s, layerStack=%d, z=%d, visible=%d, flags=%x, alpha=%x",
+ layer->isVisible() ? '+' : '-',
+ i, layer->getName().string(), layer->getLayerStack(), state.z,
layer->isVisible(), state.flags, state.alpha);
+ i++;
+ });
+ }
}
}
}
// ---------------------------------------------------------------------------
-SurfaceFlinger::LayerVector::LayerVector() {
+void SurfaceFlinger::State::traverseInZOrder(const std::function<void(Layer*)>& consume) const {
+ layersSortedByZ.traverseInZOrder(consume);
}
-SurfaceFlinger::LayerVector::LayerVector(const LayerVector& rhs)
- : SortedVector<sp<Layer> >(rhs) {
-}
-
-int SurfaceFlinger::LayerVector::do_compare(const void* lhs,
- const void* rhs) const
-{
- // sort layers per layer-stack, then by z-order and finally by sequence
- const sp<Layer>& l(*reinterpret_cast<const sp<Layer>*>(lhs));
- const sp<Layer>& r(*reinterpret_cast<const sp<Layer>*>(rhs));
-
- uint32_t ls = l->getCurrentState().layerStack;
- uint32_t rs = r->getCurrentState().layerStack;
- if (ls != rs)
- return ls - rs;
-
- uint32_t lz = l->getCurrentState().z;
- uint32_t rz = r->getCurrentState().z;
- if (lz != rz)
- return lz - rz;
-
- return l->sequence - r->sequence;
+void SurfaceFlinger::State::traverseInReverseZOrder(const std::function<void(Layer*)>& consume) const {
+ layersSortedByZ.traverseInReverseZOrder(consume);
}
}; // namespace android
diff --git a/services/surfaceflinger/SurfaceInterceptor.cpp b/services/surfaceflinger/SurfaceInterceptor.cpp
index 60bc7f3..2d6472a 100644
--- a/services/surfaceflinger/SurfaceInterceptor.cpp
+++ b/services/surfaceflinger/SurfaceInterceptor.cpp
@@ -74,9 +74,11 @@
void SurfaceInterceptor::saveExistingSurfacesLocked(const SortedVector<sp<Layer>>& layers) {
ATRACE_CALL();
- for (const auto& layer : layers) {
- addSurfaceCreationLocked(createTraceIncrementLocked(), layer);
- addInitialSurfaceStateLocked(createTraceIncrementLocked(), layer);
+ for (const auto& l : layers) {
+ l->traverseInZOrder([this](Layer* layer) {
+ addSurfaceCreationLocked(createTraceIncrementLocked(), layer);
+ addInitialSurfaceStateLocked(createTraceIncrementLocked(), layer);
+ });
}
}
diff --git a/services/surfaceflinger/tests/Android.mk b/services/surfaceflinger/tests/Android.mk
index 4f1a8e6..f93d918 100644
--- a/services/surfaceflinger/tests/Android.mk
+++ b/services/surfaceflinger/tests/Android.mk
@@ -20,6 +20,7 @@
libprotobuf-cpp-full \
libui \
libutils \
+ liblog
LOCAL_STATIC_LIBRARIES := libtrace_proto
diff --git a/services/surfaceflinger/tests/Transaction_test.cpp b/services/surfaceflinger/tests/Transaction_test.cpp
index 79cd245..d9f1438 100644
--- a/services/surfaceflinger/tests/Transaction_test.cpp
+++ b/services/surfaceflinger/tests/Transaction_test.cpp
@@ -84,6 +84,18 @@
}
}
+ void expectFGColor(uint32_t x, uint32_t y) {
+ checkPixel(x, y, 195, 63, 63);
+ }
+
+ void expectBGColor(uint32_t x, uint32_t y) {
+ checkPixel(x, y, 63, 63, 195);
+ }
+
+ void expectChildColor(uint32_t x, uint32_t y) {
+ checkPixel(x, y, 200, 200, 200);
+ }
+
private:
ScreenCapture(const sp<CpuConsumer>& cc) :
mCC(cc) {
@@ -140,14 +152,14 @@
mComposerClient->setDisplayLayerStack(display, 0);
- ASSERT_EQ(NO_ERROR, mBGSurfaceControl->setLayer(INT_MAX-2));
+ ASSERT_EQ(NO_ERROR, mBGSurfaceControl->setLayer(INT32_MAX-2));
ASSERT_EQ(NO_ERROR, mBGSurfaceControl->show());
- ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setLayer(INT_MAX-1));
+ ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setLayer(INT32_MAX-1));
ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setPosition(64, 64));
ASSERT_EQ(NO_ERROR, mFGSurfaceControl->show());
- ASSERT_EQ(NO_ERROR, mSyncSurfaceControl->setLayer(INT_MAX-1));
+ ASSERT_EQ(NO_ERROR, mSyncSurfaceControl->setLayer(INT32_MAX-1));
ASSERT_EQ(NO_ERROR, mSyncSurfaceControl->setPosition(displayWidth-2,
displayHeight-2));
ASSERT_EQ(NO_ERROR, mSyncSurfaceControl->show());
@@ -517,4 +529,105 @@
}
}
+class ChildLayerTest : public LayerUpdateTest {
+protected:
+ void SetUp() override {
+ LayerUpdateTest::SetUp();
+ mChild = mComposerClient->createSurface(
+ String8("Child surface"),
+ 10, 10, PIXEL_FORMAT_RGBA_8888,
+ 0, mFGSurfaceControl.get());
+ fillSurfaceRGBA8(mChild, 200, 200, 200);
+
+ {
+ SCOPED_TRACE("before anything");
+ ScreenCapture::captureScreen(&mCapture);
+ mCapture->expectChildColor(64, 64);
+ }
+ }
+ void TearDown() override {
+ LayerUpdateTest::TearDown();
+ mChild = 0;
+ }
+
+ sp<SurfaceControl> mChild;
+ sp<ScreenCapture> mCapture;
+};
+
+TEST_F(ChildLayerTest, ChildLayerPositioning) {
+ SurfaceComposerClient::openGlobalTransaction();
+ mChild->show();
+ mChild->setPosition(10, 10);
+ mFGSurfaceControl->setPosition(64, 64);
+ SurfaceComposerClient::closeGlobalTransaction(true);
+
+ {
+ ScreenCapture::captureScreen(&mCapture);
+ // Top left of foreground must now be visible
+ mCapture->expectFGColor(64, 64);
+ // But 10 pixels in we should see the child surface
+ mCapture->expectChildColor(74, 74);
+ // And 10 more pixels we should be back to the foreground surface
+ mCapture->expectFGColor(84, 84);
+ }
+
+ SurfaceComposerClient::openGlobalTransaction();
+ ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setPosition(0, 0));
+ SurfaceComposerClient::closeGlobalTransaction(true);
+
+ {
+ ScreenCapture::captureScreen(&mCapture);
+ // Top left of foreground should now be at 0, 0
+ mCapture->expectFGColor(0, 0);
+ // But 10 pixels in we should see the child surface
+ mCapture->expectChildColor(10, 10);
+ // And 10 more pixels we should be back to the foreground surface
+ mCapture->expectFGColor(20, 20);
+ }
+}
+
+TEST_F(ChildLayerTest, ChildLayerConstraints) {
+ SurfaceComposerClient::openGlobalTransaction();
+ mChild->show();
+ mFGSurfaceControl->setPosition(0, 0);
+ mChild->setPosition(63, 63);
+ SurfaceComposerClient::closeGlobalTransaction(true);
+
+ {
+ ScreenCapture::captureScreen(&mCapture);
+ mCapture->expectFGColor(0, 0);
+ // Last pixel in foreground should now be the child.
+ mCapture->expectChildColor(63, 63);
+ // But the child should be constrained and the next pixel
+ // must be the background
+ mCapture->expectBGColor(64, 64);
+ }
+}
+
+TEST_F(ChildLayerTest, ChildLayerScaling) {
+ SurfaceComposerClient::openGlobalTransaction();
+ mFGSurfaceControl->setPosition(0, 0);
+ SurfaceComposerClient::closeGlobalTransaction(true);
+
+ // Find the boundary between the parent and child
+ {
+ ScreenCapture::captureScreen(&mCapture);
+ mCapture->expectChildColor(9, 9);
+ mCapture->expectFGColor(10, 10);
+ }
+
+ SurfaceComposerClient::openGlobalTransaction();
+ mFGSurfaceControl->setMatrix(2.0, 0, 0, 2.0);
+ SurfaceComposerClient::closeGlobalTransaction(true);
+
+ // The boundary should be twice as far from the origin now.
+ // The pixels from the last test should all be child now
+ {
+ ScreenCapture::captureScreen(&mCapture);
+ mCapture->expectChildColor(9, 9);
+ mCapture->expectChildColor(10, 10);
+ mCapture->expectChildColor(19, 19);
+ mCapture->expectFGColor(20, 20);
+ }
+}
}
diff --git a/services/vr/Android.bp b/services/vr/Android.bp
new file mode 100644
index 0000000..80df479
--- /dev/null
+++ b/services/vr/Android.bp
@@ -0,0 +1,3 @@
+subdirs = [
+ "*",
+]
diff --git a/services/vr/vr_window_manager/Android.bp b/services/vr/vr_window_manager/Android.bp
new file mode 100644
index 0000000..c30219f
--- /dev/null
+++ b/services/vr/vr_window_manager/Android.bp
@@ -0,0 +1,39 @@
+subdirs = [
+ "composer/1.0",
+]
+
+cc_library_shared {
+ name: "libvrhwc",
+
+ srcs: [
+ "composer/impl/sync_timeline.cpp",
+ "composer/impl/vr_hwc.cpp",
+ "composer/impl/vr_composer_client.cpp",
+ ],
+
+ static_libs: [
+ "libhwcomposer-client",
+ ],
+
+ shared_libs: [
+ "android.dvr.composer@1.0",
+ "android.hardware.graphics.composer@2.1",
+ "libbase",
+ "libcutils",
+ "libfmq",
+ "libhardware",
+ "libhidlbase",
+ "libhidltransport",
+ "liblog",
+ "libsync",
+ "libui",
+ "libutils",
+ ],
+
+ // Access to software sync timeline.
+ include_dirs: [ "system/core/libsync" ],
+
+ cflags: [
+ "-DLOG_TAG=\"vrhwc\"",
+ ],
+}
diff --git a/services/vr/vr_window_manager/composer/1.0/Android.bp b/services/vr/vr_window_manager/composer/1.0/Android.bp
new file mode 100644
index 0000000..f69481f
--- /dev/null
+++ b/services/vr/vr_window_manager/composer/1.0/Android.bp
@@ -0,0 +1,54 @@
+// This file is autogenerated by hidl-gen. Do not edit manually.
+
+genrule {
+ name: "android.dvr.composer@1.0_genc++",
+ tools: ["hidl-gen"],
+ cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hidl:system/libhidl/transport -randroid.hardware:hardware/interfaces/ -randroid.dvr:frameworks/native/services/vr/vr_window_manager android.dvr.composer@1.0",
+ srcs: [
+ "IVrComposerClient.hal",
+ ],
+ out: [
+ "android/dvr/composer/1.0/VrComposerClientAll.cpp",
+ ],
+}
+
+genrule {
+ name: "android.dvr.composer@1.0_genc++_headers",
+ tools: ["hidl-gen"],
+ cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hidl:system/libhidl/transport -randroid.hardware:hardware/interfaces/ -randroid.dvr:frameworks/native/services/vr/vr_window_manager android.dvr.composer@1.0",
+ srcs: [
+ "IVrComposerClient.hal",
+ ],
+ out: [
+ "android/dvr/composer/1.0/IVrComposerClient.h",
+ "android/dvr/composer/1.0/IHwVrComposerClient.h",
+ "android/dvr/composer/1.0/BnVrComposerClient.h",
+ "android/dvr/composer/1.0/BpVrComposerClient.h",
+ "android/dvr/composer/1.0/BsVrComposerClient.h",
+ ],
+}
+
+cc_library_shared {
+ name: "android.dvr.composer@1.0",
+ generated_sources: ["android.dvr.composer@1.0_genc++"],
+ generated_headers: ["android.dvr.composer@1.0_genc++_headers"],
+ export_generated_headers: ["android.dvr.composer@1.0_genc++_headers"],
+ shared_libs: [
+ "libhidlbase",
+ "libhidltransport",
+ "libhwbinder",
+ "liblog",
+ "libutils",
+ "libcutils",
+ "android.hardware.graphics.composer@2.1",
+ "android.hidl.base@1.0",
+ ],
+ export_shared_lib_headers: [
+ "libhidlbase",
+ "libhidltransport",
+ "libhwbinder",
+ "libutils",
+ "android.hardware.graphics.composer@2.1",
+ "android.hidl.base@1.0",
+ ],
+}
diff --git a/services/vr/vr_window_manager/composer/1.0/IVrComposerClient.hal b/services/vr/vr_window_manager/composer/1.0/IVrComposerClient.hal
new file mode 100644
index 0000000..230a68a
--- /dev/null
+++ b/services/vr/vr_window_manager/composer/1.0/IVrComposerClient.hal
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+package android.dvr.composer@1.0;
+
+import android.hardware.graphics.composer@2.1::IComposerClient;
+
+interface IVrComposerClient
+ extends android.hardware.graphics.composer@2.1::IComposerClient {
+ /*
+ * Used to annotate the layer with additional information, which will be
+ * used to describe the content of the layer (ie: notification, permission,
+ * etc) which allows VR window manager to treat certain layer types
+ * specially.
+ *
+ * @param display is the display on which the layer was created.
+ * @param layer is the layer affected by the change.
+ * @param layer_type the type of the layer as described by the window
+ * manager.
+ * @param application_id the application id the layer belongs to.
+ * @return error is NONE upon success. Otherwise,
+ * BAD_DISPLAY when an invalid display handle was passed in.
+ * BAD_LAYER when an invalid layer handle was passed in.
+ *
+ * setLayerInfo(Display display,
+ * Layer layer,
+ * uint32_t layer_type,
+ * uint32_t application_id)
+ * generates(Error error);
+ */
+
+ enum VrCommand : int32_t {
+ OPCODE_SHIFT = android.hardware.graphics.composer@2.1::IComposerClient.Command:OPCODE_SHIFT,
+
+ SET_LAYER_INFO = 0x800 << OPCODE_SHIFT,
+ };
+};
diff --git a/services/vr/vr_window_manager/composer/impl/sync_timeline.cpp b/services/vr/vr_window_manager/composer/impl/sync_timeline.cpp
new file mode 100644
index 0000000..aa55aed
--- /dev/null
+++ b/services/vr/vr_window_manager/composer/impl/sync_timeline.cpp
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2016 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 "composer/impl/sync_timeline.h"
+
+#include <sys/cdefs.h>
+#include <sw_sync.h>
+#include <unistd.h>
+
+namespace android {
+namespace dvr {
+
+SyncTimeline::SyncTimeline() {}
+
+SyncTimeline::~SyncTimeline() {}
+
+bool SyncTimeline::Initialize() {
+ timeline_fd_.reset(sw_sync_timeline_create());
+ return timeline_fd_ >= 0;
+}
+
+int SyncTimeline::CreateFence(int time) {
+ return sw_sync_fence_create(timeline_fd_.get(), "dummy fence", time);
+}
+
+bool SyncTimeline::IncrementTimeline() {
+ return sw_sync_timeline_inc(timeline_fd_.get(), 1) == 0;
+}
+
+} // namespace dvr
+} // namespace android
diff --git a/services/vr/vr_window_manager/composer/impl/sync_timeline.h b/services/vr/vr_window_manager/composer/impl/sync_timeline.h
new file mode 100644
index 0000000..945acbd
--- /dev/null
+++ b/services/vr/vr_window_manager/composer/impl/sync_timeline.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2016 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.
+ */
+#ifndef VR_WINDOW_MANAGER_COMPOSER_IMPL_SYNC_TIMELINE_H_
+#define VR_WINDOW_MANAGER_COMPOSER_IMPL_SYNC_TIMELINE_H_
+
+#include <android-base/unique_fd.h>
+
+namespace android {
+namespace dvr {
+
+// TODO(dnicoara): Remove this and move to EGL based fences.
+class SyncTimeline {
+ public:
+ SyncTimeline();
+ ~SyncTimeline();
+
+ bool Initialize();
+
+ int CreateFence(int time);
+ bool IncrementTimeline();
+
+ private:
+ base::unique_fd timeline_fd_;
+
+ SyncTimeline(const SyncTimeline&) = delete;
+ void operator=(const SyncTimeline&) = delete;
+};
+
+} // namespace dvr
+} // namespace android
+
+#endif // VR_WINDOW_MANAGER_COMPOSER_IMPL_SYNC_TIMELINE_H_
diff --git a/services/vr/vr_window_manager/composer/impl/vr_composer_client.cpp b/services/vr/vr_window_manager/composer/impl/vr_composer_client.cpp
new file mode 100644
index 0000000..367acb7
--- /dev/null
+++ b/services/vr/vr_window_manager/composer/impl/vr_composer_client.cpp
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2016 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 <android/dvr/composer/1.0/IVrComposerClient.h>
+#include <hardware/gralloc.h>
+#include <hardware/gralloc1.h>
+#include <log/log.h>
+
+#include "vr_hwc.h"
+#include "vr_composer_client.h"
+
+namespace android {
+namespace dvr {
+
+using android::hardware::graphics::common::V1_0::PixelFormat;
+using android::dvr::composer::V1_0::IVrComposerClient;
+
+VrComposerClient::VrComposerClient(dvr::VrHwc& hal)
+ : ComposerClient(hal), mVrHal(hal) {}
+
+VrComposerClient::~VrComposerClient() {}
+
+std::unique_ptr<ComposerClient::CommandReader>
+VrComposerClient::createCommandReader() {
+ return std::unique_ptr<CommandReader>(new VrCommandReader(*this));
+}
+
+VrComposerClient::VrCommandReader::VrCommandReader(VrComposerClient& client)
+ : CommandReader(client), mVrClient(client), mVrHal(client.mVrHal) {}
+
+VrComposerClient::VrCommandReader::~VrCommandReader() {}
+
+bool VrComposerClient::VrCommandReader::parseCommand(
+ IComposerClient::Command command, uint16_t length) {
+ IVrComposerClient::VrCommand vrCommand =
+ static_cast<IVrComposerClient::VrCommand>(command);
+ switch (vrCommand) {
+ case IVrComposerClient::VrCommand::SET_LAYER_INFO:
+ return parseSetLayerInfo(length);
+ default:
+ return CommandReader::parseCommand(command, length);
+ }
+}
+
+bool VrComposerClient::VrCommandReader::parseSetLayerInfo(uint16_t length) {
+ if (length != 2) {
+ return false;
+ }
+
+ auto err = mVrHal.setLayerInfo(mDisplay, mLayer, read(), read());
+ if (err != Error::NONE) {
+ mWriter.setError(getCommandLoc(), err);
+ }
+
+ return true;
+}
+
+} // namespace dvr
+} // namespace android
diff --git a/services/vr/vr_window_manager/composer/impl/vr_composer_client.h b/services/vr/vr_window_manager/composer/impl/vr_composer_client.h
new file mode 100644
index 0000000..8f0c562
--- /dev/null
+++ b/services/vr/vr_window_manager/composer/impl/vr_composer_client.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2017 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.
+ */
+
+#ifndef VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_COMPOSER_CLIENT_H_
+#define VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_COMPOSER_CLIENT_H_
+
+#include <ComposerClient.h>
+#include <IComposerCommandBuffer.h>
+
+namespace android {
+namespace dvr {
+
+class VrHwc;
+
+using hardware::graphics::common::V1_0::PixelFormat;
+using hardware::graphics::composer::V2_1::implementation::ComposerClient;
+
+class VrComposerClient : public ComposerClient {
+ public:
+ VrComposerClient(android::dvr::VrHwc& hal);
+ virtual ~VrComposerClient();
+
+ private:
+ class VrCommandReader : public ComposerClient::CommandReader {
+ public:
+ VrCommandReader(VrComposerClient& client);
+ ~VrCommandReader() override;
+
+ bool parseCommand(IComposerClient::Command command,
+ uint16_t length) override;
+
+ private:
+ bool parseSetLayerInfo(uint16_t length);
+
+ VrComposerClient& mVrClient;
+ android::dvr::VrHwc& mVrHal;
+
+ VrCommandReader(const VrCommandReader&) = delete;
+ void operator=(const VrCommandReader&) = delete;
+ };
+
+ std::unique_ptr<CommandReader> createCommandReader() override;
+
+ dvr::VrHwc& mVrHal;
+
+ VrComposerClient(const VrComposerClient&) = delete;
+ void operator=(const VrComposerClient&) = delete;
+};
+
+} // namespace dvr
+} // namespace android
+
+#endif // VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_COMPOSER_CLIENT_H_
diff --git a/services/vr/vr_window_manager/composer/impl/vr_hwc.cpp b/services/vr/vr_window_manager/composer/impl/vr_hwc.cpp
new file mode 100644
index 0000000..d64a99a
--- /dev/null
+++ b/services/vr/vr_window_manager/composer/impl/vr_hwc.cpp
@@ -0,0 +1,531 @@
+/*
+ * Copyright 2016 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 "composer/impl/vr_hwc.h"
+
+#include <ui/Fence.h>
+#include <ui/GraphicBuffer.h>
+#include <ui/GraphicBufferMapper.h>
+
+#include <mutex>
+
+#include "composer/impl/sync_timeline.h"
+#include "composer/impl/vr_composer_client.h"
+
+using namespace android::hardware::graphics::common::V1_0;
+using namespace android::hardware::graphics::composer::V2_1;
+
+using android::hardware::hidl_handle;
+using android::hardware::hidl_string;
+using android::hardware::hidl_vec;
+using android::hardware::Return;
+using android::hardware::Void;
+
+namespace android {
+namespace dvr {
+namespace {
+
+using android::hardware::graphics::common::V1_0::PixelFormat;
+
+const Display kDefaultDisplayId = 1;
+const Config kDefaultConfigId = 1;
+
+} // namespace
+
+HwcDisplay::HwcDisplay() {}
+
+HwcDisplay::~HwcDisplay() {}
+
+bool HwcDisplay::Initialize() { return hwc_timeline_.Initialize(); }
+
+bool HwcDisplay::SetClientTarget(const native_handle_t* handle,
+ base::unique_fd fence) {
+ // OK, so this is where we cheat a lot because we don't have direct access to
+ // buffer information. Everything is hardcoded, but once gralloc1 is available
+ // we should use it to read buffer properties from the handle.
+ buffer_ = new GraphicBuffer(
+ 1080, 1920, PIXEL_FORMAT_RGBA_8888, 1,
+ GraphicBuffer::USAGE_HW_COMPOSER | GraphicBuffer::USAGE_HW_TEXTURE, 1088,
+ native_handle_clone(handle), true);
+ if (GraphicBufferMapper::get().registerBuffer(buffer_.get()) != OK) {
+ ALOGE("Failed to set client target");
+ return false;
+ }
+
+ fence_ = new Fence(fence.release());
+ return true;
+}
+
+HwcLayer* HwcDisplay::CreateLayer() {
+ uint64_t layer_id = layer_ids_++;
+ layers_.push_back(HwcLayer(layer_id));
+ return &layers_.back();
+}
+
+HwcLayer* HwcDisplay::GetLayer(Layer id) {
+ for (size_t i = 0; i < layers_.size(); ++i)
+ if (layers_[i].id == id) return &layers_[i];
+
+ return nullptr;
+}
+
+bool HwcDisplay::DestroyLayer(Layer id) {
+ for (auto it = layers_.begin(); it != layers_.end(); ++it) {
+ if (it->id == id) {
+ layers_.erase(it);
+ return true;
+ }
+ }
+
+ return false;
+}
+
+void HwcDisplay::GetChangedCompositionTypes(
+ std::vector<Layer>* layer_ids,
+ std::vector<IComposerClient::Composition>* types) {
+ for (const auto& layer : layers_) {
+ layer_ids->push_back(layer.id);
+ types->push_back(IComposerClient::Composition::CLIENT);
+ }
+}
+
+std::vector<ComposerView::ComposerLayer> HwcDisplay::GetFrame() {
+ // Increment the time the fence is signalled every time we get the
+ // presentation frame. This ensures that calling ReleaseFrame() only affects
+ // the current frame.
+ fence_time_++;
+
+ // TODO(dnicoara): Send the actual layers when we process layers as overlays.
+ ComposerView::ComposerLayer layer = {
+ .buffer = buffer_,
+ .fence = fence_.get() ? fence_ : new Fence(-1),
+ .display_frame = {0, 0, 1080, 1920},
+ .crop = {0.0f, 0.0f, 1080.0f, 1920.0f},
+ .blend_mode = IComposerClient::BlendMode::NONE,
+ };
+ return std::vector<ComposerView::ComposerLayer>(1, layer);
+}
+
+void HwcDisplay::GetReleaseFences(std::vector<Layer>* layer_ids,
+ std::vector<int>* fences) {
+ for (const auto& layer : layers_) {
+ layer_ids->push_back(layer.id);
+ fences->push_back(hwc_timeline_.CreateFence(fence_time_));
+ }
+}
+
+void HwcDisplay::ReleaseFrame() { hwc_timeline_.IncrementTimeline(); }
+
+VrHwc::VrHwc() {}
+
+VrHwc::~VrHwc() {}
+
+bool VrHwc::Initialize() { return display_.Initialize(); }
+
+bool VrHwc::hasCapability(Capability capability) const { return false; }
+
+void VrHwc::removeClient() {
+ std::lock_guard<std::mutex> guard(mutex_);
+ client_ = nullptr;
+}
+
+void VrHwc::enableCallback(bool enable) {
+ std::lock_guard<std::mutex> guard(mutex_);
+ if (enable && client_ != nullptr) {
+ client_.promote()->onHotplug(kDefaultDisplayId,
+ IComposerCallback::Connection::CONNECTED);
+ }
+}
+
+uint32_t VrHwc::getMaxVirtualDisplayCount() { return 0; }
+
+Error VrHwc::createVirtualDisplay(uint32_t width, uint32_t height,
+ PixelFormat* format, Display* outDisplay) {
+ *format = PixelFormat::RGBA_8888;
+ *outDisplay = 0;
+ return Error::NONE;
+}
+
+Error VrHwc::destroyVirtualDisplay(Display display) { return Error::NONE; }
+
+Error VrHwc::createLayer(Display display, Layer* outLayer) {
+ if (display != kDefaultDisplayId) {
+ return Error::BAD_DISPLAY;
+ }
+
+ std::lock_guard<std::mutex> guard(mutex_);
+
+ HwcLayer* layer = display_.CreateLayer();
+ *outLayer = layer->id;
+ return Error::NONE;
+}
+
+Error VrHwc::destroyLayer(Display display, Layer layer) {
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ std::lock_guard<std::mutex> guard(mutex_);
+
+ return display_.DestroyLayer(layer) ? Error::NONE : Error::BAD_LAYER;
+}
+
+Error VrHwc::getActiveConfig(Display display, Config* outConfig) {
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ *outConfig = kDefaultConfigId;
+ return Error::NONE;
+}
+
+Error VrHwc::getClientTargetSupport(Display display, uint32_t width,
+ uint32_t height, PixelFormat format,
+ Dataspace dataspace) {
+ return Error::NONE;
+}
+
+Error VrHwc::getColorModes(Display display, hidl_vec<ColorMode>* outModes) {
+ std::vector<ColorMode> color_modes(1, ColorMode::NATIVE);
+ *outModes = hidl_vec<ColorMode>(color_modes);
+ return Error::NONE;
+}
+
+Error VrHwc::getDisplayAttribute(Display display, Config config,
+ IComposerClient::Attribute attribute,
+ int32_t* outValue) {
+ if (display != kDefaultDisplayId) {
+ return Error::BAD_DISPLAY;
+ }
+
+ if (config != kDefaultConfigId) {
+ return Error::BAD_CONFIG;
+ }
+
+ switch (attribute) {
+ case IComposerClient::Attribute::WIDTH:
+ *outValue = 1080;
+ break;
+ case IComposerClient::Attribute::HEIGHT:
+ *outValue = 1920;
+ break;
+ case IComposerClient::Attribute::VSYNC_PERIOD:
+ *outValue = 1000 * 1000 * 1000 / 30; // 30fps
+ break;
+ case IComposerClient::Attribute::DPI_X:
+ case IComposerClient::Attribute::DPI_Y:
+ *outValue = 300 * 1000; // 300dpi
+ break;
+ default:
+ return Error::BAD_PARAMETER;
+ }
+
+ return Error::NONE;
+}
+
+Error VrHwc::getDisplayConfigs(Display display, hidl_vec<Config>* outConfigs) {
+ if (display != kDefaultDisplayId) {
+ return Error::BAD_DISPLAY;
+ }
+
+ std::vector<Config> configs(1, kDefaultConfigId);
+ *outConfigs = hidl_vec<Config>(configs);
+ return Error::NONE;
+}
+
+Error VrHwc::getDisplayName(Display display, hidl_string* outName) {
+ *outName = hidl_string();
+ return Error::NONE;
+}
+
+Error VrHwc::getDisplayType(Display display,
+ IComposerClient::DisplayType* outType) {
+ if (display != kDefaultDisplayId) {
+ *outType = IComposerClient::DisplayType::INVALID;
+ return Error::BAD_DISPLAY;
+ }
+
+ *outType = IComposerClient::DisplayType::PHYSICAL;
+ return Error::NONE;
+}
+
+Error VrHwc::getDozeSupport(Display display, bool* outSupport) {
+ *outSupport = false;
+ if (display == kDefaultDisplayId)
+ return Error::NONE;
+ else
+ return Error::BAD_DISPLAY;
+}
+
+Error VrHwc::getHdrCapabilities(Display display, hidl_vec<Hdr>* outTypes,
+ float* outMaxLuminance,
+ float* outMaxAverageLuminance,
+ float* outMinLuminance) {
+ *outMaxLuminance = 0;
+ *outMaxAverageLuminance = 0;
+ *outMinLuminance = 0;
+ return Error::NONE;
+}
+
+Error VrHwc::setActiveConfig(Display display, Config config) {
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ if (config != kDefaultConfigId) return Error::BAD_CONFIG;
+
+ return Error::NONE;
+}
+
+Error VrHwc::setColorMode(Display display, ColorMode mode) {
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ return Error::NONE;
+}
+
+Error VrHwc::setPowerMode(Display display, IComposerClient::PowerMode mode) {
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ return Error::NONE;
+}
+
+Error VrHwc::setVsyncEnabled(Display display, IComposerClient::Vsync enabled) {
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ return Error::NONE;
+}
+
+Error VrHwc::setColorTransform(Display display, const float* matrix,
+ int32_t hint) {
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ return Error::NONE;
+}
+
+Error VrHwc::setClientTarget(Display display, buffer_handle_t target,
+ int32_t acquireFence, int32_t dataspace,
+ const std::vector<hwc_rect_t>& damage) {
+ base::unique_fd fence(acquireFence);
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ if (target == nullptr) return Error::NONE;
+
+ std::lock_guard<std::mutex> guard(mutex_);
+
+ if (!display_.SetClientTarget(target, std::move(fence)))
+ return Error::BAD_PARAMETER;
+
+ return Error::NONE;
+}
+
+Error VrHwc::setOutputBuffer(Display display, buffer_handle_t buffer,
+ int32_t releaseFence) {
+ base::unique_fd fence(releaseFence);
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ return Error::NONE;
+}
+
+Error VrHwc::validateDisplay(
+ Display display, std::vector<Layer>* outChangedLayers,
+ std::vector<IComposerClient::Composition>* outCompositionTypes,
+ uint32_t* outDisplayRequestMask, std::vector<Layer>* outRequestedLayers,
+ std::vector<uint32_t>* outRequestMasks) {
+ if (display != kDefaultDisplayId) {
+ return Error::BAD_DISPLAY;
+ }
+
+ std::lock_guard<std::mutex> guard(mutex_);
+
+ display_.GetChangedCompositionTypes(outChangedLayers, outCompositionTypes);
+ return Error::NONE;
+}
+
+Error VrHwc::acceptDisplayChanges(Display display) { return Error::NONE; }
+
+Error VrHwc::presentDisplay(Display display, int32_t* outPresentFence,
+ std::vector<Layer>* outLayers,
+ std::vector<int32_t>* outReleaseFences) {
+ *outPresentFence = -1;
+ if (display != kDefaultDisplayId) {
+ return Error::BAD_DISPLAY;
+ }
+
+ std::lock_guard<std::mutex> guard(mutex_);
+
+ if (observer_)
+ observer_->OnNewFrame(display_.GetFrame());
+ else
+ display_.ReleaseFrame();
+
+ display_.GetReleaseFences(outLayers, outReleaseFences);
+ return Error::NONE;
+}
+
+Error VrHwc::setLayerCursorPosition(Display display, Layer layer, int32_t x,
+ int32_t y) {
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ return Error::NONE;
+}
+
+Error VrHwc::setLayerBuffer(Display display, Layer layer,
+ buffer_handle_t buffer, int32_t acquireFence) {
+ base::unique_fd fence(acquireFence);
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ return Error::NONE;
+}
+
+Error VrHwc::setLayerSurfaceDamage(Display display, Layer layer,
+ const std::vector<hwc_rect_t>& damage) {
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ return Error::NONE;
+}
+
+Error VrHwc::setLayerBlendMode(Display display, Layer layer, int32_t mode) {
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ return Error::NONE;
+}
+
+Error VrHwc::setLayerColor(Display display, Layer layer,
+ IComposerClient::Color color) {
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ return Error::NONE;
+}
+
+Error VrHwc::setLayerCompositionType(Display display, Layer layer,
+ int32_t type) {
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ return Error::NONE;
+}
+
+Error VrHwc::setLayerDataspace(Display display, Layer layer,
+ int32_t dataspace) {
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ return Error::NONE;
+}
+
+Error VrHwc::setLayerDisplayFrame(Display display, Layer layer,
+ const hwc_rect_t& frame) {
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ return Error::NONE;
+}
+
+Error VrHwc::setLayerPlaneAlpha(Display display, Layer layer, float alpha) {
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ return Error::NONE;
+}
+
+Error VrHwc::setLayerSidebandStream(Display display, Layer layer,
+ buffer_handle_t stream) {
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ return Error::NONE;
+}
+
+Error VrHwc::setLayerSourceCrop(Display display, Layer layer,
+ const hwc_frect_t& crop) {
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ return Error::NONE;
+}
+
+Error VrHwc::setLayerTransform(Display display, Layer layer,
+ int32_t transform) {
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ return Error::NONE;
+}
+
+Error VrHwc::setLayerVisibleRegion(Display display, Layer layer,
+ const std::vector<hwc_rect_t>& visible) {
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ return Error::NONE;
+}
+
+Error VrHwc::setLayerZOrder(Display display, Layer layer, uint32_t z) {
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ return Error::NONE;
+}
+
+Error VrHwc::setLayerInfo(Display display, Layer layer, uint32_t type,
+ uint32_t appId) {
+ if (display != kDefaultDisplayId) return Error::BAD_DISPLAY;
+
+ return Error::NONE;
+}
+
+Return<void> VrHwc::getCapabilities(getCapabilities_cb hidl_cb) {
+ hidl_cb(hidl_vec<Capability>());
+ return Void();
+}
+
+Return<void> VrHwc::dumpDebugInfo(dumpDebugInfo_cb hidl_cb) {
+ hidl_cb(hidl_string());
+ return Void();
+}
+
+Return<void> VrHwc::createClient(createClient_cb hidl_cb) {
+ std::lock_guard<std::mutex> guard(mutex_);
+
+ Error status = Error::NONE;
+ sp<VrComposerClient> client;
+ if (client_ == nullptr) {
+ client = new VrComposerClient(*this);
+ client->initialize();
+ } else {
+ ALOGE("Already have a client");
+ status = Error::NO_RESOURCES;
+ }
+
+ client_ = client;
+ hidl_cb(status, client);
+ return Void();
+}
+
+void VrHwc::RegisterObserver(Observer* observer) {
+ std::lock_guard<std::mutex> guard(mutex_);
+ if (observer_)
+ ALOGE("Overwriting observer");
+ else
+ observer_ = observer;
+}
+
+void VrHwc::UnregisterObserver(Observer* observer) {
+ std::lock_guard<std::mutex> guard(mutex_);
+ if (observer != observer_)
+ ALOGE("Trying to unregister unknown observer");
+ else
+ observer_ = nullptr;
+}
+
+void VrHwc::ReleaseFrame() {
+ std::lock_guard<std::mutex> guard(mutex_);
+ display_.ReleaseFrame();
+}
+
+ComposerView* GetComposerViewFromIComposer(
+ hardware::graphics::composer::V2_1::IComposer* composer) {
+ return static_cast<VrHwc*>(composer);
+}
+
+IComposer* HIDL_FETCH_IComposer(const char*) { return new VrHwc(); }
+
+} // namespace dvr
+} // namespace android
diff --git a/services/vr/vr_window_manager/composer/impl/vr_hwc.h b/services/vr/vr_window_manager/composer/impl/vr_hwc.h
new file mode 100644
index 0000000..fbbf028
--- /dev/null
+++ b/services/vr/vr_window_manager/composer/impl/vr_hwc.h
@@ -0,0 +1,266 @@
+/*
+ * Copyright 2016 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.
+ */
+#ifndef VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_HWC_H_
+#define VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_HWC_H_
+
+#include <android/hardware/graphics/composer/2.1/IComposer.h>
+#include <ComposerBase.h>
+#include <ui/GraphicBufferMapper.h>
+#include <utils/StrongPointer.h>
+
+#include <mutex>
+
+#include "composer/impl/sync_timeline.h"
+
+using namespace android::hardware::graphics::common::V1_0;
+using namespace android::hardware::graphics::composer::V2_1;
+
+using android::hardware::hidl_handle;
+using android::hardware::hidl_string;
+using android::hardware::hidl_vec;
+using android::hardware::Return;
+using android::hardware::Void;
+
+namespace android {
+
+class Fence;
+class GraphicBuffer;
+
+namespace dvr {
+
+class VrComposerClient;
+
+using android::hardware::graphics::common::V1_0::PixelFormat;
+using android::hardware::graphics::composer::V2_1::implementation::ComposerBase;
+
+class ComposerView {
+ public:
+ struct ComposerLayer {
+ using Recti = hardware::graphics::composer::V2_1::IComposerClient::Rect;
+ using Rectf = hardware::graphics::composer::V2_1::IComposerClient::FRect;
+ using BlendMode =
+ hardware::graphics::composer::V2_1::IComposerClient::BlendMode;
+
+ // TODO(dnicoara): Add all layer properties. For now just the basics to get
+ // it going.
+ sp<GraphicBuffer> buffer;
+ sp<Fence> fence;
+ Recti display_frame;
+ Rectf crop;
+ BlendMode blend_mode;
+ };
+
+ using Frame = std::vector<ComposerLayer>;
+
+ class Observer {
+ public:
+ virtual ~Observer() {}
+
+ // Returns a list of layers that need to be shown together. Layers are
+ // returned in z-order, with the lowest layer first.
+ virtual void OnNewFrame(const Frame& frame) = 0;
+ };
+
+ virtual ~ComposerView() {}
+
+ virtual void RegisterObserver(Observer* observer) = 0;
+ virtual void UnregisterObserver(Observer* observer) = 0;
+
+ // Called to release the oldest frame received by the observer.
+ virtual void ReleaseFrame() = 0;
+};
+
+struct HwcLayer {
+ HwcLayer(Layer new_id) : id(new_id) {}
+
+ Layer id;
+};
+
+class HwcDisplay {
+ public:
+ HwcDisplay();
+ ~HwcDisplay();
+
+ bool Initialize();
+
+ HwcLayer* CreateLayer();
+ bool DestroyLayer(Layer id);
+ HwcLayer* GetLayer(Layer id);
+
+ bool SetClientTarget(const native_handle_t* handle, base::unique_fd fence);
+
+ void GetChangedCompositionTypes(
+ std::vector<Layer>* layer_ids,
+ std::vector<IComposerClient::Composition>* composition);
+
+ std::vector<ComposerView::ComposerLayer> GetFrame();
+
+ void GetReleaseFences(
+ std::vector<Layer>* layer_ids, std::vector<int>* fences);
+
+ void ReleaseFrame();
+
+ private:
+ // The client target buffer and the associated fence.
+ // TODO(dnicoara): Replace this with a list of ComposerView::ComposerLayer.
+ sp<GraphicBuffer> buffer_;
+ sp<Fence> fence_;
+
+ // List of currently active layers.
+ std::vector<HwcLayer> layers_;
+
+ // Layer ID generator.
+ uint64_t layer_ids_ = 1;
+
+ // Creates software sync fences used to signal releasing frames.
+ SyncTimeline hwc_timeline_;
+
+ // Keeps track of the current fence time. Used in conjunction with
+ // |hwc_timeline_| to properly signal frame release times. Allows the observer
+ // to receive multiple presentation frames without calling ReleaseFrame() in
+ // between each presentation. When the observer is ready to release a frame
+ // only the oldest presentation frame is affected by the release.
+ int fence_time_ = 0;
+
+ HwcDisplay(const HwcDisplay&) = delete;
+ void operator=(const HwcDisplay&) = delete;
+};
+
+class VrHwc : public IComposer, public ComposerBase, public ComposerView {
+ public:
+ VrHwc();
+ ~VrHwc() override;
+
+ bool Initialize();
+
+ bool hasCapability(Capability capability) const;
+
+ Error setLayerInfo(Display display, Layer layer, uint32_t type,
+ uint32_t appId);
+
+ // ComposerBase
+ void removeClient() override;
+ void enableCallback(bool enable) override;
+
+ uint32_t getMaxVirtualDisplayCount() override;
+ Error createVirtualDisplay(uint32_t width, uint32_t height,
+ PixelFormat* format, Display* outDisplay) override;
+ Error destroyVirtualDisplay(Display display) override;
+
+ Error createLayer(Display display, Layer* outLayer) override;
+ Error destroyLayer(Display display, Layer layer) override;
+
+ Error getActiveConfig(Display display, Config* outConfig) override;
+ Error getClientTargetSupport(Display display,
+ uint32_t width, uint32_t height,
+ PixelFormat format, Dataspace dataspace) override;
+ Error getColorModes(Display display, hidl_vec<ColorMode>* outModes) override;
+ Error getDisplayAttribute(Display display, Config config,
+ IComposerClient::Attribute attribute, int32_t* outValue) override;
+ Error getDisplayConfigs(Display display, hidl_vec<Config>* outConfigs) override;
+ Error getDisplayName(Display display, hidl_string* outName) override;
+ Error getDisplayType(Display display,
+ IComposerClient::DisplayType* outType) override;
+ Error getDozeSupport(Display display, bool* outSupport) override;
+ Error getHdrCapabilities(Display display, hidl_vec<Hdr>* outTypes,
+ float* outMaxLuminance, float* outMaxAverageLuminance,
+ float* outMinLuminance) override;
+
+ Error setActiveConfig(Display display, Config config) override;
+ Error setColorMode(Display display, ColorMode mode) override;
+ Error setPowerMode(Display display, IComposerClient::PowerMode mode) override;
+ Error setVsyncEnabled(Display display, IComposerClient::Vsync enabled) override;
+
+ Error setColorTransform(Display display, const float* matrix,
+ int32_t hint) override;
+ Error setClientTarget(Display display, buffer_handle_t target,
+ int32_t acquireFence, int32_t dataspace,
+ const std::vector<hwc_rect_t>& damage) override;
+ Error setOutputBuffer(Display display, buffer_handle_t buffer,
+ int32_t releaseFence) override;
+ Error validateDisplay(Display display,
+ std::vector<Layer>* outChangedLayers,
+ std::vector<IComposerClient::Composition>* outCompositionTypes,
+ uint32_t* outDisplayRequestMask,
+ std::vector<Layer>* outRequestedLayers,
+ std::vector<uint32_t>* outRequestMasks) override;
+ Error acceptDisplayChanges(Display display) override;
+ Error presentDisplay(Display display, int32_t* outPresentFence,
+ std::vector<Layer>* outLayers,
+ std::vector<int32_t>* outReleaseFences) override;
+
+ Error setLayerCursorPosition(Display display, Layer layer,
+ int32_t x, int32_t y) override;
+ Error setLayerBuffer(Display display, Layer layer,
+ buffer_handle_t buffer, int32_t acquireFence) override;
+ Error setLayerSurfaceDamage(Display display, Layer layer,
+ const std::vector<hwc_rect_t>& damage) override;
+ Error setLayerBlendMode(Display display, Layer layer, int32_t mode) override;
+ Error setLayerColor(Display display, Layer layer,
+ IComposerClient::Color color) override;
+ Error setLayerCompositionType(Display display, Layer layer,
+ int32_t type) override;
+ Error setLayerDataspace(Display display, Layer layer,
+ int32_t dataspace) override;
+ Error setLayerDisplayFrame(Display display, Layer layer,
+ const hwc_rect_t& frame) override;
+ Error setLayerPlaneAlpha(Display display, Layer layer, float alpha) override;
+ Error setLayerSidebandStream(Display display, Layer layer,
+ buffer_handle_t stream) override;
+ Error setLayerSourceCrop(Display display, Layer layer,
+ const hwc_frect_t& crop) override;
+ Error setLayerTransform(Display display, Layer layer,
+ int32_t transform) override;
+ Error setLayerVisibleRegion(Display display, Layer layer,
+ const std::vector<hwc_rect_t>& visible) override;
+ Error setLayerZOrder(Display display, Layer layer, uint32_t z) override;
+
+ // IComposer:
+ Return<void> getCapabilities(getCapabilities_cb hidl_cb) override;
+ Return<void> dumpDebugInfo(dumpDebugInfo_cb hidl_cb) override;
+ Return<void> createClient(createClient_cb hidl_cb) override;
+
+ // ComposerView:
+ void RegisterObserver(Observer* observer) override;
+ void UnregisterObserver(Observer* observer) override;
+ void ReleaseFrame() override;
+
+ private:
+ wp<VrComposerClient> client_;
+ sp<IComposerCallback> callbacks_;
+
+ // Guard access to internal state from binder threads.
+ std::mutex mutex_;
+
+ HwcDisplay display_;
+
+ Observer* observer_ = nullptr;
+
+ VrHwc(const VrHwc&) = delete;
+ void operator=(const VrHwc&) = delete;
+};
+
+
+ComposerView* GetComposerViewFromIComposer(
+ hardware::graphics::composer::V2_1::IComposer* composer);
+
+hardware::graphics::composer::V2_1::IComposer* HIDL_FETCH_IComposer(
+ const char* name);
+
+} // namespace dvr
+} // namespace android
+
+#endif // VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_HWC_H_
diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
index 93b90d0..b8a5c1c 100644
--- a/vulkan/api/vulkan.api
+++ b/vulkan/api/vulkan.api
@@ -150,7 +150,7 @@
@extension("VK_NVX_device_generated_commands") define VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 1
@extension("VK_NVX_device_generated_commands") define VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NVX_device_generated_commands"
-@extension("VK_KHR_swapchain_front_buffered") define VK_KHR_SWAPCHAIN_FRONT_BUFFERED_SPEC_VERSION 2
+@extension("VK_KHR_swapchain_front_buffered") define VK_KHR_SWAPCHAIN_FRONT_BUFFERED_SPEC_VERSION 1
@extension("VK_KHR_swapchain_front_buffered") define VK_KHR_SWAPCHAIN_FRONT_BUFFERED_EXTENSION_NAME "VK_KHR_swapchain_front_buffered"
diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
index 5d38ff9..1bf37dd 100644
--- a/vulkan/include/vulkan/vulkan.h
+++ b/vulkan/include/vulkan/vulkan.h
@@ -3887,7 +3887,7 @@
} VkPresentRegionsKHR;
#define VK_KHR_swapchain_front_buffered 1
-#define VK_KHR_SWAPCHAIN_FRONT_BUFFERED_SPEC_VERSION 2
+#define VK_KHR_SWAPCHAIN_FRONT_BUFFERED_SPEC_VERSION 1
#define VK_KHR_SWAPCHAIN_FRONT_BUFFERED_EXTENSION_NAME "VK_KHR_swapchain_front_buffered"
typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain);
@@ -4146,8 +4146,7 @@
#define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing"
typedef struct VkRefreshCycleDurationGOOGLE {
- uint64_t minRefreshDuration;
- uint64_t maxRefreshDuration;
+ uint64_t refreshDuration;
} VkRefreshCycleDurationGOOGLE;
typedef struct VkPastPresentationTimingGOOGLE {
diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
index 08eee37..338462a 100644
--- a/vulkan/libvulkan/swapchain.cpp
+++ b/vulkan/libvulkan/swapchain.cpp
@@ -197,21 +197,17 @@
frame_timestamps_enabled(false) {
timing.clear();
ANativeWindow* window = surface.window.get();
- int64_t min_rdur;
- int64_t max_rdur;
- native_window_get_refresh_cycle_period(
+ int64_t rdur;
+ native_window_get_refresh_cycle_duration(
window,
- &min_rdur,
- &max_rdur);
- min_refresh_duration = static_cast<uint64_t>(min_rdur);
- max_refresh_duration = static_cast<uint64_t>(max_rdur);
+ &rdur);
+ refresh_duration = static_cast<uint64_t>(rdur);
}
Surface& surface;
uint32_t num_images;
bool frame_timestamps_enabled;
- uint64_t min_refresh_duration;
- uint64_t max_refresh_duration;
+ uint64_t refresh_duration;
struct Image {
Image() : image(VK_NULL_HANDLE), dequeue_fence(-1), dequeued(false) {}
@@ -356,7 +352,7 @@
// timestamps to calculate the info that should
// be reported to the user:
//
- ti->calculate(swapchain.min_refresh_duration);
+ ti->calculate(swapchain.refresh_duration);
num_ready++;
}
break;
@@ -1288,8 +1284,7 @@
Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
VkResult result = VK_SUCCESS;
- pDisplayTimingProperties->minRefreshDuration = swapchain.min_refresh_duration;
- pDisplayTimingProperties->maxRefreshDuration = swapchain.max_refresh_duration;
+ pDisplayTimingProperties->refreshDuration = swapchain.refresh_duration;
return result;
}
diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
index 89c65af..55f7f19 100644
--- a/vulkan/nulldrv/null_driver.cpp
+++ b/vulkan/nulldrv/null_driver.cpp
@@ -269,15 +269,8 @@
layer_name);
}
-// NOTE: Change this to zero to report and extension, which can be useful
-// for testing changes to the loader.
-#if 1
- (void)properties; // unused
- *count = 0;
- return VK_SUCCESS;
-#else
const VkExtensionProperties kExtensions[] = {
- {VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION}};
+ {VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION}};
const uint32_t kExtensionsCount =
sizeof(kExtensions) / sizeof(kExtensions[0]);
@@ -286,7 +279,6 @@
if (properties)
std::copy(kExtensions, kExtensions + *count, properties);
return *count < kExtensionsCount ? VK_INCOMPLETE : VK_SUCCESS;
-#endif
}
VKAPI_ATTR
@@ -310,6 +302,10 @@
for (uint32_t i = 0; i < create_info->enabledExtensionCount; i++) {
if (strcmp(create_info->ppEnabledExtensionNames[i],
+ VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME) == 0) {
+ ALOGV("instance extension '%s' requested",
+ create_info->ppEnabledExtensionNames[i]);
+ } else if (strcmp(create_info->ppEnabledExtensionNames[i],
VK_EXT_DEBUG_REPORT_EXTENSION_NAME) == 0) {
ALOGV("instance extension '%s' requested",
create_info->ppEnabledExtensionNames[i]);
@@ -514,6 +510,11 @@
};
}
+void GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physical_device,
+ VkPhysicalDeviceProperties2KHR* properties) {
+ GetPhysicalDeviceProperties(physical_device, &properties->properties);
+}
+
void GetPhysicalDeviceQueueFamilyProperties(
VkPhysicalDevice,
uint32_t* count,
@@ -529,6 +530,12 @@
}
}
+void GetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physical_device, uint32_t* count, VkQueueFamilyProperties2KHR* properties) {
+ // note: even though multiple structures, this is safe to forward in this
+ // case since we only expose one queue family.
+ GetPhysicalDeviceQueueFamilyProperties(physical_device, count, properties ? &properties->queueFamilyProperties : nullptr);
+}
+
void GetPhysicalDeviceMemoryProperties(
VkPhysicalDevice,
VkPhysicalDeviceMemoryProperties* properties) {
@@ -544,6 +551,10 @@
properties->memoryHeaps[0].flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT;
}
+void GetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physical_device, VkPhysicalDeviceMemoryProperties2KHR* properties) {
+ GetPhysicalDeviceMemoryProperties(physical_device, &properties->memoryProperties);
+}
+
void GetPhysicalDeviceFeatures(VkPhysicalDevice /*gpu*/,
VkPhysicalDeviceFeatures* features) {
*features = VkPhysicalDeviceFeatures{
@@ -605,6 +616,10 @@
};
}
+void GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physical_device, VkPhysicalDeviceFeatures2KHR* features) {
+ GetPhysicalDeviceFeatures(physical_device, &features->features);
+}
+
// -----------------------------------------------------------------------------
// Device
@@ -1083,11 +1098,22 @@
ALOGV("TODO: vk%s", __FUNCTION__);
}
+void GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2KHR* pFormatProperties) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+}
+
VkResult GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
ALOGV("TODO: vk%s", __FUNCTION__);
return VK_SUCCESS;
}
+VkResult GetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo,
+ VkImageFormatProperties2KHR* pImageFormatProperties) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+ return VK_SUCCESS;
+}
+
VkResult EnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties) {
ALOGV("TODO: vk%s", __FUNCTION__);
return VK_SUCCESS;
@@ -1140,6 +1166,14 @@
ALOGV("TODO: vk%s", __FUNCTION__);
}
+void GetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceSparseImageFormatInfo2KHR const* pInfo,
+ unsigned int* pNumProperties,
+ VkSparseImageFormatProperties2KHR* pProperties) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+}
+
+
VkResult QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) {
ALOGV("TODO: vk%s", __FUNCTION__);
return VK_SUCCESS;
diff --git a/vulkan/nulldrv/null_driver.tmpl b/vulkan/nulldrv/null_driver.tmpl
index 209d61d..ce15517 100644
--- a/vulkan/nulldrv/null_driver.tmpl
+++ b/vulkan/nulldrv/null_driver.tmpl
@@ -205,5 +205,6 @@
{{$ext := index $.Arguments 0}}
{{ if eq $ext "VK_ANDROID_native_buffer"}}true
{{else if eq $ext "VK_EXT_debug_report"}}true
+ {{else if eq $ext "VK_KHR_get_physical_device_properties2"}}true
{{end}}
{{end}}
diff --git a/vulkan/nulldrv/null_driver_gen.cpp b/vulkan/nulldrv/null_driver_gen.cpp
index 5ae31a2..7cbbdb1 100644
--- a/vulkan/nulldrv/null_driver_gen.cpp
+++ b/vulkan/nulldrv/null_driver_gen.cpp
@@ -171,12 +171,19 @@
{"vkGetImageSubresourceLayout", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetImageSubresourceLayout>(GetImageSubresourceLayout))},
{"vkGetInstanceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetInstanceProcAddr>(GetInstanceProcAddr))},
{"vkGetPhysicalDeviceFeatures", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceFeatures>(GetPhysicalDeviceFeatures))},
+ {"vkGetPhysicalDeviceFeatures2KHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceFeatures2KHR>(GetPhysicalDeviceFeatures2KHR))},
{"vkGetPhysicalDeviceFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceFormatProperties>(GetPhysicalDeviceFormatProperties))},
+ {"vkGetPhysicalDeviceFormatProperties2KHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceFormatProperties2KHR>(GetPhysicalDeviceFormatProperties2KHR))},
{"vkGetPhysicalDeviceImageFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceImageFormatProperties>(GetPhysicalDeviceImageFormatProperties))},
+ {"vkGetPhysicalDeviceImageFormatProperties2KHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceImageFormatProperties2KHR>(GetPhysicalDeviceImageFormatProperties2KHR))},
{"vkGetPhysicalDeviceMemoryProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceMemoryProperties>(GetPhysicalDeviceMemoryProperties))},
+ {"vkGetPhysicalDeviceMemoryProperties2KHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceMemoryProperties2KHR>(GetPhysicalDeviceMemoryProperties2KHR))},
{"vkGetPhysicalDeviceProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceProperties>(GetPhysicalDeviceProperties))},
+ {"vkGetPhysicalDeviceProperties2KHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceProperties2KHR>(GetPhysicalDeviceProperties2KHR))},
{"vkGetPhysicalDeviceQueueFamilyProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceQueueFamilyProperties>(GetPhysicalDeviceQueueFamilyProperties))},
+ {"vkGetPhysicalDeviceQueueFamilyProperties2KHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR>(GetPhysicalDeviceQueueFamilyProperties2KHR))},
{"vkGetPhysicalDeviceSparseImageFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceSparseImageFormatProperties>(GetPhysicalDeviceSparseImageFormatProperties))},
+ {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR>(GetPhysicalDeviceSparseImageFormatProperties2KHR))},
{"vkGetPipelineCacheData", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPipelineCacheData>(GetPipelineCacheData))},
{"vkGetQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetQueryPoolResults>(GetQueryPoolResults))},
{"vkGetRenderAreaGranularity", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetRenderAreaGranularity>(GetRenderAreaGranularity))},
diff --git a/vulkan/nulldrv/null_driver_gen.h b/vulkan/nulldrv/null_driver_gen.h
index 25a4371..cfc14dd 100644
--- a/vulkan/nulldrv/null_driver_gen.h
+++ b/vulkan/nulldrv/null_driver_gen.h
@@ -172,6 +172,13 @@
VKAPI_ATTR VkResult CreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);
VKAPI_ATTR void DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator);
VKAPI_ATTR void DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage);
+VKAPI_ATTR void GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR* pFeatures);
+VKAPI_ATTR void GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2KHR* pProperties);
+VKAPI_ATTR void GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2KHR* pFormatProperties);
+VKAPI_ATTR VkResult GetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, VkImageFormatProperties2KHR* pImageFormatProperties);
+VKAPI_ATTR void GetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR* pQueueFamilyProperties);
+VKAPI_ATTR void GetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties);
+VKAPI_ATTR void GetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2KHR* pProperties);
VKAPI_ATTR VkResult GetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage);
VKAPI_ATTR VkResult AcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore, VkFence fence);
VKAPI_ATTR VkResult QueueSignalReleaseImageANDROID(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image, int* pNativeFenceFd);