Merge "Follow "atomic" to "group" refactoring."
diff --git a/cmds/dumpstate/Android.mk b/cmds/dumpstate/Android.mk
index d1e94ed..302a947 100644
--- a/cmds/dumpstate/Android.mk
+++ b/cmds/dumpstate/Android.mk
@@ -93,10 +93,6 @@
# ==========#
include $(CLEAR_VARS)
-ifdef BOARD_WLAN_DEVICE
-LOCAL_CFLAGS := -DFWDUMP_$(BOARD_WLAN_DEVICE)
-endif
-
LOCAL_SRC_FILES := $(COMMON_SRC_FILES) \
DumpstateService.cpp \
dumpstate.cpp
diff --git a/cmds/dumpstate/dumpstate.cpp b/cmds/dumpstate/dumpstate.cpp
index 9434d56..4812de5 100644
--- a/cmds/dumpstate/dumpstate.cpp
+++ b/cmds/dumpstate/dumpstate.cpp
@@ -1037,26 +1037,11 @@
RunCommand("WIFI NETWORKS", {"wpa_cli", "IFNAME=wlan0", "list_networks"},
CommandOptions::WithTimeout(20).Build());
-#ifdef FWDUMP_bcmdhd
- RunCommand("ND OFFLOAD TABLE", {WLUTIL, "nd_hostip"}, CommandOptions::AS_ROOT);
-
- RunCommand("DUMP WIFI INTERNAL COUNTERS (1)", {WLUTIL, "counters"}, AS_ROOT_20);
-
- RunCommand("ND OFFLOAD STATUS (1)", {WLUTIL, "nd_status"}, CommandOptions::AS_ROOT);
-
-#endif
DumpFile("INTERRUPTS (1)", "/proc/interrupts");
RunDumpsys("NETWORK DIAGNOSTICS", {"connectivity", "--diag"},
CommandOptions::WithTimeout(10).Build());
-#ifdef FWDUMP_bcmdhd
- RunCommand("DUMP WIFI STATUS", {"dhdutil", "-i", "wlan0", "dump"}, AS_ROOT_20);
-
- RunCommand("DUMP WIFI INTERNAL COUNTERS (2)", {WLUTIL, "counters"}, AS_ROOT_20);
-
- RunCommand("ND OFFLOAD STATUS (2)", {WLUTIL, "nd_status"}, CommandOptions::AS_ROOT);
-#endif
DumpFile("INTERRUPTS (2)", "/proc/interrupts");
RunCommand("SYSTEM PROPERTIES", {"getprop"});
diff --git a/cmds/lshal/Lshal.cpp b/cmds/lshal/Lshal.cpp
index 51a8682..a5cac15 100644
--- a/cmds/lshal/Lshal.cpp
+++ b/cmds/lshal/Lshal.cpp
@@ -257,8 +257,9 @@
continue;
}
// Strip out system libs.
- // TODO(b/34772739): might want to add other framework HAL packages
- if (fqName.inPackage("android.hidl")) {
+ if (fqName.inPackage("android.hidl") ||
+ fqName.inPackage("android.frameworks") ||
+ fqName.inPackage("android.system")) {
continue;
}
std::string interfaceName =
diff --git a/include/batteryservice/IBatteryPropertiesRegistrar.h b/include/batteryservice/IBatteryPropertiesRegistrar.h
index b5c3a4d..a7dbea6 100644
--- a/include/batteryservice/IBatteryPropertiesRegistrar.h
+++ b/include/batteryservice/IBatteryPropertiesRegistrar.h
@@ -27,6 +27,7 @@
REGISTER_LISTENER = IBinder::FIRST_CALL_TRANSACTION,
UNREGISTER_LISTENER,
GET_PROPERTY,
+ SCHEDULE_UPDATE,
};
class IBatteryPropertiesRegistrar : public IInterface {
@@ -36,6 +37,7 @@
virtual void registerListener(const sp<IBatteryPropertiesListener>& listener) = 0;
virtual void unregisterListener(const sp<IBatteryPropertiesListener>& listener) = 0;
virtual status_t getProperty(int id, struct BatteryProperty *val) = 0;
+ virtual void scheduleUpdate() = 0;
};
class BnBatteryPropertiesRegistrar : public BnInterface<IBatteryPropertiesRegistrar> {
diff --git a/libs/gui/BufferQueueCore.cpp b/libs/gui/BufferQueueCore.cpp
index 9e3fecb..d653db8 100644
--- a/libs/gui/BufferQueueCore.cpp
+++ b/libs/gui/BufferQueueCore.cpp
@@ -261,6 +261,13 @@
for (auto& b : mQueue) {
b.mIsStale = true;
+
+ // We set this to false to force the BufferQueue to resend the buffer
+ // handle upon acquire, since if we're here due to a producer
+ // disconnect, the consumer will have been told to purge its cache of
+ // slot-to-buffer-handle mappings and will not be able to otherwise
+ // obtain a valid buffer handle.
+ b.mAcquireCalled = false;
}
VALIDATE_CONSISTENCY();
diff --git a/libs/gui/tests/BufferQueue_test.cpp b/libs/gui/tests/BufferQueue_test.cpp
index 91ce531..907e0493 100644
--- a/libs/gui/tests/BufferQueue_test.cpp
+++ b/libs/gui/tests/BufferQueue_test.cpp
@@ -1117,4 +1117,64 @@
ASSERT_EQ(true, output.bufferReplaced);
}
+TEST_F(BufferQueueTest, TestStaleBufferHandleSentAfterDisconnect) {
+ createBufferQueue();
+ sp<DummyConsumer> dc(new DummyConsumer);
+ ASSERT_EQ(OK, mConsumer->consumerConnect(dc, true));
+ IGraphicBufferProducer::QueueBufferOutput output;
+ sp<IProducerListener> dummyListener(new DummyProducerListener);
+ ASSERT_EQ(OK, mProducer->connect(dummyListener, NATIVE_WINDOW_API_CPU,
+ true, &output));
+
+ int slot = BufferQueue::INVALID_BUFFER_SLOT;
+ sp<Fence> fence = Fence::NO_FENCE;
+ sp<GraphicBuffer> buffer = nullptr;
+ IGraphicBufferProducer::QueueBufferInput input(0ull, true,
+ HAL_DATASPACE_UNKNOWN, Rect::INVALID_RECT,
+ NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, Fence::NO_FENCE);
+
+ // Dequeue, request, and queue one buffer
+ status_t result = mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0,
+ nullptr);
+ ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION, result);
+ ASSERT_EQ(OK, mProducer->requestBuffer(slot, &buffer));
+ ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));
+
+ // Acquire and release the buffer. Upon acquiring, the buffer handle should
+ // be non-null since this is the first time we've acquired this slot.
+ BufferItem item;
+ ASSERT_EQ(OK, mConsumer->acquireBuffer(&item, 0));
+ ASSERT_EQ(slot, item.mSlot);
+ ASSERT_NE(nullptr, item.mGraphicBuffer.get());
+ ASSERT_EQ(OK, mConsumer->releaseBuffer(item.mSlot, item.mFrameNumber,
+ EGL_NO_DISPLAY, EGL_NO_SYNC_KHR, Fence::NO_FENCE));
+
+ // Dequeue and queue the buffer again
+ ASSERT_EQ(OK, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr));
+ ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));
+
+ // Acquire and release the buffer again. Upon acquiring, the buffer handle
+ // should be null since this is not the first time we've acquired this slot.
+ ASSERT_EQ(OK, mConsumer->acquireBuffer(&item, 0));
+ ASSERT_EQ(slot, item.mSlot);
+ ASSERT_EQ(nullptr, item.mGraphicBuffer.get());
+ ASSERT_EQ(OK, mConsumer->releaseBuffer(item.mSlot, item.mFrameNumber,
+ EGL_NO_DISPLAY, EGL_NO_SYNC_KHR, Fence::NO_FENCE));
+
+ // Dequeue and queue the buffer again
+ ASSERT_EQ(OK, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0, nullptr));
+ ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));
+
+ // Disconnect the producer end. This should clear all of the slots and mark
+ // the buffer in the queue as stale.
+ ASSERT_EQ(OK, mProducer->disconnect(NATIVE_WINDOW_API_CPU));
+
+ // Acquire the buffer again. Upon acquiring, the buffer handle should not be
+ // null since the queued buffer should have been marked as stale, which
+ // should trigger the BufferQueue to resend the buffer handle.
+ ASSERT_EQ(OK, mConsumer->acquireBuffer(&item, 0));
+ ASSERT_EQ(slot, item.mSlot);
+ ASSERT_NE(nullptr, item.mGraphicBuffer.get());
+}
+
} // namespace android
diff --git a/libs/vr/libvrflinger/hardware_composer.cpp b/libs/vr/libvrflinger/hardware_composer.cpp
index da45859..542bbd9 100644
--- a/libs/vr/libvrflinger/hardware_composer.cpp
+++ b/libs/vr/libvrflinger/hardware_composer.cpp
@@ -518,10 +518,13 @@
post_thread_cond_var_.notify_all();
}
-int HardwareComposer::PostThreadPollInterruptible(int event_fd) {
+int HardwareComposer::PostThreadPollInterruptible(int event_fd,
+ int requested_events) {
pollfd pfd[2] = {
{
- .fd = event_fd, .events = POLLPRI | POLLIN, .revents = 0,
+ .fd = event_fd,
+ .events = static_cast<short>(requested_events),
+ .revents = 0,
},
{
.fd = post_thread_interrupt_event_fd_.Get(),
@@ -645,7 +648,9 @@
// TODO(eieio): This is pretty driver specific, this should be moved to a
// separate class eventually.
int HardwareComposer::BlockUntilVSync() {
- return PostThreadPollInterruptible(primary_display_vsync_event_fd_.Get());
+ return PostThreadPollInterruptible(primary_display_vsync_event_fd_.Get(),
+ // There will be a POLLPRI event on vsync
+ POLLPRI);
}
// Waits for the next vsync and returns the timestamp of the vsync event. If
@@ -718,7 +723,7 @@
return -error;
}
- return PostThreadPollInterruptible(timer_fd);
+ return PostThreadPollInterruptible(timer_fd, POLLIN);
}
void HardwareComposer::PostThread() {
diff --git a/libs/vr/libvrflinger/hardware_composer.h b/libs/vr/libvrflinger/hardware_composer.h
index 2d3d78b..e570cb6 100644
--- a/libs/vr/libvrflinger/hardware_composer.h
+++ b/libs/vr/libvrflinger/hardware_composer.h
@@ -281,7 +281,7 @@
// Blocks until either event_fd becomes readable, or we're interrupted by a
// control thread. Any errors are returned as negative errno values. If we're
// interrupted, kPostThreadInterrupted will be returned.
- int PostThreadPollInterruptible(int event_fd);
+ int PostThreadPollInterruptible(int event_fd, int requested_events);
// BlockUntilVSync, WaitForVSync, and SleepUntil are all blocking calls made
// on the post thread that can be interrupted by a control thread. If
diff --git a/services/batteryservice/IBatteryPropertiesRegistrar.cpp b/services/batteryservice/IBatteryPropertiesRegistrar.cpp
index 1fdda43..01a65ae 100644
--- a/services/batteryservice/IBatteryPropertiesRegistrar.cpp
+++ b/services/batteryservice/IBatteryPropertiesRegistrar.cpp
@@ -60,6 +60,12 @@
val->readFromParcel(&reply);
return ret;
}
+
+ void scheduleUpdate() {
+ Parcel data;
+ data.writeInterfaceToken(IBatteryPropertiesRegistrar::getInterfaceDescriptor());
+ remote()->transact(SCHEDULE_UPDATE, data, NULL);
+ }
};
IMPLEMENT_META_INTERFACE(BatteryPropertiesRegistrar, "android.os.IBatteryPropertiesRegistrar");
@@ -97,6 +103,12 @@
val.writeToParcel(reply);
return OK;
}
+
+ case SCHEDULE_UPDATE: {
+ CHECK_INTERFACE(IBatteryPropertiesRegistrar, data, reply);
+ scheduleUpdate();
+ return OK;
+ }
}
return BBinder::onTransact(code, data, reply, flags);
};
diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp
index 2755206..ac7e083 100644
--- a/services/surfaceflinger/Layer.cpp
+++ b/services/surfaceflinger/Layer.cpp
@@ -595,7 +595,7 @@
const State& s(getDrawingState());
#ifdef USE_HWC2
auto blendMode = HWC2::BlendMode::None;
- if (!isOpaque(s) || s.alpha != 1.0f) {
+ if (!isOpaque(s) || getAlpha() != 1.0f) {
blendMode = mPremultipliedAlpha ?
HWC2::BlendMode::Premultiplied : HWC2::BlendMode::Coverage;
}
@@ -604,7 +604,7 @@
" %s (%d)", mName.string(), to_string(blendMode).c_str(),
to_string(error).c_str(), static_cast<int32_t>(error));
#else
- if (!isOpaque(s) || s.alpha != 0xFF) {
+ if (!isOpaque(s) || getAlpha() != 0xFF) {
layer.setBlending(mPremultipliedAlpha ?
HWC_BLENDING_PREMULT :
HWC_BLENDING_COVERAGE);
@@ -678,9 +678,10 @@
hwcInfo.sourceCrop = sourceCrop;
}
- error = hwcLayer->setPlaneAlpha(s.alpha);
+ float alpha = getAlpha();
+ error = hwcLayer->setPlaneAlpha(alpha);
ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set plane alpha %.3f: "
- "%s (%d)", mName.string(), s.alpha, to_string(error).c_str(),
+ "%s (%d)", mName.string(), alpha, to_string(error).c_str(),
static_cast<int32_t>(error));
error = hwcLayer->setZOrder(z);
@@ -698,7 +699,7 @@
const Transform& tr(hw->getTransform());
layer.setFrame(tr.transform(frame));
layer.setCrop(computeCrop(hw));
- layer.setPlaneAlpha(s.alpha);
+ layer.setPlaneAlpha(getAlpha());
#endif
/*
@@ -1147,7 +1148,7 @@
texCoords[3] = vec2(right, 1.0f - top);
RenderEngine& engine(mFlinger->getRenderEngine());
- engine.setupLayerBlending(mPremultipliedAlpha, isOpaque(s), s.alpha);
+ engine.setupLayerBlending(mPremultipliedAlpha, isOpaque(s), getAlpha());
engine.drawMesh(mMesh);
engine.disableBlending();
}
@@ -1753,11 +1754,15 @@
setTransactionFlags(eTransactionNeeded);
return true;
}
-bool Layer::setFinalCrop(const Rect& crop) {
+
+bool Layer::setFinalCrop(const Rect& crop, bool immediate) {
if (mCurrentState.finalCrop == crop)
return false;
mCurrentState.sequence++;
- mCurrentState.finalCrop = crop;
+ mCurrentState.requestedFinalCrop = crop;
+ if (immediate) {
+ mCurrentState.finalCrop = crop;
+ }
mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
@@ -1957,12 +1962,11 @@
}
bool Layer::isVisible() const {
- const Layer::State& s(mDrawingState);
#ifdef USE_HWC2
- return !(isHiddenByPolicy()) && s.alpha > 0.0f
+ return !(isHiddenByPolicy()) && getAlpha() > 0.0f
&& (mActiveBuffer != NULL || mSidebandStream != NULL);
#else
- return !(isHiddenByPolicy()) && s.alpha
+ return !(isHiddenByPolicy()) && getAlpha()
&& (mActiveBuffer != NULL || mSidebandStream != NULL);
#endif
}
@@ -2519,6 +2523,24 @@
return t * getDrawingState().active.transform;
}
+#ifdef USE_HWC2
+float Layer::getAlpha() const {
+ const auto& p = getParent();
+
+ float parentAlpha = (p != nullptr) ? p->getAlpha() : 1.0;
+ return parentAlpha * getDrawingState().alpha;
+}
+#else
+uint8_t Layer::getAlpha() const {
+ const auto& p = getParent();
+
+ float parentAlpha = (p != nullptr) ? (p->getAlpha() / 255.0f) : 1.0;
+ float drawingAlpha = getDrawingState().alpha / 255.0f;
+ drawingAlpha = drawingAlpha * parentAlpha;
+ return static_cast<uint8_t>(std::round(drawingAlpha * 255));
+}
+#endif
+
void Layer::commitChildList() {
for (size_t i = 0; i < mCurrentChildren.size(); i++) {
const auto& child = mCurrentChildren[i];
diff --git a/services/surfaceflinger/Layer.h b/services/surfaceflinger/Layer.h
index cee9e3c..e21be8b 100644
--- a/services/surfaceflinger/Layer.h
+++ b/services/surfaceflinger/Layer.h
@@ -135,6 +135,7 @@
// finalCrop is expressed in display space coordinate.
Rect finalCrop;
+ Rect requestedFinalCrop;
// If set, defers this state update until the identified Layer
// receives a frame with the given frameNumber
@@ -163,7 +164,14 @@
status_t setBuffers(uint32_t w, uint32_t h, PixelFormat format, uint32_t flags);
// modify current state
+
+ // These members of state (position, crop, and finalCrop)
+ // may be updated immediately or have the update delayed
+ // until a pending surface resize completes (if applicable).
bool setPosition(float x, float y, bool immediate);
+ bool setCrop(const Rect& crop, bool immediate);
+ bool setFinalCrop(const Rect& crop, bool immediate);
+
bool setLayer(int32_t z);
bool setSize(uint32_t w, uint32_t h);
#ifdef USE_HWC2
@@ -174,8 +182,6 @@
bool setMatrix(const layer_state_t::matrix22_t& matrix);
bool setTransparentRegionHint(const Region& transparent);
bool setFlags(uint8_t flags, uint8_t mask);
- bool setCrop(const Rect& crop, bool immediate);
- bool setFinalCrop(const Rect& crop);
bool setLayerStack(uint32_t layerStack);
bool setDataSpace(android_dataspace dataSpace);
uint32_t getLayerStack() const;
@@ -453,6 +459,15 @@
Transform getTransform() const;
+ // Returns the Alpha of the Surface, accounting for the Alpha
+ // of parent Surfaces in the hierarchy (alpha's will be multiplied
+ // down the hierarchy).
+#ifdef USE_HWC2
+ float getAlpha() const;
+#else
+ uint8_t getAlpha() const;
+#endif
+
void traverseInReverseZOrder(const std::function<void(Layer*)>& exec);
void traverseInZOrder(const std::function<void(Layer*)>& exec);
diff --git a/services/surfaceflinger/LayerRejecter.cpp b/services/surfaceflinger/LayerRejecter.cpp
index 5ca7d39..0b302eb 100644
--- a/services/surfaceflinger/LayerRejecter.cpp
+++ b/services/surfaceflinger/LayerRejecter.cpp
@@ -120,6 +120,11 @@
mCurrent.crop = mFront.requestedCrop;
mRecomputeVisibleRegions = true;
}
+ if (mFront.finalCrop != mFront.requestedFinalCrop) {
+ mFront.finalCrop = mFront.requestedFinalCrop;
+ mCurrent.finalCrop = mFront.requestedFinalCrop;
+ mRecomputeVisibleRegions = true;
+ }
mFreezePositionUpdates = false;
return false;
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index a63b9b4..f82b363 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -2766,7 +2766,7 @@
flags |= eTraversalNeeded;
}
if (what & layer_state_t::eFinalCropChanged) {
- if (layer->setFinalCrop(s.finalCrop))
+ if (layer->setFinalCrop(s.finalCrop, !geometryAppliesWithResize))
flags |= eTraversalNeeded;
}
if (what & layer_state_t::eLayerStackChanged) {
diff --git a/services/surfaceflinger/SurfaceFlinger_hwc1.cpp b/services/surfaceflinger/SurfaceFlinger_hwc1.cpp
index cd02b13..c26847f 100644
--- a/services/surfaceflinger/SurfaceFlinger_hwc1.cpp
+++ b/services/surfaceflinger/SurfaceFlinger_hwc1.cpp
@@ -2564,7 +2564,7 @@
flags |= eTraversalNeeded;
}
if (what & layer_state_t::eFinalCropChanged) {
- if (layer->setFinalCrop(s.finalCrop))
+ if (layer->setFinalCrop(s.finalCrop, !geometryAppliesWithResize))
flags |= eTraversalNeeded;
}
if (what & layer_state_t::eLayerStackChanged) {
diff --git a/services/surfaceflinger/tests/Android.mk b/services/surfaceflinger/tests/Android.mk
index f46ce8a..16041da 100644
--- a/services/surfaceflinger/tests/Android.mk
+++ b/services/surfaceflinger/tests/Android.mk
@@ -28,6 +28,8 @@
LOCAL_CFLAGS += -Wall -Werror -Wunused -Wunreachable-code
+LOCAL_TEST_DATA = SurfaceFlinger_test.filter
+
# Build the binary to $(TARGET_OUT_DATA_NATIVE_TESTS)/$(LOCAL_MODULE)
# to integrate with auto-test framework.
include $(BUILD_NATIVE_TEST)
diff --git a/services/surfaceflinger/tests/SurfaceFlinger_test.filter b/services/surfaceflinger/tests/SurfaceFlinger_test.filter
new file mode 100644
index 0000000..915b5cd
--- /dev/null
+++ b/services/surfaceflinger/tests/SurfaceFlinger_test.filter
@@ -0,0 +1,5 @@
+{
+ "presubmit": {
+ "filter": "LayerUpdateTest.*:ChildLayerTest.*:SurfaceFlingerStress.*"
+ }
+}
\ No newline at end of file
diff --git a/services/surfaceflinger/tests/Transaction_test.cpp b/services/surfaceflinger/tests/Transaction_test.cpp
index aeb557a..a46ba48 100644
--- a/services/surfaceflinger/tests/Transaction_test.cpp
+++ b/services/surfaceflinger/tests/Transaction_test.cpp
@@ -470,6 +470,141 @@
}
}
+class GeometryLatchingTest : public LayerUpdateTest {
+protected:
+ void EXPECT_INITIAL_STATE(const char * trace) {
+ SCOPED_TRACE(trace);
+ ScreenCapture::captureScreen(&sc);
+ // We find the leading edge of the FG surface.
+ sc->expectFGColor(127, 127);
+ sc->expectBGColor(128, 128);
+ }
+ void completeFGResize() {
+ fillSurfaceRGBA8(mFGSurfaceControl, 195, 63, 63);
+ waitForPostedBuffers();
+ }
+ void restoreInitialState() {
+ SurfaceComposerClient::openGlobalTransaction();
+ mFGSurfaceControl->setSize(64, 64);
+ mFGSurfaceControl->setPosition(64, 64);
+ mFGSurfaceControl->setCrop(Rect(0, 0, 64, 64));
+ mFGSurfaceControl->setFinalCrop(Rect(0, 0, -1, -1));
+ SurfaceComposerClient::closeGlobalTransaction(true);
+
+ EXPECT_INITIAL_STATE("After restoring initial state");
+ }
+ sp<ScreenCapture> sc;
+};
+
+TEST_F(GeometryLatchingTest, SurfacePositionLatching) {
+ EXPECT_INITIAL_STATE("before anything");
+
+ // By default position can be updated even while
+ // a resize is pending.
+ SurfaceComposerClient::openGlobalTransaction();
+ mFGSurfaceControl->setSize(32, 32);
+ mFGSurfaceControl->setPosition(100, 100);
+ SurfaceComposerClient::closeGlobalTransaction(true);
+
+ {
+ SCOPED_TRACE("After moving surface");
+ ScreenCapture::captureScreen(&sc);
+ // If we moved, the FG Surface should cover up what was previously BG
+ // however if we didn't move the FG wouldn't be large enough now.
+ sc->expectFGColor(163, 163);
+ }
+
+ restoreInitialState();
+
+ // Now we repeat with setGeometryAppliesWithResize
+ // and verify the position DOESN'T latch.
+ SurfaceComposerClient::openGlobalTransaction();
+ mFGSurfaceControl->setGeometryAppliesWithResize();
+ mFGSurfaceControl->setSize(32, 32);
+ mFGSurfaceControl->setPosition(100, 100);
+ SurfaceComposerClient::closeGlobalTransaction(true);
+
+ {
+ SCOPED_TRACE("While resize is pending");
+ ScreenCapture::captureScreen(&sc);
+ // This time we shouldn't have moved, so the BG color
+ // should still be visible.
+ sc->expectBGColor(128, 128);
+ }
+
+ completeFGResize();
+
+ {
+ SCOPED_TRACE("After the resize");
+ ScreenCapture::captureScreen(&sc);
+ // But after the resize completes, we should move
+ // and the FG should be visible here.
+ sc->expectFGColor(128, 128);
+ }
+}
+
+class CropLatchingTest : public GeometryLatchingTest {
+protected:
+ void EXPECT_CROPPED_STATE(const char* trace) {
+ SCOPED_TRACE(trace);
+ ScreenCapture::captureScreen(&sc);
+ // The edge should be moved back one pixel by our crop.
+ sc->expectFGColor(126, 126);
+ sc->expectBGColor(127, 127);
+ sc->expectBGColor(128, 128);
+ }
+};
+
+TEST_F(CropLatchingTest, CropLatching) {
+ EXPECT_INITIAL_STATE("before anything");
+ // Normally the crop applies immediately even while a resize is pending.
+ SurfaceComposerClient::openGlobalTransaction();
+ mFGSurfaceControl->setSize(128, 128);
+ mFGSurfaceControl->setCrop(Rect(0, 0, 63, 63));
+ SurfaceComposerClient::closeGlobalTransaction(true);
+
+ EXPECT_CROPPED_STATE("after setting crop (without geometryAppliesWithResize)");
+
+ restoreInitialState();
+
+ SurfaceComposerClient::openGlobalTransaction();
+ mFGSurfaceControl->setSize(128, 128);
+ mFGSurfaceControl->setGeometryAppliesWithResize();
+ mFGSurfaceControl->setCrop(Rect(0, 0, 63, 63));
+ SurfaceComposerClient::closeGlobalTransaction(true);
+
+ EXPECT_INITIAL_STATE("after setting crop (with geometryAppliesWithResize)");
+
+ completeFGResize();
+
+ EXPECT_CROPPED_STATE("after the resize finishes");
+}
+
+TEST_F(CropLatchingTest, FinalCropLatching) {
+ EXPECT_INITIAL_STATE("before anything");
+ // Normally the crop applies immediately even while a resize is pending.
+ SurfaceComposerClient::openGlobalTransaction();
+ mFGSurfaceControl->setSize(128, 128);
+ mFGSurfaceControl->setFinalCrop(Rect(64, 64, 127, 127));
+ SurfaceComposerClient::closeGlobalTransaction(true);
+
+ EXPECT_CROPPED_STATE("after setting crop (without geometryAppliesWithResize)");
+
+ restoreInitialState();
+
+ SurfaceComposerClient::openGlobalTransaction();
+ mFGSurfaceControl->setSize(128, 128);
+ mFGSurfaceControl->setGeometryAppliesWithResize();
+ mFGSurfaceControl->setFinalCrop(Rect(64, 64, 127, 127));
+ SurfaceComposerClient::closeGlobalTransaction(true);
+
+ EXPECT_INITIAL_STATE("after setting crop (with geometryAppliesWithResize)");
+
+ completeFGResize();
+
+ EXPECT_CROPPED_STATE("after the resize finishes");
+}
+
TEST_F(LayerUpdateTest, DeferredTransactionTest) {
sp<ScreenCapture> sc;
{
@@ -629,6 +764,45 @@
}
}
+TEST_F(ChildLayerTest, ChildLayerAlpha) {
+ fillSurfaceRGBA8(mBGSurfaceControl, 0, 0, 254);
+ fillSurfaceRGBA8(mFGSurfaceControl, 254, 0, 0);
+ fillSurfaceRGBA8(mChild, 0, 254, 0);
+ waitForPostedBuffers();
+
+ SurfaceComposerClient::openGlobalTransaction();
+ mChild->show();
+ mChild->setPosition(0, 0);
+ mFGSurfaceControl->setPosition(0, 0);
+ SurfaceComposerClient::closeGlobalTransaction(true);
+
+ {
+ ScreenCapture::captureScreen(&mCapture);
+ // Unblended child color
+ mCapture->checkPixel(0, 0, 0, 254, 0);
+ }
+
+ SurfaceComposerClient::openGlobalTransaction();
+ ASSERT_EQ(NO_ERROR, mChild->setAlpha(0.5));
+ SurfaceComposerClient::closeGlobalTransaction(true);
+
+ {
+ ScreenCapture::captureScreen(&mCapture);
+ // Child and BG blended.
+ mCapture->checkPixel(0, 0, 127, 127, 0);
+ }
+
+ SurfaceComposerClient::openGlobalTransaction();
+ ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setAlpha(0.5));
+ SurfaceComposerClient::closeGlobalTransaction(true);
+
+ {
+ ScreenCapture::captureScreen(&mCapture);
+ // Child and BG blended.
+ mCapture->checkPixel(0, 0, 95, 64, 95);
+ }
+}
+
TEST_F(ChildLayerTest, ReparentChildren) {
SurfaceComposerClient::openGlobalTransaction();
mChild->show();
@@ -677,11 +851,11 @@
SurfaceComposerClient::openGlobalTransaction();
mFGSurfaceControl->detachChildren();
- SurfaceComposerClient::closeGlobalTransaction();
+ SurfaceComposerClient::closeGlobalTransaction(true);
SurfaceComposerClient::openGlobalTransaction();
mChild->hide();
- SurfaceComposerClient::closeGlobalTransaction();
+ SurfaceComposerClient::closeGlobalTransaction(true);
// Nothing should have changed.
{
diff --git a/services/vr/vr_window_manager/aidl/android/service/vr/IVrWindowManager.aidl b/services/vr/vr_window_manager/aidl/android/service/vr/IVrWindowManager.aidl
index b5dbb8b..67fd927 100644
--- a/services/vr/vr_window_manager/aidl/android/service/vr/IVrWindowManager.aidl
+++ b/services/vr/vr_window_manager/aidl/android/service/vr/IVrWindowManager.aidl
@@ -24,5 +24,6 @@
void enterVrMode() = 2;
void exitVrMode() = 3;
void setDebugMode(int mode) = 4;
+ void set2DMode(int mode) = 5;
}
diff --git a/services/vr/vr_window_manager/display_view.cpp b/services/vr/vr_window_manager/display_view.cpp
index 5f1e73e..8a1c84d 100644
--- a/services/vr/vr_window_manager/display_view.cpp
+++ b/services/vr/vr_window_manager/display_view.cpp
@@ -8,7 +8,6 @@
namespace {
constexpr float kLayerScaleFactor = 3.0f;
-constexpr unsigned int kVRAppLayerCount = 2;
constexpr unsigned int kMaximumPendingFrames = 8;
// clang-format off
@@ -99,7 +98,7 @@
// Determine if ths frame should be shown or hidden.
ViewMode CalculateVisibilityFromLayerConfig(const HwcCallback::Frame& frame,
- uint32_t vr_app) {
+ uint32_t *appid) {
auto& layers = frame.layers();
// TODO(achaulk): Figure out how to identify the current VR app for 2D app
@@ -120,6 +119,11 @@
return ViewMode::Hidden;
}
+ if(layers[index].appid != *appid) {
+ *appid = layers[index].appid;
+ return ViewMode::App;
+ }
+
// This is the VR app, ignore it.
index++;
@@ -136,6 +140,7 @@
if (!layers[i].should_skip_layer())
return ViewMode::VR;
}
+
return ViewMode::Hidden;
}
@@ -198,16 +203,25 @@
base::unique_fd DisplayView::OnFrame(std::unique_ptr<HwcCallback::Frame> frame,
bool debug_mode, bool* showing) {
- ViewMode visibility =
- CalculateVisibilityFromLayerConfig(*frame.get(), current_vr_app_);
+ uint32_t app = current_vr_app_;
+ ViewMode visibility = CalculateVisibilityFromLayerConfig(*frame.get(), &app);
if (visibility == ViewMode::Hidden && debug_mode)
visibility = ViewMode::VR;
- if (frame->layers().empty())
+ if (frame->layers().empty()) {
current_vr_app_ = 0;
- else
- current_vr_app_ = frame->layers().front().appid;
+ } else if (visibility == ViewMode::App) {
+ // This is either a VR app switch or a 2D app launching.
+ // If we can have VR apps, update if it's 0.
+ if (!always_2d_ && (current_vr_app_ == 0 || !use_2dmode_)) {
+ visibility = ViewMode::Hidden;
+ current_vr_app_ = app;
+ }
+ } else if (!current_vr_app_) {
+ // The VR app is running.
+ current_vr_app_ = app;
+ }
pending_frames_.emplace_back(std::move(frame), visibility);
diff --git a/services/vr/vr_window_manager/display_view.h b/services/vr/vr_window_manager/display_view.h
index 0a27781..9483e8b 100644
--- a/services/vr/vr_window_manager/display_view.h
+++ b/services/vr/vr_window_manager/display_view.h
@@ -44,6 +44,9 @@
uint32_t id() const { return id_; }
int touchpad_id() const { return touchpad_id_; }
+ void set_2dmode(bool mode) { use_2dmode_ = mode; }
+ void set_always_2d(bool mode) { always_2d_ = mode; }
+
private:
bool IsHit(const vec3& view_location, const vec3& view_direction,
vec3* hit_location, vec2* hit_location_in_window_coord,
@@ -79,6 +82,8 @@
vec2 ime_top_left_;
vec2 ime_size_;
bool has_ime_ = false;
+ bool use_2dmode_ = false;
+ bool always_2d_ = false;
struct PendingFrame {
PendingFrame() = default;
diff --git a/services/vr/vr_window_manager/shell_view.cpp b/services/vr/vr_window_manager/shell_view.cpp
index a21e883..e17b2ae 100644
--- a/services/vr/vr_window_manager/shell_view.cpp
+++ b/services/vr/vr_window_manager/shell_view.cpp
@@ -16,6 +16,8 @@
namespace {
+constexpr uint32_t kPrimaryDisplayId = 1;
+
const std::string kVertexShader = SHADER0([]() {
layout(location = 0) in vec4 aPosition;
layout(location = 1) in vec4 aTexCoord;
@@ -96,8 +98,8 @@
}
int GetTouchIdForDisplay(uint32_t display) {
- return display == 1 ? DVR_VIRTUAL_TOUCHPAD_PRIMARY
- : DVR_VIRTUAL_TOUCHPAD_VIRTUAL;
+ return display == kPrimaryDisplayId ? DVR_VIRTUAL_TOUCHPAD_PRIMARY
+ : DVR_VIRTUAL_TOUCHPAD_VIRTUAL;
}
} // namespace
@@ -190,6 +192,11 @@
result.append("\n");
}
+void ShellView::Set2DMode(bool mode) {
+ if (!displays_.empty())
+ displays_[0]->set_2dmode(mode);
+}
+
void ShellView::OnDrawFrame() {
bool visible = false;
@@ -253,6 +260,9 @@
}
auto display = new DisplayView(id, GetTouchIdForDisplay(id));
+ // Virtual displays only ever have 2D apps so force it.
+ if (id != kPrimaryDisplayId)
+ display->set_always_2d(true);
new_displays_.emplace_back(display);
return display;
}
diff --git a/services/vr/vr_window_manager/shell_view.h b/services/vr/vr_window_manager/shell_view.h
index 856c8b8..6887e7e 100644
--- a/services/vr/vr_window_manager/shell_view.h
+++ b/services/vr/vr_window_manager/shell_view.h
@@ -32,6 +32,8 @@
void EnableDebug(bool debug) override;
void VrMode(bool mode) override;
void dumpInternal(String8& result) override;
+ void Set2DMode(bool mode) override;
+
protected:
void DrawEye(EyeType eye, const mat4& perspective, const mat4& eye_matrix,
diff --git a/services/vr/vr_window_manager/shell_view_binder_interface.h b/services/vr/vr_window_manager/shell_view_binder_interface.h
index b58e4bd..9f77e5a 100644
--- a/services/vr/vr_window_manager/shell_view_binder_interface.h
+++ b/services/vr/vr_window_manager/shell_view_binder_interface.h
@@ -12,6 +12,7 @@
virtual void EnableDebug(bool debug) = 0;
virtual void VrMode(bool mode) = 0;
virtual void dumpInternal(String8& result) = 0;
+ virtual void Set2DMode(bool mode) = 0;
};
} // namespace dvr
diff --git a/services/vr/vr_window_manager/vr_window_manager_binder.cpp b/services/vr/vr_window_manager/vr_window_manager_binder.cpp
index bd3f3ee..8868588 100644
--- a/services/vr/vr_window_manager/vr_window_manager_binder.cpp
+++ b/services/vr/vr_window_manager/vr_window_manager_binder.cpp
@@ -133,6 +133,11 @@
return binder::Status::ok();
}
+binder::Status VrWindowManagerBinder::set2DMode(int32_t mode) {
+ app_.Set2DMode(static_cast<bool>(mode));
+ return binder::Status::ok();
+}
+
status_t VrWindowManagerBinder::dump(
int fd, const Vector<String16>& args [[gnu::unused]]) {
String8 result;
diff --git a/services/vr/vr_window_manager/vr_window_manager_binder.h b/services/vr/vr_window_manager/vr_window_manager_binder.h
index 99ca27a..1915ffc 100644
--- a/services/vr/vr_window_manager/vr_window_manager_binder.h
+++ b/services/vr/vr_window_manager/vr_window_manager_binder.h
@@ -59,6 +59,7 @@
::android::binder::Status enterVrMode() override;
::android::binder::Status exitVrMode() override;
::android::binder::Status setDebugMode(int32_t mode) override;
+ ::android::binder::Status set2DMode(int32_t mode) override;
// Implements BBinder::dump().
status_t dump(int fd, const Vector<String16>& args) override;
diff --git a/services/vr/vr_window_manager/vr_wm_ctl.cpp b/services/vr/vr_window_manager/vr_wm_ctl.cpp
index c67b2eb..2e5c488 100644
--- a/services/vr/vr_window_manager/vr_wm_ctl.cpp
+++ b/services/vr/vr_window_manager/vr_wm_ctl.cpp
@@ -39,6 +39,8 @@
exit(report(vrwm->exitVrMode()));
} else if ((argc == 3) && (strcmp(argv[1], "debug") == 0)) {
exit(report(vrwm->setDebugMode(atoi(argv[2]))));
+ } else if ((argc == 3) && (strcmp(argv[1], "2d") == 0)) {
+ exit(report(vrwm->set2DMode(atoi(argv[2]))));
} else {
usage();
exit(2);