Merge "SurfaceFlinger: update orientation via transactions" into ics-mr0 (075e4c3d) · Commits · e / os / android_frameworks_base

include/surfaceflinger/ISurfaceComposer.h

+3 −9

Original line number	Diff line number	Diff line
		@@ -80,6 +80,7 @@ public:
		eOrientation90 = 1,
		eOrientation180 = 2,
		eOrientation270 = 3,
		eOrientationUnchanged = 4,
		eOrientationSwapMask = 0x01
		};

		@@ -101,15 +102,8 @@ public:
		virtual sp<IMemoryHeap> getCblk() const = 0;

		/* open/close transactions. requires ACCESS_SURFACE_FLINGER permission */
		virtual void setTransactionState(const Vector<ComposerState>& state) = 0;

		/* [un]freeze display. requires ACCESS_SURFACE_FLINGER permission */
		virtual status_t freezeDisplay(DisplayID dpy, uint32_t flags) = 0;
		virtual status_t unfreezeDisplay(DisplayID dpy, uint32_t flags) = 0;

		/* Set display orientation. requires ACCESS_SURFACE_FLINGER permission
		* No flags are currently defined. Set flags to 0. */
		virtual int setOrientation(DisplayID dpy, int orientation, uint32_t flags) = 0;
		virtual void setTransactionState(const Vector<ComposerState>& state,
		int orientation) = 0;

		/* signal that we're done booting.
		* Requires ACCESS_SURFACE_FLINGER permission

include/surfaceflinger/SurfaceComposerClient.h

+0 −1

Original line number	Diff line number	Diff line
		@@ -195,4 +195,3 @@ public:
		}; // namespace android

		#endif // ANDROID_SF_SURFACE_COMPOSER_CLIENT_H

libs/gui/ISurfaceComposer.cpp

+4 −51

Original line number	Diff line number	Diff line
		@@ -78,7 +78,8 @@ public:
		return interface_cast<IMemoryHeap>(reply.readStrongBinder());
		}

		virtual void setTransactionState(const Vector<ComposerState>& state)
		virtual void setTransactionState(const Vector<ComposerState>& state,
		int orientation)
		{
		Parcel data, reply;
		data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
		@@ -88,38 +89,8 @@ public:
		for ( ; b != e ; ++b ) {
		b->write(data);
		}
		remote()->transact(BnSurfaceComposer::SET_TRANSACTION_STATE, data, &reply);
		}

		virtual status_t freezeDisplay(DisplayID dpy, uint32_t flags)
		{
		Parcel data, reply;
		data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
		data.writeInt32(dpy);
		data.writeInt32(flags);
		remote()->transact(BnSurfaceComposer::FREEZE_DISPLAY, data, &reply);
		return reply.readInt32();
		}

		virtual status_t unfreezeDisplay(DisplayID dpy, uint32_t flags)
		{
		Parcel data, reply;
		data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
		data.writeInt32(dpy);
		data.writeInt32(flags);
		remote()->transact(BnSurfaceComposer::UNFREEZE_DISPLAY, data, &reply);
		return reply.readInt32();
		}

		virtual int setOrientation(DisplayID dpy, int orientation, uint32_t flags)
		{
		Parcel data, reply;
		data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
		data.writeInt32(dpy);
		data.writeInt32(orientation);
		data.writeInt32(flags);
		remote()->transact(BnSurfaceComposer::SET_ORIENTATION, data, &reply);
		return reply.readInt32();
		remote()->transact(BnSurfaceComposer::SET_TRANSACTION_STATE, data, &reply);
		}

		virtual void bootFinished()
		@@ -232,26 +203,8 @@ status_t BnSurfaceComposer::onTransact(
		s.read(data);
		state.add(s);
		}
		setTransactionState(state);
		} break;
		case SET_ORIENTATION: {
		CHECK_INTERFACE(ISurfaceComposer, data, reply);
		DisplayID dpy = data.readInt32();
		int orientation = data.readInt32();
		uint32_t flags = data.readInt32();
		reply->writeInt32( setOrientation(dpy, orientation, flags) );
		} break;
		case FREEZE_DISPLAY: {
		CHECK_INTERFACE(ISurfaceComposer, data, reply);
		DisplayID dpy = data.readInt32();
		uint32_t flags = data.readInt32();
		reply->writeInt32( freezeDisplay(dpy, flags) );
		} break;
		case UNFREEZE_DISPLAY: {
		CHECK_INTERFACE(ISurfaceComposer, data, reply);
		DisplayID dpy = data.readInt32();
		uint32_t flags = data.readInt32();
		reply->writeInt32( unfreezeDisplay(dpy, flags) );
		setTransactionState(state, orientation);
		} break;
		case BOOT_FINISHED: {
		CHECK_INTERFACE(ISurfaceComposer, data, reply);

libs/gui/SurfaceComposerClient.cpp

+25 −14

Original line number	Diff line number	Diff line
		@@ -91,8 +91,10 @@ class Composer : public Singleton<Composer>

		mutable Mutex mLock;
		SortedVector<ComposerState> mStates;
		int mOrientation;

		Composer() : Singleton<Composer>() { }
		Composer() : Singleton<Composer>(),
		mOrientation(ISurfaceComposer::eOrientationUnchanged) { }

		void closeGlobalTransactionImpl();

		@@ -119,6 +121,7 @@ public:
		status_t setFreezeTint(
		const sp<SurfaceComposerClient>& client, SurfaceID id,
		uint32_t tint);
		status_t setOrientation(int orientation);

		static void closeGlobalTransaction() {
		Composer::getInstance().closeGlobalTransactionImpl();
		@@ -133,14 +136,18 @@ void Composer::closeGlobalTransactionImpl() {
		sp<ISurfaceComposer> sm(getComposerService());

		Vector<ComposerState> transaction;
		int orientation;

		{ // scope for the lock
		Mutex::Autolock _l(mLock);
		transaction = mStates;
		mStates.clear();

		orientation = mOrientation;
		mOrientation = ISurfaceComposer::eOrientationUnchanged;
		}

		sm->setTransactionState(transaction);
		sm->setTransactionState(transaction, orientation);
		}

		layer_state_t* Composer::getLayerStateLocked(
		@@ -260,6 +267,12 @@ status_t Composer::setFreezeTint(const sp<SurfaceComposerClient>& client,
		return NO_ERROR;
		}

		status_t Composer::setOrientation(int orientation) {
		Mutex::Autolock _l(mLock);
		mOrientation = orientation;
		return NO_ERROR;
		}

		// ---------------------------------------------------------------------------

		SurfaceComposerClient::SurfaceComposerClient()
		@@ -427,6 +440,12 @@ status_t SurfaceComposerClient::setMatrix(SurfaceID id, float dsdx, float dtdx,
		return getComposer().setMatrix(this, id, dsdx, dtdx, dsdy, dtdy);
		}

		status_t SurfaceComposerClient::setOrientation(DisplayID dpy,
		int orientation, uint32_t flags)
		{
		return Composer::getInstance().setOrientation(orientation);
		}

		// ----------------------------------------------------------------------------

		status_t SurfaceComposerClient::getDisplayInfo(
		@@ -491,21 +510,14 @@ ssize_t SurfaceComposerClient::getNumberOfDisplays()

		status_t SurfaceComposerClient::freezeDisplay(DisplayID dpy, uint32_t flags)
		{
		sp<ISurfaceComposer> sm(getComposerService());
		return sm->freezeDisplay(dpy, flags);
		// This has been made a no-op because it can cause Gralloc buffer deadlocks.
		return NO_ERROR;
		}

		status_t SurfaceComposerClient::unfreezeDisplay(DisplayID dpy, uint32_t flags)
		{
		sp<ISurfaceComposer> sm(getComposerService());
		return sm->unfreezeDisplay(dpy, flags);
		}

		int SurfaceComposerClient::setOrientation(DisplayID dpy,
		int orientation, uint32_t flags)
		{
		sp<ISurfaceComposer> sm(getComposerService());
		return sm->setOrientation(dpy, orientation, flags);
		// This has been made a no-op because it can cause Gralloc buffer deadlocks.
		return NO_ERROR;
		}

		// ----------------------------------------------------------------------------
		@@ -572,4 +584,3 @@ size_t ScreenshotClient::getSize() const {

		// ----------------------------------------------------------------------------
		}; // namespace android

services/java/com/android/server/wm/WindowManagerService.java

+17 −22

Original line number	Diff line number	Diff line
		@@ -5230,20 +5230,19 @@ public class WindowManagerService extends IWindowManager.Stub
		startFreezingDisplayLocked(inTransaction);
		mInputManager.setDisplayOrientation(0, rotation);

		// NOTE: We disable the rotation in the emulator because
		// it doesn't support hardware OpenGL emulation yet.
		if (CUSTOM_SCREEN_ROTATION && mScreenRotationAnimation != null
		&& mScreenRotationAnimation.hasScreenshot()) {
		Surface.freezeDisplay(0);
		if (!inTransaction) {
		if (SHOW_TRANSACTIONS) Slog.i(TAG,
		">>> OPEN TRANSACTION setRotationUnchecked");
		Surface.openTransaction();
		}
		try {
		if (mScreenRotationAnimation != null) {
		// NOTE: We disable the rotation in the emulator because
		// it doesn't support hardware OpenGL emulation yet.
		if (CUSTOM_SCREEN_ROTATION && mScreenRotationAnimation != null
		&& mScreenRotationAnimation.hasScreenshot()) {
		mScreenRotationAnimation.setRotation(rotation);
		}
		Surface.setOrientation(0, rotation);
		} finally {
		if (!inTransaction) {
		Surface.closeTransaction();
		@@ -5251,11 +5250,7 @@ public class WindowManagerService extends IWindowManager.Stub
		"<<< CLOSE TRANSACTION setRotationUnchecked");
		}
		}
		Surface.setOrientation(0, rotation);
		Surface.unfreezeDisplay(0);
		} else {
		Surface.setOrientation(0, rotation);
		}

		rebuildBlackFrame(inTransaction);

		for (int i=mWindows.size()-1; i>=0; i--) {