Merge "Allow destroySurface to get called in transaction."
diff --git a/cmds/atrace/atrace.cpp b/cmds/atrace/atrace.cpp
index 1b90579..c92a127 100644
--- a/cmds/atrace/atrace.cpp
+++ b/cmds/atrace/atrace.cpp
@@ -94,6 +94,7 @@
static const TracingCategory k_categories[] = {
{ "gfx", "Graphics", ATRACE_TAG_GRAPHICS, {
{ OPT, "events/mdss/enable" },
+ { OPT, "events/sde/enable" },
} },
{ "input", "Input", ATRACE_TAG_INPUT, { } },
{ "view", "View System", ATRACE_TAG_VIEW, { } },
diff --git a/cmds/installd/dexopt.cpp b/cmds/installd/dexopt.cpp
index b456507..2a7ad61 100644
--- a/cmds/installd/dexopt.cpp
+++ b/cmds/installd/dexopt.cpp
@@ -223,7 +223,7 @@
const char* input_file_name, const char* output_file_name, int swap_fd,
const char* instruction_set, const char* compiler_filter,
bool debuggable, bool post_bootcomplete, bool background_job_compile, int profile_fd,
- const char* class_loader_context, int target_sdk_version, bool disable_hidden_api_checks,
+ const char* class_loader_context, int target_sdk_version, bool enable_hidden_api_checks,
int dex_metadata_fd) {
static const unsigned int MAX_INSTRUCTION_SET_LEN = 7;
@@ -452,7 +452,7 @@
+ (disable_cdex ? 1 : 0)
+ (generate_minidebug_info ? 1 : 0)
+ (target_sdk_version != 0 ? 2 : 0)
- + (disable_hidden_api_checks ? 2 : 0)
+ + (enable_hidden_api_checks ? 2 : 0)
+ (dex_metadata_fd > -1 ? 1 : 0)];
int i = 0;
argv[i++] = dex2oat_bin;
@@ -527,9 +527,9 @@
argv[i++] = RUNTIME_ARG;
argv[i++] = target_sdk_version_arg;
}
- if (disable_hidden_api_checks) {
+ if (enable_hidden_api_checks) {
argv[i++] = RUNTIME_ARG;
- argv[i++] = "-Xno-hidden-api-checks";
+ argv[i++] = "-Xhidden-api-checks";
}
if (dex_metadata_fd > -1) {
@@ -1887,7 +1887,7 @@
bool profile_guided = (dexopt_flags & DEXOPT_PROFILE_GUIDED) != 0;
bool is_secondary_dex = (dexopt_flags & DEXOPT_SECONDARY_DEX) != 0;
bool background_job_compile = (dexopt_flags & DEXOPT_IDLE_BACKGROUND_JOB) != 0;
- bool disable_hidden_api_checks = (dexopt_flags & DEXOPT_DISABLE_HIDDEN_API_CHECKS) != 0;
+ bool enable_hidden_api_checks = (dexopt_flags & DEXOPT_ENABLE_HIDDEN_API_CHECKS) != 0;
// Check if we're dealing with a secondary dex file and if we need to compile it.
std::string oat_dir_str;
@@ -1993,7 +1993,7 @@
reference_profile_fd.get(),
class_loader_context,
target_sdk_version,
- disable_hidden_api_checks,
+ enable_hidden_api_checks,
dex_metadata_fd.get());
_exit(68); /* only get here on exec failure */
} else {
diff --git a/cmds/installd/installd_constants.h b/cmds/installd/installd_constants.h
index 9b6714d..06c83e4 100644
--- a/cmds/installd/installd_constants.h
+++ b/cmds/installd/installd_constants.h
@@ -52,7 +52,7 @@
// Tells the compiler that it is invoked from the background service. This
// controls whether extra debugging flags can be used (taking more compile time.)
constexpr int DEXOPT_IDLE_BACKGROUND_JOB = 1 << 9;
-constexpr int DEXOPT_DISABLE_HIDDEN_API_CHECKS = 1 << 10;
+constexpr int DEXOPT_ENABLE_HIDDEN_API_CHECKS = 1 << 10;
/* all known values for dexopt flags */
constexpr int DEXOPT_MASK =
@@ -64,7 +64,7 @@
| DEXOPT_FORCE
| DEXOPT_STORAGE_CE
| DEXOPT_STORAGE_DE
- | DEXOPT_DISABLE_HIDDEN_API_CHECKS;
+ | DEXOPT_ENABLE_HIDDEN_API_CHECKS;
// NOTE: keep in sync with StorageManager
constexpr int FLAG_STORAGE_DE = 1 << 0;
diff --git a/cmds/installd/otapreopt.cpp b/cmds/installd/otapreopt.cpp
index 72d01a5..f2d1b33 100644
--- a/cmds/installd/otapreopt.cpp
+++ b/cmds/installd/otapreopt.cpp
@@ -79,8 +79,8 @@
static_assert(DEXOPT_FORCE == 1 << 6, "DEXOPT_FORCE unexpected.");
static_assert(DEXOPT_STORAGE_CE == 1 << 7, "DEXOPT_STORAGE_CE unexpected.");
static_assert(DEXOPT_STORAGE_DE == 1 << 8, "DEXOPT_STORAGE_DE unexpected.");
-static_assert(DEXOPT_DISABLE_HIDDEN_API_CHECKS == 1 << 10,
- "DEXOPT_DISABLE_HIDDEN_API_CHECKS unexpected");
+static_assert(DEXOPT_ENABLE_HIDDEN_API_CHECKS == 1 << 10,
+ "DEXOPT_ENABLE_HIDDEN_API_CHECKS unexpected");
static_assert(DEXOPT_MASK == 0x5fe, "DEXOPT_MASK unexpected.");
diff --git a/cmds/installd/otapreopt_parameters.cpp b/cmds/installd/otapreopt_parameters.cpp
index 5b5f522..1f85728 100644
--- a/cmds/installd/otapreopt_parameters.cpp
+++ b/cmds/installd/otapreopt_parameters.cpp
@@ -218,6 +218,9 @@
// Set the profile name to the primary apk profile.
profile_name = "primary.prof";
+ // By default we don't have a dex metadata file.
+ dex_metadata_path = nullptr;
+
return true;
}
@@ -272,6 +275,9 @@
// Set the profile name to the primary apk profile.
profile_name = "primary.prof";
+ // By default we don't have a dex metadata file.
+ dex_metadata_path = nullptr;
+
for (size_t param_index = 0; param_index < num_args_actual; ++param_index) {
const char* param = argv[dexopt_index + 1 + param_index];
switch (param_index) {
@@ -332,11 +338,14 @@
break;
case 14:
- dex_metadata_path = ParseNull(param);
+ dex_metadata_path = ParseNull(param);
+ break;
default:
- CHECK(false) << "Should not get here. Did you call ReadArguments "
- << "with the right expectation?";
+ LOG(FATAL) << "Should not get here. Did you call ReadArguments "
+ << "with the right expectation? index=" << param_index
+ << " num_args=" << num_args_actual;
+ return false;
}
}
diff --git a/cmds/installd/tests/installd_otapreopt_test.cpp b/cmds/installd/tests/installd_otapreopt_test.cpp
index 1e8ae42..8b8dde1 100644
--- a/cmds/installd/tests/installd_otapreopt_test.cpp
+++ b/cmds/installd/tests/installd_otapreopt_test.cpp
@@ -39,8 +39,8 @@
class OTAPreoptTest : public testing::Test {
protected:
virtual void SetUp() {
- setenv("ANDROID_LOG_TAGS", "*:v", 1);
- android::base::InitLogging(nullptr);
+ setenv("ANDROID_LOG_TAGS", "*:f", 1);
+ android::base::InitLogging(nullptr, android::base::StderrLogger);
}
void verifyPackageParameters(const OTAPreoptParameters& params,
@@ -68,7 +68,7 @@
if (version > 1) {
ASSERT_STREQ(params.se_info, ParseNull(args[i++]));
} else {
- ASSERT_STREQ(params.se_info, nullptr);
+ ASSERT_EQ(params.se_info, nullptr);
}
if (version > 2) {
ASSERT_EQ(params.downgrade, ParseBool(args[i++]));
@@ -88,7 +88,7 @@
if (version > 5) {
ASSERT_STREQ(params.dex_metadata_path, ParseNull(args[i++]));
} else {
- ASSERT_STREQ(params.dex_metadata_path, nullptr);
+ ASSERT_EQ(params.dex_metadata_path, nullptr);
}
}
diff --git a/cmds/surfacereplayer/proto/Android.bp b/cmds/surfacereplayer/proto/Android.bp
index 71a5e23..7b402fe 100644
--- a/cmds/surfacereplayer/proto/Android.bp
+++ b/cmds/surfacereplayer/proto/Android.bp
@@ -7,6 +7,11 @@
"-Wall",
"-Werror",
],
+ arch: {
+ arm: {
+ instruction_set: "arm",
+ },
+ },
proto: {
type: "lite",
export_proto_headers: true,
diff --git a/data/etc/android.hardware.sensor.assist.xml b/data/etc/android.hardware.sensor.assist.xml
new file mode 100644
index 0000000..c7f9d56
--- /dev/null
+++ b/data/etc/android.hardware.sensor.assist.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+
+<!-- Feature for devices with an assist gesture sensor. -->
+<permissions>
+ <feature name="android.hardware.sensor.assist" />
+</permissions>
diff --git a/libs/gui/Android.bp b/libs/gui/Android.bp
index 065d44d..a1a0928 100644
--- a/libs/gui/Android.bp
+++ b/libs/gui/Android.bp
@@ -65,6 +65,9 @@
// Allow implicit instantiation for templated class function
"-Wno-undefined-func-template",
+ // Allow explicitly marking struct as packed even when unnecessary
+ "-Wno-packed",
+
"-DDEBUG_ONLY_CODE=0",
],
@@ -82,6 +85,7 @@
srcs: [
"BitTube.cpp",
+ "BufferHubConsumer.cpp",
"BufferHubProducer.cpp",
"BufferItem.cpp",
"BufferItemConsumer.cpp",
diff --git a/libs/gui/BufferHubConsumer.cpp b/libs/gui/BufferHubConsumer.cpp
new file mode 100644
index 0000000..b5cdeb2
--- /dev/null
+++ b/libs/gui/BufferHubConsumer.cpp
@@ -0,0 +1,161 @@
+/*
+ * Copyright 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gui/BufferHubConsumer.h>
+
+namespace android {
+
+using namespace dvr;
+
+/* static */
+sp<BufferHubConsumer> BufferHubConsumer::Create(const std::shared_ptr<ConsumerQueue>& queue) {
+ sp<BufferHubConsumer> consumer = new BufferHubConsumer;
+ consumer->mQueue = queue;
+ return consumer;
+}
+
+/* static */ sp<BufferHubConsumer> BufferHubConsumer::Create(ConsumerQueueParcelable parcelable) {
+ if (!parcelable.IsValid()) {
+ ALOGE("BufferHubConsumer::Create: Invalid consumer parcelable.");
+ return nullptr;
+ }
+
+ sp<BufferHubConsumer> consumer = new BufferHubConsumer;
+ consumer->mQueue = ConsumerQueue::Import(parcelable.TakeChannelHandle());
+ return consumer;
+}
+
+status_t BufferHubConsumer::acquireBuffer(BufferItem* /*buffer*/, nsecs_t /*presentWhen*/,
+ uint64_t /*maxFrameNumber*/) {
+ ALOGE("BufferHubConsumer::acquireBuffer: not implemented.");
+ return INVALID_OPERATION;
+}
+
+status_t BufferHubConsumer::detachBuffer(int /*slot*/) {
+ ALOGE("BufferHubConsumer::detachBuffer: not implemented.");
+ return INVALID_OPERATION;
+}
+
+status_t BufferHubConsumer::attachBuffer(int* /*outSlot*/, const sp<GraphicBuffer>& /*buffer*/) {
+ ALOGE("BufferHubConsumer::attachBuffer: not implemented.");
+ return INVALID_OPERATION;
+}
+
+status_t BufferHubConsumer::releaseBuffer(int /*buf*/, uint64_t /*frameNumber*/,
+ EGLDisplay /*display*/, EGLSyncKHR /*fence*/,
+ const sp<Fence>& /*releaseFence*/) {
+ ALOGE("BufferHubConsumer::releaseBuffer: not implemented.");
+ return INVALID_OPERATION;
+}
+
+status_t BufferHubConsumer::consumerConnect(const sp<IConsumerListener>& /*consumer*/,
+ bool /*controlledByApp*/) {
+ ALOGE("BufferHubConsumer::consumerConnect: not implemented.");
+
+ // TODO(b/73267953): Make BufferHub honor producer and consumer connection. Returns NO_ERROR to
+ // make IGraphicBufferConsumer_test happy.
+ return NO_ERROR;
+}
+
+status_t BufferHubConsumer::consumerDisconnect() {
+ ALOGE("BufferHubConsumer::consumerDisconnect: not implemented.");
+
+ // TODO(b/73267953): Make BufferHub honor producer and consumer connection. Returns NO_ERROR to
+ // make IGraphicBufferConsumer_test happy.
+ return NO_ERROR;
+}
+
+status_t BufferHubConsumer::getReleasedBuffers(uint64_t* /*slotMask*/) {
+ ALOGE("BufferHubConsumer::getReleasedBuffers: not implemented.");
+ return INVALID_OPERATION;
+}
+
+status_t BufferHubConsumer::setDefaultBufferSize(uint32_t /*w*/, uint32_t /*h*/) {
+ ALOGE("BufferHubConsumer::setDefaultBufferSize: not implemented.");
+ return INVALID_OPERATION;
+}
+
+status_t BufferHubConsumer::setMaxBufferCount(int /*bufferCount*/) {
+ ALOGE("BufferHubConsumer::setMaxBufferCount: not implemented.");
+ return INVALID_OPERATION;
+}
+
+status_t BufferHubConsumer::setMaxAcquiredBufferCount(int /*maxAcquiredBuffers*/) {
+ ALOGE("BufferHubConsumer::setMaxAcquiredBufferCount: not implemented.");
+
+ // TODO(b/73267953): Make BufferHub honor producer and consumer connection. Returns NO_ERROR to
+ // make IGraphicBufferConsumer_test happy.
+ return NO_ERROR;
+}
+
+status_t BufferHubConsumer::setConsumerName(const String8& /*name*/) {
+ ALOGE("BufferHubConsumer::setConsumerName: not implemented.");
+ return INVALID_OPERATION;
+}
+
+status_t BufferHubConsumer::setDefaultBufferFormat(PixelFormat /*defaultFormat*/) {
+ ALOGE("BufferHubConsumer::setDefaultBufferFormat: not implemented.");
+ return INVALID_OPERATION;
+}
+
+status_t BufferHubConsumer::setDefaultBufferDataSpace(android_dataspace /*defaultDataSpace*/) {
+ ALOGE("BufferHubConsumer::setDefaultBufferDataSpace: not implemented.");
+ return INVALID_OPERATION;
+}
+
+status_t BufferHubConsumer::setConsumerUsageBits(uint64_t /*usage*/) {
+ ALOGE("BufferHubConsumer::setConsumerUsageBits: not implemented.");
+ return INVALID_OPERATION;
+}
+
+status_t BufferHubConsumer::setConsumerIsProtected(bool /*isProtected*/) {
+ ALOGE("BufferHubConsumer::setConsumerIsProtected: not implemented.");
+ return INVALID_OPERATION;
+}
+
+status_t BufferHubConsumer::setTransformHint(uint32_t /*hint*/) {
+ ALOGE("BufferHubConsumer::setTransformHint: not implemented.");
+ return INVALID_OPERATION;
+}
+
+status_t BufferHubConsumer::getSidebandStream(sp<NativeHandle>* /*outStream*/) const {
+ ALOGE("BufferHubConsumer::getSidebandStream: not implemented.");
+ return INVALID_OPERATION;
+}
+
+status_t BufferHubConsumer::getOccupancyHistory(
+ bool /*forceFlush*/, std::vector<OccupancyTracker::Segment>* /*outHistory*/) {
+ ALOGE("BufferHubConsumer::getOccupancyHistory: not implemented.");
+ return INVALID_OPERATION;
+}
+
+status_t BufferHubConsumer::discardFreeBuffers() {
+ ALOGE("BufferHubConsumer::discardFreeBuffers: not implemented.");
+ return INVALID_OPERATION;
+}
+
+status_t BufferHubConsumer::dumpState(const String8& /*prefix*/, String8* /*outResult*/) const {
+ ALOGE("BufferHubConsumer::dumpState: not implemented.");
+ return INVALID_OPERATION;
+}
+
+IBinder* BufferHubConsumer::onAsBinder() {
+ ALOGE("BufferHubConsumer::onAsBinder: BufferHubConsumer should never be used as an Binder "
+ "object.");
+ return nullptr;
+}
+
+} // namespace android
diff --git a/libs/gui/BufferHubProducer.cpp b/libs/gui/BufferHubProducer.cpp
index af1f833..70321ca 100644
--- a/libs/gui/BufferHubProducer.cpp
+++ b/libs/gui/BufferHubProducer.cpp
@@ -14,29 +14,18 @@
* limitations under the License.
*/
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Weverything"
-#endif
-
-// The following headers are included without checking every warning.
-// TODO(b/72172820): Remove the workaround once we have enforced -Weverything
-// in these headers and their dependencies.
#include <dvr/dvr_api.h>
#include <gui/BufferHubProducer.h>
-
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
#include <inttypes.h>
#include <log/log.h>
#include <system/window.h>
namespace android {
+using namespace dvr;
+
/* static */
-sp<BufferHubProducer> BufferHubProducer::Create(const std::shared_ptr<dvr::ProducerQueue>& queue) {
+sp<BufferHubProducer> BufferHubProducer::Create(const std::shared_ptr<ProducerQueue>& queue) {
if (queue->metadata_size() != sizeof(DvrNativeBufferMetadata)) {
ALOGE("BufferHubProducer::Create producer's metadata size is different "
"than the size of DvrNativeBufferMetadata");
@@ -49,14 +38,14 @@
}
/* static */
-sp<BufferHubProducer> BufferHubProducer::Create(dvr::ProducerQueueParcelable parcelable) {
+sp<BufferHubProducer> BufferHubProducer::Create(ProducerQueueParcelable parcelable) {
if (!parcelable.IsValid()) {
ALOGE("BufferHubProducer::Create: Invalid producer parcelable.");
return nullptr;
}
sp<BufferHubProducer> producer = new BufferHubProducer;
- producer->queue_ = dvr::ProducerQueue::Import(parcelable.TakeChannelHandle());
+ producer->queue_ = ProducerQueue::Import(parcelable.TakeChannelHandle());
return producer;
}
@@ -102,9 +91,9 @@
if (max_dequeued_buffers <= 0 ||
max_dequeued_buffers >
- int(dvr::BufferHubQueue::kMaxQueueCapacity - kDefaultUndequeuedBuffers)) {
+ int(BufferHubQueue::kMaxQueueCapacity - kDefaultUndequeuedBuffers)) {
ALOGE("setMaxDequeuedBufferCount: %d out of range (0, %zu]", max_dequeued_buffers,
- dvr::BufferHubQueue::kMaxQueueCapacity);
+ BufferHubQueue::kMaxQueueCapacity);
return BAD_VALUE;
}
@@ -153,7 +142,7 @@
uint32_t height, PixelFormat format, uint64_t usage,
uint64_t* /*outBufferAge*/,
FrameEventHistoryDelta* /* out_timestamps */) {
- ALOGV("dequeueBuffer: w=%u, h=%u, format=%d, usage=%" PRIu64, width, height, format, usage);
+ ALOGW("dequeueBuffer: w=%u, h=%u, format=%d, usage=%" PRIu64, width, height, format, usage);
status_t ret;
std::unique_lock<std::mutex> lock(mutex_);
@@ -174,9 +163,9 @@
}
size_t slot = 0;
- std::shared_ptr<dvr::BufferProducer> buffer_producer;
+ std::shared_ptr<BufferProducer> buffer_producer;
- for (size_t retry = 0; retry < dvr::BufferHubQueue::kMaxQueueCapacity; retry++) {
+ for (size_t retry = 0; retry < BufferHubQueue::kMaxQueueCapacity; retry++) {
LocalHandle fence;
auto buffer_status = queue_->Dequeue(dequeue_timeout_ms_, &slot, &fence);
if (!buffer_status) return NO_MEMORY;
@@ -225,7 +214,7 @@
buffers_[slot].mBufferState.freeQueued();
buffers_[slot].mBufferState.dequeue();
- ALOGV("dequeueBuffer: slot=%zu", slot);
+ ALOGW("dequeueBuffer: slot=%zu", slot);
// TODO(jwcai) Handle fence properly. |BufferHub| has full fence support, we
// just need to exopose that through |BufferHubQueue| once we need fence.
@@ -590,7 +579,7 @@
ALOGV(__FUNCTION__);
std::unique_lock<std::mutex> lock(mutex_);
- dequeue_timeout_ms_ = int(timeout / (1000 * 1000));
+ dequeue_timeout_ms_ = static_cast<int>(timeout / (1000 * 1000));
return NO_ERROR;
}
@@ -620,7 +609,7 @@
return NO_ERROR;
}
-status_t BufferHubProducer::TakeAsParcelable(dvr::ProducerQueueParcelable* out_parcelable) {
+status_t BufferHubProducer::TakeAsParcelable(ProducerQueueParcelable* out_parcelable) {
if (!out_parcelable || out_parcelable->IsValid()) return BAD_VALUE;
if (connected_api_ != kNoConnectedApi) {
@@ -684,7 +673,7 @@
}
status_t BufferHubProducer::FreeAllBuffers() {
- for (size_t slot = 0; slot < dvr::BufferHubQueue::kMaxQueueCapacity; slot++) {
+ for (size_t slot = 0; slot < BufferHubQueue::kMaxQueueCapacity; slot++) {
// Reset in memory objects related the the buffer.
buffers_[slot].mGraphicBuffer = nullptr;
buffers_[slot].mBufferState.reset();
@@ -707,4 +696,28 @@
return NO_ERROR;
}
+status_t BufferHubProducer::exportToParcel(Parcel* parcel) {
+ status_t res = TakeAsParcelable(&pending_producer_parcelable_);
+ if (res != NO_ERROR) return res;
+
+ if (!pending_producer_parcelable_.IsValid()) {
+ ALOGE("BufferHubProducer::exportToParcel: Invalid parcelable object.");
+ return BAD_VALUE;
+ }
+
+ res = parcel->writeUint32(USE_BUFFER_HUB);
+ if (res != NO_ERROR) {
+ ALOGE("BufferHubProducer::exportToParcel: Cannot write magic, res=%d.", res);
+ return res;
+ }
+
+ return pending_producer_parcelable_.writeToParcel(parcel);
+}
+
+IBinder* BufferHubProducer::onAsBinder() {
+ ALOGE("BufferHubProducer::onAsBinder: BufferHubProducer should never be used as an Binder "
+ "object.");
+ return nullptr;
+}
+
} // namespace android
diff --git a/libs/gui/BufferQueue.cpp b/libs/gui/BufferQueue.cpp
index 4151212..1988690 100644
--- a/libs/gui/BufferQueue.cpp
+++ b/libs/gui/BufferQueue.cpp
@@ -18,6 +18,8 @@
#define ATRACE_TAG ATRACE_TAG_GRAPHICS
//#define LOG_NDEBUG 0
+#include <gui/BufferHubConsumer.h>
+#include <gui/BufferHubProducer.h>
#include <gui/BufferQueue.h>
#include <gui/BufferQueueConsumer.h>
#include <gui/BufferQueueCore.h>
@@ -101,4 +103,31 @@
*outConsumer = consumer;
}
+void BufferQueue::createBufferHubQueue(sp<IGraphicBufferProducer>* outProducer,
+ sp<IGraphicBufferConsumer>* outConsumer) {
+ LOG_ALWAYS_FATAL_IF(outProducer == NULL, "BufferQueue: outProducer must not be NULL");
+ LOG_ALWAYS_FATAL_IF(outConsumer == NULL, "BufferQueue: outConsumer must not be NULL");
+
+ sp<IGraphicBufferProducer> producer;
+ sp<IGraphicBufferConsumer> consumer;
+
+ dvr::ProducerQueueConfigBuilder configBuilder;
+ std::shared_ptr<dvr::ProducerQueue> producerQueue =
+ dvr::ProducerQueue::Create(configBuilder.SetMetadata<DvrNativeBufferMetadata>().Build(),
+ dvr::UsagePolicy{});
+ LOG_ALWAYS_FATAL_IF(producerQueue == NULL, "BufferQueue: failed to create ProducerQueue.");
+
+ std::shared_ptr<dvr::ConsumerQueue> consumerQueue = producerQueue->CreateConsumerQueue();
+ LOG_ALWAYS_FATAL_IF(consumerQueue == NULL, "BufferQueue: failed to create ConsumerQueue.");
+
+ producer = BufferHubProducer::Create(producerQueue);
+ consumer = BufferHubConsumer::Create(consumerQueue);
+
+ LOG_ALWAYS_FATAL_IF(producer == NULL, "BufferQueue: failed to create BufferQueueProducer");
+ LOG_ALWAYS_FATAL_IF(consumer == NULL, "BufferQueue: failed to create BufferQueueConsumer");
+
+ *outProducer = producer;
+ *outConsumer = consumer;
+}
+
}; // namespace android
diff --git a/libs/gui/BufferQueueProducer.cpp b/libs/gui/BufferQueueProducer.cpp
index 1e8d94c..c8021e4 100644
--- a/libs/gui/BufferQueueProducer.cpp
+++ b/libs/gui/BufferQueueProducer.cpp
@@ -1121,6 +1121,9 @@
case NATIVE_WINDOW_CONSUMER_IS_PROTECTED:
value = static_cast<int32_t>(mCore->mConsumerIsProtected);
break;
+ case NATIVE_WINDOW_MAX_BUFFER_COUNT:
+ value = static_cast<int32_t>(mCore->mMaxBufferCount);
+ break;
default:
return BAD_VALUE;
}
diff --git a/libs/gui/IGraphicBufferProducer.cpp b/libs/gui/IGraphicBufferProducer.cpp
index 7e49024..777a3e5 100644
--- a/libs/gui/IGraphicBufferProducer.cpp
+++ b/libs/gui/IGraphicBufferProducer.cpp
@@ -27,6 +27,7 @@
#include <binder/Parcel.h>
#include <binder/IInterface.h>
+#include <gui/BufferHubProducer.h>
#include <gui/BufferQueueDefs.h>
#include <gui/IGraphicBufferProducer.h>
#include <gui/IProducerListener.h>
@@ -653,6 +654,75 @@
// ----------------------------------------------------------------------
+status_t IGraphicBufferProducer::exportToParcel(Parcel* parcel) {
+ status_t res = OK;
+ res = parcel->writeUint32(USE_BUFFER_QUEUE);
+ if (res != NO_ERROR) {
+ ALOGE("exportToParcel: Cannot write magic, res=%d.", res);
+ return res;
+ }
+
+ return parcel->writeStrongBinder(IInterface::asBinder(this));
+}
+
+/* static */
+status_t IGraphicBufferProducer::exportToParcel(const sp<IGraphicBufferProducer>& producer,
+ Parcel* parcel) {
+ if (parcel == nullptr) {
+ ALOGE("exportToParcel: Invalid parcel object.");
+ return BAD_VALUE;
+ }
+
+ if (producer == nullptr) {
+ status_t res = OK;
+ res = parcel->writeUint32(IGraphicBufferProducer::USE_BUFFER_QUEUE);
+ if (res != NO_ERROR) return res;
+ return parcel->writeStrongBinder(nullptr);
+ } else {
+ return producer->exportToParcel(parcel);
+ }
+}
+
+/* static */
+sp<IGraphicBufferProducer> IGraphicBufferProducer::createFromParcel(const Parcel* parcel) {
+ uint32_t outMagic = 0;
+ status_t res = NO_ERROR;
+
+ res = parcel->readUint32(&outMagic);
+ if (res != NO_ERROR) {
+ ALOGE("createFromParcel: Failed to read magic, error=%d.", res);
+ return nullptr;
+ }
+
+ switch (outMagic) {
+ case USE_BUFFER_QUEUE: {
+ sp<IBinder> binder;
+ res = parcel->readNullableStrongBinder(&binder);
+ if (res != NO_ERROR) {
+ ALOGE("createFromParcel: Can't read strong binder.");
+ return nullptr;
+ }
+ return interface_cast<IGraphicBufferProducer>(binder);
+ }
+ case USE_BUFFER_HUB: {
+ ALOGE("createFromParcel: BufferHub not implemented.");
+ dvr::ProducerQueueParcelable producerParcelable;
+ res = producerParcelable.readFromParcel(parcel);
+ if (res != NO_ERROR) {
+ ALOGE("createFromParcel: Failed to read from parcel, error=%d", res);
+ return nullptr;
+ }
+ return BufferHubProducer::Create(std::move(producerParcelable));
+ }
+ default: {
+ ALOGE("createFromParcel: Unexpected mgaic: 0x%x.", outMagic);
+ return nullptr;
+ }
+ }
+}
+
+// ----------------------------------------------------------------------------
+
status_t BnGraphicBufferProducer::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
diff --git a/libs/gui/include/gui/BufferHubConsumer.h b/libs/gui/include/gui/BufferHubConsumer.h
new file mode 100644
index 0000000..d380770
--- /dev/null
+++ b/libs/gui/include/gui/BufferHubConsumer.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright 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.
+ */
+
+#ifndef ANDROID_GUI_BUFFERHUBCONSUMER_H_
+#define ANDROID_GUI_BUFFERHUBCONSUMER_H_
+
+#include <gui/IGraphicBufferConsumer.h>
+#include <private/dvr/buffer_hub_queue_client.h>
+#include <private/dvr/buffer_hub_queue_parcelable.h>
+
+namespace android {
+
+class BufferHubConsumer : public IGraphicBufferConsumer {
+public:
+ // Creates a BufferHubConsumer instance by importing an existing producer queue.
+ static sp<BufferHubConsumer> Create(const std::shared_ptr<dvr::ConsumerQueue>& queue);
+
+ // Creates a BufferHubConsumer instance by importing an existing producer
+ // parcelable. Note that this call takes the ownership of the parcelable
+ // object and is guaranteed to succeed if parcelable object is valid.
+ static sp<BufferHubConsumer> Create(dvr::ConsumerQueueParcelable parcelable);
+
+ // See |IGraphicBufferConsumer::acquireBuffer|
+ status_t acquireBuffer(BufferItem* buffer, nsecs_t presentWhen,
+ uint64_t maxFrameNumber = 0) override;
+
+ // See |IGraphicBufferConsumer::detachBuffer|
+ status_t detachBuffer(int slot) override;
+
+ // See |IGraphicBufferConsumer::attachBuffer|
+ status_t attachBuffer(int* outSlot, const sp<GraphicBuffer>& buffer) override;
+
+ // See |IGraphicBufferConsumer::releaseBuffer|
+ status_t releaseBuffer(int buf, uint64_t frameNumber, EGLDisplay display, EGLSyncKHR fence,
+ const sp<Fence>& releaseFence) override;
+
+ // See |IGraphicBufferConsumer::consumerConnect|
+ status_t consumerConnect(const sp<IConsumerListener>& consumer, bool controlledByApp) override;
+
+ // See |IGraphicBufferConsumer::consumerDisconnect|
+ status_t consumerDisconnect() override;
+
+ // See |IGraphicBufferConsumer::getReleasedBuffers|
+ status_t getReleasedBuffers(uint64_t* slotMask) override;
+
+ // See |IGraphicBufferConsumer::setDefaultBufferSize|
+ status_t setDefaultBufferSize(uint32_t w, uint32_t h) override;
+
+ // See |IGraphicBufferConsumer::setMaxBufferCount|
+ status_t setMaxBufferCount(int bufferCount) override;
+
+ // See |IGraphicBufferConsumer::setMaxAcquiredBufferCount|
+ status_t setMaxAcquiredBufferCount(int maxAcquiredBuffers) override;
+
+ // See |IGraphicBufferConsumer::setConsumerName|
+ status_t setConsumerName(const String8& name) override;
+
+ // See |IGraphicBufferConsumer::setDefaultBufferFormat|
+ status_t setDefaultBufferFormat(PixelFormat defaultFormat) override;
+
+ // See |IGraphicBufferConsumer::setDefaultBufferDataSpace|
+ status_t setDefaultBufferDataSpace(android_dataspace defaultDataSpace) override;
+
+ // See |IGraphicBufferConsumer::setConsumerUsageBits|
+ status_t setConsumerUsageBits(uint64_t usage) override;
+
+ // See |IGraphicBufferConsumer::setConsumerIsProtected|
+ status_t setConsumerIsProtected(bool isProtected) override;
+
+ // See |IGraphicBufferConsumer::setTransformHint|
+ status_t setTransformHint(uint32_t hint) override;
+
+ // See |IGraphicBufferConsumer::getSidebandStream|
+ status_t getSidebandStream(sp<NativeHandle>* outStream) const override;
+
+ // See |IGraphicBufferConsumer::getOccupancyHistory|
+ status_t getOccupancyHistory(bool forceFlush,
+ std::vector<OccupancyTracker::Segment>* outHistory) override;
+
+ // See |IGraphicBufferConsumer::discardFreeBuffers|
+ status_t discardFreeBuffers() override;
+
+ // See |IGraphicBufferConsumer::dumpState|
+ status_t dumpState(const String8& prefix, String8* outResult) const override;
+
+ // BufferHubConsumer provides its own logic to cast to a binder object.
+ IBinder* onAsBinder() override;
+
+private:
+ // Private constructor to force use of |Create|.
+ BufferHubConsumer() = default;
+
+ // Concrete implementation backed by BufferHubBuffer.
+ std::shared_ptr<dvr::ConsumerQueue> mQueue;
+};
+
+} // namespace android
+
+#endif // ANDROID_GUI_BUFFERHUBCONSUMER_H_
diff --git a/libs/gui/include/gui/BufferHubProducer.h b/libs/gui/include/gui/BufferHubProducer.h
index 2ee011b..23c9909 100644
--- a/libs/gui/include/gui/BufferHubProducer.h
+++ b/libs/gui/include/gui/BufferHubProducer.h
@@ -24,7 +24,7 @@
namespace android {
-class BufferHubProducer : public BnGraphicBufferProducer {
+class BufferHubProducer : public IGraphicBufferProducer {
public:
static constexpr int kNoConnectedApi = -1;
@@ -135,6 +135,12 @@
// invalid parcelable.
status_t TakeAsParcelable(dvr::ProducerQueueParcelable* out_parcelable);
+ IBinder* onAsBinder() override;
+
+protected:
+ // See |IGraphicBufferProducer::exportToParcel|
+ status_t exportToParcel(Parcel* parcel) override;
+
private:
using LocalHandle = pdx::LocalHandle;
@@ -203,6 +209,9 @@
// A uniqueId used by IGraphicBufferProducer interface.
const uint64_t unique_id_{genUniqueId()};
+
+ // A pending parcelable object which keeps the bufferhub channel alive.
+ dvr::ProducerQueueParcelable pending_producer_parcelable_;
};
} // namespace android
diff --git a/libs/gui/include/gui/BufferQueue.h b/libs/gui/include/gui/BufferQueue.h
index ba5cbf7..f175573 100644
--- a/libs/gui/include/gui/BufferQueue.h
+++ b/libs/gui/include/gui/BufferQueue.h
@@ -79,6 +79,10 @@
sp<IGraphicBufferConsumer>* outConsumer,
bool consumerIsSurfaceFlinger = false);
+ // Creates an IGraphicBufferProducer and IGraphicBufferConsumer pair backed by BufferHub.
+ static void createBufferHubQueue(sp<IGraphicBufferProducer>* outProducer,
+ sp<IGraphicBufferConsumer>* outConsumer);
+
BufferQueue() = delete; // Create through createBufferQueue
};
diff --git a/libs/gui/include/gui/IGraphicBufferProducer.h b/libs/gui/include/gui/IGraphicBufferProducer.h
index 722833e..887654e 100644
--- a/libs/gui/include/gui/IGraphicBufferProducer.h
+++ b/libs/gui/include/gui/IGraphicBufferProducer.h
@@ -73,6 +73,14 @@
RELEASE_ALL_BUFFERS = 0x2,
};
+ enum {
+ // A parcelable magic indicates using Binder BufferQueue as transport
+ // backend.
+ USE_BUFFER_QUEUE = 0x62717565, // 'bque'
+ // A parcelable magic indicates using BufferHub as transport backend.
+ USE_BUFFER_HUB = 0x62687562, // 'bhub'
+ };
+
// requestBuffer requests a new buffer for the given index. The server (i.e.
// the IGraphicBufferProducer implementation) assigns the newly created
// buffer to the given slot index, and the client is expected to mirror the
@@ -604,6 +612,24 @@
// returned by querying the now deprecated
// NATIVE_WINDOW_CONSUMER_USAGE_BITS attribute.
virtual status_t getConsumerUsage(uint64_t* outUsage) const = 0;
+
+ // Static method exports any IGraphicBufferProducer object to a parcel. It
+ // handles null producer as well.
+ static status_t exportToParcel(const sp<IGraphicBufferProducer>& producer,
+ Parcel* parcel);
+
+ // Factory method that creates a new IBGP instance from the parcel.
+ static sp<IGraphicBufferProducer> createFromParcel(const Parcel* parcel);
+
+protected:
+ // Exports the current producer as a binder parcelable object. Note that the
+ // producer must be disconnected to be exportable. After successful export,
+ // the producer queue can no longer be connected again. Returns NO_ERROR
+ // when the export is successful and writes an implementation defined
+ // parcelable object into the parcel. For traditional Android BufferQueue,
+ // it writes a strong binder object; for BufferHub, it writes a
+ // ProducerQueueParcelable object.
+ virtual status_t exportToParcel(Parcel* parcel);
};
// ----------------------------------------------------------------------------
diff --git a/libs/gui/tests/Android.bp b/libs/gui/tests/Android.bp
index 908959c..01e90e0 100644
--- a/libs/gui/tests/Android.bp
+++ b/libs/gui/tests/Android.bp
@@ -49,3 +49,35 @@
"libnativewindow"
],
}
+
+// Build a separate binary for each source file to $(TARGET_OUT_DATA_NATIVE_TESTS)/$(LOCAL_MODULE)
+cc_test {
+ name: "libgui_separate_binary_test",
+ test_suites: ["device-tests"],
+
+ clang: true,
+ cflags: [
+ "-Wall",
+ "-Werror",
+ ],
+
+ test_per_src: true,
+ srcs: [
+ "SurfaceParcelable_test.cpp",
+ ],
+
+ shared_libs: [
+ "liblog",
+ "libbinder",
+ "libcutils",
+ "libgui",
+ "libui",
+ "libutils",
+ "libbufferhubqueue", // TODO(b/70046255): Remove these once BufferHub is integrated into libgui.
+ "libpdx_default_transport",
+ ],
+
+ header_libs: [
+ "libdvr_headers",
+ ],
+}
diff --git a/libs/gui/tests/IGraphicBufferProducer_test.cpp b/libs/gui/tests/IGraphicBufferProducer_test.cpp
index dd23bd4..a35cf11 100644
--- a/libs/gui/tests/IGraphicBufferProducer_test.cpp
+++ b/libs/gui/tests/IGraphicBufferProducer_test.cpp
@@ -42,6 +42,10 @@
#define TEST_CONTROLLED_BY_APP false
#define TEST_PRODUCER_USAGE_BITS (0)
+#ifndef USE_BUFFER_HUB_AS_BUFFER_QUEUE
+#define USE_BUFFER_HUB_AS_BUFFER_QUEUE 0
+#endif
+
namespace android {
namespace {
@@ -66,9 +70,15 @@
const int QUEUE_BUFFER_INPUT_SCALING_MODE = 0;
const int QUEUE_BUFFER_INPUT_TRANSFORM = 0;
const sp<Fence> QUEUE_BUFFER_INPUT_FENCE = Fence::NO_FENCE;
+
+ // Enums to control which IGraphicBufferProducer backend to test.
+ enum IGraphicBufferProducerTestCode {
+ USE_BUFFER_QUEUE_PRODUCER = 0,
+ USE_BUFFER_HUB_PRODUCER,
+ };
}; // namespace anonymous
-class IGraphicBufferProducerTest : public ::testing::Test {
+class IGraphicBufferProducerTest : public ::testing::TestWithParam<uint32_t> {
protected:
IGraphicBufferProducerTest() {}
@@ -81,10 +91,27 @@
mDC = new DummyConsumer;
- BufferQueue::createBufferQueue(&mProducer, &mConsumer);
+ switch (GetParam()) {
+ case USE_BUFFER_QUEUE_PRODUCER: {
+ BufferQueue::createBufferQueue(&mProducer, &mConsumer);
+ break;
+ }
+ case USE_BUFFER_HUB_PRODUCER: {
+ BufferQueue::createBufferHubQueue(&mProducer, &mConsumer);
+ break;
+ }
+ default: {
+ // Should never reach here.
+ LOG_ALWAYS_FATAL("Invalid test params: %u", GetParam());
+ break;
+ }
+ }
// Test check: Can't connect producer if no consumer yet
- ASSERT_EQ(NO_INIT, TryConnectProducer());
+ if (GetParam() == USE_BUFFER_QUEUE_PRODUCER) {
+ // TODO(b/73267953): Make BufferHub honor producer and consumer connection.
+ ASSERT_EQ(NO_INIT, TryConnectProducer());
+ }
// Must connect consumer before producer connects will succeed.
ASSERT_OK(mConsumer->consumerConnect(mDC, /*controlledByApp*/false));
@@ -229,7 +256,7 @@
sp<IGraphicBufferConsumer> mConsumer;
};
-TEST_F(IGraphicBufferProducerTest, ConnectFirst_ReturnsError) {
+TEST_P(IGraphicBufferProducerTest, ConnectFirst_ReturnsError) {
IGraphicBufferProducer::QueueBufferOutput output;
// NULL output returns BAD_VALUE
@@ -247,7 +274,7 @@
// TODO: get a token from a dead process somehow
}
-TEST_F(IGraphicBufferProducerTest, ConnectAgain_ReturnsError) {
+TEST_P(IGraphicBufferProducerTest, ConnectAgain_ReturnsError) {
ASSERT_NO_FATAL_FAILURE(ConnectProducer());
// Can't connect when there is already a producer connected
@@ -259,20 +286,23 @@
ASSERT_OK(mConsumer->consumerDisconnect());
// Can't connect when IGBP is abandoned
- EXPECT_EQ(NO_INIT, mProducer->connect(TEST_TOKEN,
- TEST_API,
- TEST_CONTROLLED_BY_APP,
- &output));
+ if (GetParam() == USE_BUFFER_QUEUE_PRODUCER) {
+ // TODO(b/73267953): Make BufferHub honor producer and consumer connection.
+ EXPECT_EQ(NO_INIT, mProducer->connect(TEST_TOKEN,
+ TEST_API,
+ TEST_CONTROLLED_BY_APP,
+ &output));
+ }
}
-TEST_F(IGraphicBufferProducerTest, Disconnect_Succeeds) {
+TEST_P(IGraphicBufferProducerTest, Disconnect_Succeeds) {
ASSERT_NO_FATAL_FAILURE(ConnectProducer());
ASSERT_OK(mProducer->disconnect(TEST_API));
}
-TEST_F(IGraphicBufferProducerTest, Disconnect_ReturnsError) {
+TEST_P(IGraphicBufferProducerTest, Disconnect_ReturnsError) {
ASSERT_NO_FATAL_FAILURE(ConnectProducer());
// Must disconnect with same API number
@@ -283,7 +313,7 @@
// TODO: somehow kill mProducer so that this returns DEAD_OBJECT
}
-TEST_F(IGraphicBufferProducerTest, Query_Succeeds) {
+TEST_P(IGraphicBufferProducerTest, Query_Succeeds) {
ASSERT_NO_FATAL_FAILURE(ConnectProducer());
int32_t value = -1;
@@ -308,7 +338,7 @@
}
-TEST_F(IGraphicBufferProducerTest, Query_ReturnsError) {
+TEST_P(IGraphicBufferProducerTest, Query_ReturnsError) {
ASSERT_NO_FATAL_FAILURE(ConnectProducer());
// One past the end of the last 'query' enum value. Update this if we add more enums.
@@ -334,14 +364,17 @@
ASSERT_OK(mConsumer->consumerDisconnect());
// BQ was abandoned
- EXPECT_EQ(NO_INIT, mProducer->query(NATIVE_WINDOW_FORMAT, &value));
+ if (GetParam() == USE_BUFFER_QUEUE_PRODUCER) {
+ // TODO(b/73267953): Make BufferHub honor producer and consumer connection.
+ EXPECT_EQ(NO_INIT, mProducer->query(NATIVE_WINDOW_FORMAT, &value));
+ }
// TODO: other things in window.h that are supported by Surface::query
// but not by BufferQueue::query
}
// TODO: queue under more complicated situations not involving just a single buffer
-TEST_F(IGraphicBufferProducerTest, Queue_Succeeds) {
+TEST_P(IGraphicBufferProducerTest, Queue_Succeeds) {
ASSERT_NO_FATAL_FAILURE(ConnectProducer());
int dequeuedSlot = -1;
@@ -371,16 +404,21 @@
EXPECT_EQ(DEFAULT_WIDTH, output.width);
EXPECT_EQ(DEFAULT_HEIGHT, output.height);
EXPECT_EQ(DEFAULT_TRANSFORM_HINT, output.transformHint);
+
// Since queueBuffer was called exactly once
- EXPECT_EQ(1u, output.numPendingBuffers);
- EXPECT_EQ(2u, output.nextFrameNumber);
+ if (GetParam() == USE_BUFFER_QUEUE_PRODUCER) {
+ // TODO(b/70041889): BufferHubProducer need to support metadata: numPendingBuffers
+ EXPECT_EQ(1u, output.numPendingBuffers);
+ // TODO(b/70041952): BufferHubProducer need to support metadata: nextFrameNumber
+ EXPECT_EQ(2u, output.nextFrameNumber);
+ }
}
// Buffer was not in the dequeued state
EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(dequeuedSlot, input, &output));
}
-TEST_F(IGraphicBufferProducerTest, Queue_ReturnsError) {
+TEST_P(IGraphicBufferProducerTest, Queue_ReturnsError) {
ASSERT_NO_FATAL_FAILURE(ConnectProducer());
// Invalid slot number
@@ -463,15 +501,16 @@
ASSERT_OK(mConsumer->consumerDisconnect());
// The buffer queue has been abandoned.
- {
+ if (GetParam() == USE_BUFFER_QUEUE_PRODUCER) {
IGraphicBufferProducer::QueueBufferInput input = CreateBufferInput();
IGraphicBufferProducer::QueueBufferOutput output;
+ // TODO(b/73267953): Make BufferHub honor producer and consumer connection.
EXPECT_EQ(NO_INIT, mProducer->queueBuffer(dequeuedSlot, input, &output));
}
}
-TEST_F(IGraphicBufferProducerTest, CancelBuffer_DoesntCrash) {
+TEST_P(IGraphicBufferProducerTest, CancelBuffer_DoesntCrash) {
ASSERT_NO_FATAL_FAILURE(ConnectProducer());
int dequeuedSlot = -1;
@@ -488,7 +527,7 @@
mProducer->cancelBuffer(dequeuedSlot, dequeuedFence);
}
-TEST_F(IGraphicBufferProducerTest, SetMaxDequeuedBufferCount_Succeeds) {
+TEST_P(IGraphicBufferProducerTest, SetMaxDequeuedBufferCount_Succeeds) {
ASSERT_NO_FATAL_FAILURE(ConnectProducer());
int minUndequeuedBuffers;
ASSERT_OK(mProducer->query(NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS,
@@ -540,7 +579,7 @@
ASSERT_OK(mProducer->setMaxDequeuedBufferCount(maxBuffers-1));
}
-TEST_F(IGraphicBufferProducerTest, SetMaxDequeuedBufferCount_Fails) {
+TEST_P(IGraphicBufferProducerTest, SetMaxDequeuedBufferCount_Fails) {
ASSERT_NO_FATAL_FAILURE(ConnectProducer());
int minUndequeuedBuffers;
ASSERT_OK(mProducer->query(NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS,
@@ -578,12 +617,19 @@
ASSERT_OK(mConsumer->consumerDisconnect());
// Fail because the buffer queue was abandoned
- EXPECT_EQ(NO_INIT, mProducer->setMaxDequeuedBufferCount(minBuffers))
- << "bufferCount: " << minBuffers;
-
+ if (GetParam() == USE_BUFFER_QUEUE_PRODUCER) {
+ // TODO(b/73267953): Make BufferHub honor producer and consumer connection.
+ EXPECT_EQ(NO_INIT, mProducer->setMaxDequeuedBufferCount(minBuffers))
+ << "bufferCount: " << minBuffers;
+ }
}
-TEST_F(IGraphicBufferProducerTest, SetAsyncMode_Succeeds) {
+TEST_P(IGraphicBufferProducerTest, SetAsyncMode_Succeeds) {
+ if (GetParam() == USE_BUFFER_HUB_PRODUCER) {
+ // TODO(b/36724099): Add support for BufferHubProducer::setAsyncMode(true)
+ return;
+ }
+
ASSERT_OK(mConsumer->setMaxAcquiredBufferCount(1)) << "maxAcquire: " << 1;
ASSERT_NO_FATAL_FAILURE(ConnectProducer());
ASSERT_OK(mProducer->setAsyncMode(true)) << "async mode: " << true;
@@ -609,7 +655,7 @@
}
}
-TEST_F(IGraphicBufferProducerTest, SetAsyncMode_Fails) {
+TEST_P(IGraphicBufferProducerTest, SetAsyncMode_Fails) {
ASSERT_NO_FATAL_FAILURE(ConnectProducer());
// Prerequisite to fail out a valid setBufferCount call
{
@@ -628,11 +674,13 @@
ASSERT_OK(mConsumer->consumerDisconnect());
// Fail because the buffer queue was abandoned
- EXPECT_EQ(NO_INIT, mProducer->setAsyncMode(false)) << "asyncMode: "
- << false;
+ if (GetParam() == USE_BUFFER_QUEUE_PRODUCER) {
+ // TODO(b/36724099): Make BufferHub honor producer and consumer connection.
+ EXPECT_EQ(NO_INIT, mProducer->setAsyncMode(false)) << "asyncMode: " << false;
+ }
}
-TEST_F(IGraphicBufferProducerTest,
+TEST_P(IGraphicBufferProducerTest,
DisconnectedProducerReturnsError_dequeueBuffer) {
int slot = -1;
sp<Fence> fence;
@@ -642,15 +690,18 @@
TEST_PRODUCER_USAGE_BITS, nullptr, nullptr));
}
-TEST_F(IGraphicBufferProducerTest,
+TEST_P(IGraphicBufferProducerTest,
DisconnectedProducerReturnsError_detachNextBuffer) {
sp<Fence> fence;
sp<GraphicBuffer> buffer;
- ASSERT_EQ(NO_INIT, mProducer->detachNextBuffer(&buffer, &fence));
+ if (GetParam() == USE_BUFFER_QUEUE_PRODUCER) {
+ // TODO(b/38137191): Implement BufferHubProducer::detachBuffer
+ ASSERT_EQ(NO_INIT, mProducer->detachNextBuffer(&buffer, &fence));
+ }
}
-TEST_F(IGraphicBufferProducerTest,
+TEST_P(IGraphicBufferProducerTest,
DisconnectedProducerReturnsError_requestBuffer) {
ASSERT_NO_FATAL_FAILURE(ConnectProducer());
@@ -674,7 +725,7 @@
}
-TEST_F(IGraphicBufferProducerTest,
+TEST_P(IGraphicBufferProducerTest,
DisconnectedProducerReturnsError_detachBuffer) {
int slot = -1;
sp<Fence> fence;
@@ -684,10 +735,13 @@
ASSERT_OK(mProducer->disconnect(TEST_API));
- ASSERT_EQ(NO_INIT, mProducer->detachBuffer(slot));
+ if (GetParam() == USE_BUFFER_QUEUE_PRODUCER) {
+ // TODO(b/38137191): Implement BufferHubProducer::detachBuffer
+ ASSERT_EQ(NO_INIT, mProducer->detachBuffer(slot));
+ }
}
-TEST_F(IGraphicBufferProducerTest,
+TEST_P(IGraphicBufferProducerTest,
DisconnectedProducerReturnsError_queueBuffer) {
int slot = -1;
sp<Fence> fence;
@@ -704,7 +758,7 @@
ASSERT_EQ(NO_INIT, mProducer->queueBuffer(slot, input, &output));
}
-TEST_F(IGraphicBufferProducerTest,
+TEST_P(IGraphicBufferProducerTest,
DisconnectedProducerReturnsError_cancelBuffer) {
int slot = -1;
sp<Fence> fence;
@@ -717,7 +771,7 @@
ASSERT_EQ(NO_INIT, mProducer->cancelBuffer(slot, fence));
}
-TEST_F(IGraphicBufferProducerTest,
+TEST_P(IGraphicBufferProducerTest,
DisconnectedProducerReturnsError_attachBuffer) {
int slot = -1;
sp<Fence> fence;
@@ -725,11 +779,27 @@
setupDequeueRequestBuffer(&slot, &fence, &buffer);
- ASSERT_OK(mProducer->detachBuffer(slot));
+ if (GetParam() == USE_BUFFER_QUEUE_PRODUCER) {
+ // TODO(b/38137191): Implement BufferHubProducer::detachBuffer
+ ASSERT_OK(mProducer->detachBuffer(slot));
+ }
ASSERT_OK(mProducer->disconnect(TEST_API));
- ASSERT_EQ(NO_INIT, mProducer->attachBuffer(&slot, buffer));
+ if (GetParam() == USE_BUFFER_QUEUE_PRODUCER) {
+ // TODO(b/69981968): Implement BufferHubProducer::attachBuffer
+ ASSERT_EQ(NO_INIT, mProducer->attachBuffer(&slot, buffer));
+ }
}
+#if USE_BUFFER_HUB_AS_BUFFER_QUEUE
+INSTANTIATE_TEST_CASE_P(IGraphicBufferProducerBackends, IGraphicBufferProducerTest,
+ ::testing::Values(USE_BUFFER_QUEUE_PRODUCER, USE_BUFFER_HUB_PRODUCER));
+#else
+// TODO(b/70046255): Remove the #ifdef here and always tests both backends once BufferHubQueue can
+// pass all existing libgui tests.
+INSTANTIATE_TEST_CASE_P(IGraphicBufferProducerBackends, IGraphicBufferProducerTest,
+ ::testing::Values(USE_BUFFER_QUEUE_PRODUCER));
+#endif
+
} // namespace android
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();
+ }
+}
diff --git a/libs/gui/view/Surface.cpp b/libs/gui/view/Surface.cpp
index 5ed3d3b..d64dfd5 100644
--- a/libs/gui/view/Surface.cpp
+++ b/libs/gui/view/Surface.cpp
@@ -45,10 +45,7 @@
if (res != OK) return res;
}
- res = parcel->writeStrongBinder(
- IGraphicBufferProducer::asBinder(graphicBufferProducer));
-
- return res;
+ return IGraphicBufferProducer::exportToParcel(graphicBufferProducer, parcel);
}
status_t Surface::readFromParcel(const Parcel* parcel) {
@@ -70,16 +67,7 @@
}
}
- sp<IBinder> binder;
-
- res = parcel->readNullableStrongBinder(&binder);
- if (res != OK) {
- ALOGE("%s: Can't read strong binder", __FUNCTION__);
- return res;
- }
-
- graphicBufferProducer = interface_cast<IGraphicBufferProducer>(binder);
-
+ graphicBufferProducer = IGraphicBufferProducer::createFromParcel(parcel);
return OK;
}
diff --git a/libs/nativewindow/include/system/window.h b/libs/nativewindow/include/system/window.h
index 5fa1212..197f73f 100644
--- a/libs/nativewindow/include/system/window.h
+++ b/libs/nativewindow/include/system/window.h
@@ -184,6 +184,11 @@
* Returns data space for the buffers.
*/
NATIVE_WINDOW_DATASPACE = 20,
+
+ /*
+ * Returns maxBufferCount set by BufferQueueConsumer
+ */
+ NATIVE_WINDOW_MAX_BUFFER_COUNT = 21,
};
/* Valid operations for the (*perform)() hook.
diff --git a/libs/vr/libbufferhub/Android.bp b/libs/vr/libbufferhub/Android.bp
index 39814cc..e6803da 100644
--- a/libs/vr/libbufferhub/Android.bp
+++ b/libs/vr/libbufferhub/Android.bp
@@ -48,6 +48,11 @@
"-Wall",
"-Werror",
],
+ arch: {
+ arm: {
+ instruction_set: "arm",
+ },
+ },
export_include_dirs: localIncludeFiles,
shared_libs: sharedLibraries,
header_libs: headerLibraries,
diff --git a/libs/vr/libbufferhubqueue/Android.bp b/libs/vr/libbufferhubqueue/Android.bp
index eeec9ec..cf2c59b 100644
--- a/libs/vr/libbufferhubqueue/Android.bp
+++ b/libs/vr/libbufferhubqueue/Android.bp
@@ -53,6 +53,11 @@
"-Wno-unused-parameter",
"-Wno-unused-variable",
],
+ arch: {
+ arm: {
+ instruction_set: "arm",
+ },
+ },
srcs: sourceFiles,
export_include_dirs: includeFiles,
export_static_lib_headers: staticLibraries,
diff --git a/libs/vr/libbufferhubqueue/buffer_hub_queue_client.cpp b/libs/vr/libbufferhubqueue/buffer_hub_queue_client.cpp
index c75c67f..8feb1cd 100644
--- a/libs/vr/libbufferhubqueue/buffer_hub_queue_client.cpp
+++ b/libs/vr/libbufferhubqueue/buffer_hub_queue_client.cpp
@@ -582,6 +582,12 @@
return {std::move(queue_parcelable)};
}
+/*static */
+std::unique_ptr<ConsumerQueue> ConsumerQueue::Import(
+ LocalChannelHandle handle) {
+ return std::unique_ptr<ConsumerQueue>(new ConsumerQueue(std::move(handle)));
+}
+
ConsumerQueue::ConsumerQueue(LocalChannelHandle handle)
: BufferHubQueue(std::move(handle)) {
auto status = ImportQueue();
diff --git a/libs/vr/libbufferhubqueue/include/private/dvr/buffer_hub_queue_client.h b/libs/vr/libbufferhubqueue/include/private/dvr/buffer_hub_queue_client.h
index 8965530..60e1c4b 100644
--- a/libs/vr/libbufferhubqueue/include/private/dvr/buffer_hub_queue_client.h
+++ b/libs/vr/libbufferhubqueue/include/private/dvr/buffer_hub_queue_client.h
@@ -3,6 +3,14 @@
#include <ui/BufferQueueDefs.h>
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Weverything"
+#endif
+
+// The following headers are included without checking every warning.
+// TODO(b/72172820): Remove the workaround once we have enforced -Weverything
+// in these headers and their dependencies.
#include <pdx/client.h>
#include <pdx/status.h>
#include <private/dvr/buffer_hub_client.h>
@@ -10,6 +18,10 @@
#include <private/dvr/bufferhub_rpc.h>
#include <private/dvr/epoll_file_descriptor.h>
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
#include <memory>
#include <queue>
#include <vector>
@@ -45,10 +57,10 @@
uint32_t default_width() const { return default_width_; }
// Returns the default buffer height of this buffer queue.
- uint32_t default_height() const { return default_height_; }
+ uint32_t default_height() const { return static_cast<uint32_t>(default_height_); }
// Returns the default buffer format of this buffer queue.
- uint32_t default_format() const { return default_format_; }
+ uint32_t default_format() const { return static_cast<uint32_t>(default_format_); }
// Creates a new consumer in handle form for immediate transport over RPC.
pdx::Status<pdx::LocalChannelHandle> CreateConsumerQueueHandle(
@@ -160,16 +172,16 @@
// per-buffer data.
struct Entry {
Entry() : slot(0) {}
- Entry(const std::shared_ptr<BufferHubBuffer>& buffer, size_t slot,
- uint64_t index)
- : buffer(buffer), slot(slot), index(index) {}
- Entry(const std::shared_ptr<BufferHubBuffer>& buffer,
- std::unique_ptr<uint8_t[]> metadata, pdx::LocalHandle fence,
- size_t slot)
- : buffer(buffer),
- metadata(std::move(metadata)),
- fence(std::move(fence)),
- slot(slot) {}
+ Entry(const std::shared_ptr<BufferHubBuffer>& in_buffer, size_t in_slot,
+ uint64_t in_index)
+ : buffer(in_buffer), slot(in_slot), index(in_index) {}
+ Entry(const std::shared_ptr<BufferHubBuffer>& in_buffer,
+ std::unique_ptr<uint8_t[]> in_metadata, pdx::LocalHandle in_fence,
+ size_t in_slot)
+ : buffer(in_buffer),
+ metadata(std::move(in_metadata)),
+ fence(std::move(in_fence)),
+ slot(in_slot) {}
Entry(Entry&&) = default;
Entry& operator=(Entry&&) = default;
@@ -227,13 +239,13 @@
bool is_async_{false};
// Default buffer width that is set during ProducerQueue's creation.
- size_t default_width_{1};
+ uint32_t default_width_{1};
// Default buffer height that is set during ProducerQueue's creation.
- size_t default_height_{1};
+ uint32_t default_height_{1};
// Default buffer format that is set during ProducerQueue's creation.
- int32_t default_format_{1}; // PIXEL_FORMAT_RGBA_8888
+ uint32_t default_format_{1}; // PIXEL_FORMAT_RGBA_8888
// Tracks the buffers belonging to this queue. Buffers are stored according to
// "slot" in this vector. Each slot is a logical id of the buffer within this
@@ -373,10 +385,7 @@
// used to avoid participation in the buffer lifecycle by a consumer queue
// that is only used to spawn other consumer queues, such as in an
// intermediate service.
- static std::unique_ptr<ConsumerQueue> Import(pdx::LocalChannelHandle handle) {
- return std::unique_ptr<ConsumerQueue>(
- new ConsumerQueue(std::move(handle)));
- }
+ static std::unique_ptr<ConsumerQueue> Import(pdx::LocalChannelHandle handle);
// Import newly created buffers from the service side.
// Returns number of buffers successfully imported or an error.
diff --git a/libs/vr/libbufferhubqueue/include/private/dvr/buffer_hub_queue_parcelable.h b/libs/vr/libbufferhubqueue/include/private/dvr/buffer_hub_queue_parcelable.h
index 89baf92..4dea9b2 100644
--- a/libs/vr/libbufferhubqueue/include/private/dvr/buffer_hub_queue_parcelable.h
+++ b/libs/vr/libbufferhubqueue/include/private/dvr/buffer_hub_queue_parcelable.h
@@ -1,8 +1,20 @@
#ifndef ANDROID_DVR_BUFFER_HUB_QUEUE_PARCELABLE_H_
#define ANDROID_DVR_BUFFER_HUB_QUEUE_PARCELABLE_H_
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Weverything"
+#endif
+
+// The following headers are included without checking every warning.
+// TODO(b/72172820): Remove the workaround once we have enforced -Weverything
+// in these headers and their dependencies.
#include <pdx/channel_parcelable.h>
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
namespace android {
namespace dvr {
@@ -17,8 +29,10 @@
BufferHubQueueParcelable() = default;
BufferHubQueueParcelable(BufferHubQueueParcelable&& other) = default;
- BufferHubQueueParcelable& operator=(BufferHubQueueParcelable&& other) =
- default;
+ BufferHubQueueParcelable& operator=(BufferHubQueueParcelable&& other) {
+ channel_parcelable_ = std::move(other.channel_parcelable_);
+ return *this;
+ }
// Constructs an parcelable contains the channel parcelable.
BufferHubQueueParcelable(
diff --git a/libs/vr/libdisplay/Android.bp b/libs/vr/libdisplay/Android.bp
index 192fb5d..093ad92 100644
--- a/libs/vr/libdisplay/Android.bp
+++ b/libs/vr/libdisplay/Android.bp
@@ -52,6 +52,11 @@
cc_library {
tags: ["tests"],
srcs: sourceFiles,
+ arch: {
+ arm: {
+ instruction_set: "arm",
+ },
+ },
cflags: ["-DLOG_TAG=\"libdisplay\"",
"-DTRACE=0",
"-DATRACE_TAG=ATRACE_TAG_GRAPHICS",
diff --git a/libs/vr/libpdx/Android.bp b/libs/vr/libpdx/Android.bp
index 9b84d65..d183f71 100644
--- a/libs/vr/libpdx/Android.bp
+++ b/libs/vr/libpdx/Android.bp
@@ -8,6 +8,11 @@
"-DLOG_TAG=\"libpdx\"",
"-DTRACE=0",
],
+ arch: {
+ arm: {
+ instruction_set: "arm",
+ },
+ },
export_include_dirs: ["private"],
local_include_dirs: ["private"],
srcs: [
diff --git a/libs/vr/libpdx/service_tests.cpp b/libs/vr/libpdx/service_tests.cpp
index c7412b7..e623abf 100644
--- a/libs/vr/libpdx/service_tests.cpp
+++ b/libs/vr/libpdx/service_tests.cpp
@@ -180,8 +180,8 @@
EXPECT_EQ(kTestTid, message.GetThreadId());
EXPECT_EQ(kTestCid, message.GetChannelId());
EXPECT_EQ(kTestMid, message.GetMessageId());
- EXPECT_EQ(kTestEuid, message.GetEffectiveUserId());
- EXPECT_EQ(kTestEgid, message.GetEffectiveGroupId());
+ EXPECT_EQ((unsigned) kTestEuid, message.GetEffectiveUserId());
+ EXPECT_EQ((unsigned) kTestEgid, message.GetEffectiveGroupId());
EXPECT_EQ(kTestOp, message.GetOp());
EXPECT_EQ(service_, message.GetService());
EXPECT_EQ(test_channel, message.GetChannel());
diff --git a/libs/vr/libpdx_uds/Android.bp b/libs/vr/libpdx_uds/Android.bp
index 79cfdf6..e7cf357 100644
--- a/libs/vr/libpdx_uds/Android.bp
+++ b/libs/vr/libpdx_uds/Android.bp
@@ -19,6 +19,11 @@
"ipc_helper.cpp",
"service_endpoint.cpp",
],
+ arch: {
+ arm: {
+ instruction_set: "arm",
+ },
+ },
static_libs: [
"libcutils",
"libbase",
diff --git a/libs/vr/libperformance/Android.bp b/libs/vr/libperformance/Android.bp
index 35d3dea..2eed602 100644
--- a/libs/vr/libperformance/Android.bp
+++ b/libs/vr/libperformance/Android.bp
@@ -36,6 +36,11 @@
"-Wall",
"-Werror",
],
+ arch: {
+ arm: {
+ instruction_set: "arm",
+ },
+ },
export_include_dirs: includeFiles,
shared_libs: sharedLibraries,
name: "libperformance",
diff --git a/libs/vr/libvr_manager/Android.bp b/libs/vr/libvr_manager/Android.bp
index 8784877..6060c6e 100644
--- a/libs/vr/libvr_manager/Android.bp
+++ b/libs/vr/libvr_manager/Android.bp
@@ -31,6 +31,11 @@
include_dirs: include_dirs,
export_include_dirs: exported_include_dirs,
cflags: ["-Wall", "-Werror", "-Wunused", "-Wunreachable-code"],
+ arch: {
+ arm: {
+ instruction_set: "arm",
+ },
+ },
static_libs: static_libs,
name: "libvr_manager",
}
diff --git a/libs/vr/libvrflinger/Android.bp b/libs/vr/libvrflinger/Android.bp
index 23a9853..c762e46 100644
--- a/libs/vr/libvrflinger/Android.bp
+++ b/libs/vr/libvrflinger/Android.bp
@@ -81,6 +81,11 @@
"-Wno-error=sign-compare", // to fix later
"-Wno-unused-variable",
],
+ arch: {
+ arm: {
+ instruction_set: "arm",
+ },
+ },
shared_libs: sharedLibraries,
whole_static_libs: staticLibraries,
header_libs: headerLibraries,
diff --git a/opengl/libs/EGL/eglApi.cpp b/opengl/libs/EGL/eglApi.cpp
index b00602c..46e7a97 100644
--- a/opengl/libs/EGL/eglApi.cpp
+++ b/opengl/libs/EGL/eglApi.cpp
@@ -2006,22 +2006,13 @@
egl_display_ptr dp = validate_display(dpy);
if (!dp) return EGL_NO_SURFACE;
- EGLint colorSpace = EGL_GL_COLORSPACE_LINEAR_KHR;
- android_dataspace dataSpace = HAL_DATASPACE_UNKNOWN;
- // TODO: Probably need to update EGL_KHR_stream_producer_eglsurface to
- // indicate support for EGL_GL_COLORSPACE_KHR.
- // now select a corresponding sRGB format if needed
- if (!getColorSpaceAttribute(dp, attrib_list, colorSpace, dataSpace)) {
- ALOGE("error invalid colorspace: %d", colorSpace);
- return setError(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
- }
-
egl_connection_t* const cnx = &gEGLImpl;
if (cnx->dso && cnx->egl.eglCreateStreamProducerSurfaceKHR) {
EGLSurface surface = cnx->egl.eglCreateStreamProducerSurfaceKHR(
dp->disp.dpy, config, stream, attrib_list);
if (surface != EGL_NO_SURFACE) {
- egl_surface_t* s = new egl_surface_t(dp.get(), config, NULL, surface, colorSpace, cnx);
+ egl_surface_t* s = new egl_surface_t(dp.get(), config, NULL, surface,
+ EGL_GL_COLORSPACE_LINEAR_KHR, cnx);
return s;
}
}
diff --git a/services/surfaceflinger/Android.bp b/services/surfaceflinger/Android.bp
index ae34d34..ae589ca 100644
--- a/services/surfaceflinger/Android.bp
+++ b/services/surfaceflinger/Android.bp
@@ -133,6 +133,11 @@
srcs: [
":libsurfaceflinger_sources",
],
+ arch: {
+ arm: {
+ instruction_set: "arm",
+ },
+ },
logtags: ["EventLog/EventLogTags.logtags"],
include_dirs: [
"external/vulkan-validation-layers/libs/vkjson",
diff --git a/services/surfaceflinger/layerproto/Android.bp b/services/surfaceflinger/layerproto/Android.bp
index 8eb218c..75612c0 100644
--- a/services/surfaceflinger/layerproto/Android.bp
+++ b/services/surfaceflinger/layerproto/Android.bp
@@ -9,6 +9,12 @@
"layerstrace.proto",
],
+ arch: {
+ arm: {
+ instruction_set: "arm",
+ },
+ },
+
shared_libs: [
"libui",
"libprotobuf-cpp-lite",
@@ -33,4 +39,4 @@
"-Wno-undef",
],
-}
\ No newline at end of file
+}
diff --git a/services/utils/Android.bp b/services/utils/Android.bp
index 6132956..a5f7dc1 100644
--- a/services/utils/Android.bp
+++ b/services/utils/Android.bp
@@ -27,6 +27,12 @@
"PriorityDumper.cpp",
],
+ arch: {
+ arm: {
+ instruction_set: "arm",
+ },
+ },
+
clang: true,
export_include_dirs: ["include"],
}
diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
index 9fbde8c..9266b12 100644
--- a/vulkan/libvulkan/swapchain.cpp
+++ b/vulkan/libvulkan/swapchain.cpp
@@ -573,8 +573,15 @@
}
// TODO(jessehall): Figure out what the min/max values should be.
+ int max_buffer_count;
+ err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &max_buffer_count);
+ if (err != 0) {
+ ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d)",
+ strerror(-err), err);
+ return VK_ERROR_SURFACE_LOST_KHR;
+ }
capabilities->minImageCount = 2;
- capabilities->maxImageCount = 3;
+ capabilities->maxImageCount = static_cast<uint32_t>(max_buffer_count);
capabilities->currentExtent =
VkExtent2D{static_cast<uint32_t>(width), static_cast<uint32_t>(height)};