Add BufferHub backend for android::view::Surface
This CL allows BufferHubProducer to be used as alternative backend of
parcelable Surface.
When sent over binder, BufferHubProducer serializes itself differently
from Binder-based IGBP objects. Instead of writing to a Parcel object as
strong binder object, BufferHubProducer asks libbufferhubqueue to
generate a BufferHubQueueParcelable object (which packs all the FDs
representing the BufferHub channel).
When received from a binder interface, BufferHubProducer object can be
reconstructed from the BufferHubQueueParcelable object. The newly
constructed object has all the FDs (i.e. UDS channels) directly
connected to bufferhubd. Thus, on going buffer transport operations can
happen directly between the receiving process and bufferhubd. This
elimates one extra binder hop.
Bug: 37517761
Bug: 70046255
Test: libgui_test, buffer_transport_benchmark,
buffer_hub_queue_producer-test, dvr_api-test,
SurfaceParcelable_test
Change-Id: I78bd879f36d3196f3d74c76c79d27467740792f7
diff --git a/libs/gui/tests/SurfaceParcelable_test.cpp b/libs/gui/tests/SurfaceParcelable_test.cpp
new file mode 100644
index 0000000..99a8a7a
--- /dev/null
+++ b/libs/gui/tests/SurfaceParcelable_test.cpp
@@ -0,0 +1,169 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "SurfaceParcelable_test"
+
+#include <gtest/gtest.h>
+
+#include <binder/IServiceManager.h>
+#include <binder/ProcessState.h>
+#include <gui/BufferHubProducer.h>
+#include <gui/BufferQueue.h>
+#include <gui/view/Surface.h>
+#include <utils/Log.h>
+
+namespace android {
+
+static const String16 kTestServiceName = String16("SurfaceParcelableTestService");
+static const String16 kSurfaceName = String16("TEST_SURFACE");
+static const uint32_t kBufferWidth = 100;
+static const uint32_t kBufferHeight = 1;
+static const uint32_t kBufferFormat = HAL_PIXEL_FORMAT_BLOB;
+
+enum SurfaceParcelableTestServiceCode {
+ CREATE_BUFFER_QUEUE_SURFACE = IBinder::FIRST_CALL_TRANSACTION,
+ CREATE_BUFFER_HUB_SURFACE,
+};
+
+class SurfaceParcelableTestService : public BBinder {
+public:
+ SurfaceParcelableTestService() {
+ // BufferQueue
+ BufferQueue::createBufferQueue(&mBufferQueueProducer, &mBufferQueueConsumer);
+
+ // BufferHub
+ dvr::ProducerQueueConfigBuilder configBuilder;
+ mProducerQueue = dvr::ProducerQueue::Create(configBuilder.SetDefaultWidth(kBufferWidth)
+ .SetDefaultHeight(kBufferHeight)
+ .SetDefaultFormat(kBufferFormat)
+ .SetMetadata<DvrNativeBufferMetadata>()
+ .Build(),
+ dvr::UsagePolicy{});
+ mBufferHubProducer = BufferHubProducer::Create(mProducerQueue);
+ }
+
+ ~SurfaceParcelableTestService() = default;
+
+ virtual status_t onTransact(uint32_t code, const Parcel& /*data*/, Parcel* reply,
+ uint32_t /*flags*/ = 0) {
+ switch (code) {
+ case CREATE_BUFFER_QUEUE_SURFACE: {
+ view::Surface surfaceShim;
+ surfaceShim.name = kSurfaceName;
+ surfaceShim.graphicBufferProducer = mBufferQueueProducer;
+ return surfaceShim.writeToParcel(reply);
+ }
+ case CREATE_BUFFER_HUB_SURFACE: {
+ view::Surface surfaceShim;
+ surfaceShim.name = kSurfaceName;
+ surfaceShim.graphicBufferProducer = mBufferHubProducer;
+ return surfaceShim.writeToParcel(reply);
+ }
+ default:
+ return UNKNOWN_TRANSACTION;
+ };
+ }
+
+protected:
+ sp<IGraphicBufferProducer> mBufferQueueProducer;
+ sp<IGraphicBufferConsumer> mBufferQueueConsumer;
+
+ std::shared_ptr<dvr::ProducerQueue> mProducerQueue;
+ sp<IGraphicBufferProducer> mBufferHubProducer;
+};
+
+static int runBinderServer() {
+ ProcessState::self()->startThreadPool();
+
+ sp<IServiceManager> sm = defaultServiceManager();
+ sp<SurfaceParcelableTestService> service = new SurfaceParcelableTestService;
+ sm->addService(kTestServiceName, service, false);
+
+ ALOGI("Binder server running...");
+
+ while (true) {
+ int stat, retval;
+ retval = wait(&stat);
+ if (retval == -1 && errno == ECHILD) {
+ break;
+ }
+ }
+
+ ALOGI("Binder server exiting...");
+ return 0;
+}
+
+class SurfaceParcelableTest : public ::testing::TestWithParam<uint32_t> {
+protected:
+ virtual void SetUp() {
+ mService = defaultServiceManager()->getService(kTestServiceName);
+ if (mService == nullptr) {
+ ALOGE("Failed to connect to the test service.");
+ return;
+ }
+
+ ALOGI("Binder service is ready for client.");
+ }
+
+ status_t GetSurface(view::Surface* surfaceShim) {
+ ALOGI("...Test: %d", GetParam());
+
+ uint32_t opCode = GetParam();
+ Parcel data;
+ Parcel reply;
+ status_t error = mService->transact(opCode, data, &reply);
+ if (error != NO_ERROR) {
+ ALOGE("Failed to get surface over binder, error=%d.", error);
+ return error;
+ }
+
+ error = surfaceShim->readFromParcel(&reply);
+ if (error != NO_ERROR) {
+ ALOGE("Failed to get surface from parcel, error=%d.", error);
+ return error;
+ }
+
+ return NO_ERROR;
+ }
+
+private:
+ sp<IBinder> mService;
+};
+
+TEST_P(SurfaceParcelableTest, SendOverBinder) {
+ view::Surface surfaceShim;
+ EXPECT_EQ(GetSurface(&surfaceShim), NO_ERROR);
+ EXPECT_EQ(surfaceShim.name, kSurfaceName);
+ EXPECT_FALSE(surfaceShim.graphicBufferProducer == nullptr);
+}
+
+INSTANTIATE_TEST_CASE_P(SurfaceBackends, SurfaceParcelableTest,
+ ::testing::Values(CREATE_BUFFER_QUEUE_SURFACE, CREATE_BUFFER_HUB_SURFACE));
+
+} // namespace android
+
+int main(int argc, char** argv) {
+ pid_t pid = fork();
+ if (pid == 0) {
+ android::ProcessState::self()->startThreadPool();
+ ::testing::InitGoogleTest(&argc, argv);
+ return RUN_ALL_TESTS();
+
+ } else {
+ ALOGI("Test process pid: %d.", pid);
+ return android::runBinderServer();
+ }
+}