Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e2909e12 authored by Jamie Gennis's avatar Jamie Gennis
Browse files

SurfaceFlinger: update orientation via transactions 

This change merges the ISurfaceComposer::setOrientation functionality
into ISurfaceComposer::setTransactionState.  It enables the window
manager to atomically update both the display orientation and the
position and size of the windows in a single transaction with
SurfaceFlinger.

Bug: 5439574
Change-Id: I18a8ccc564d7d760ef8afb2d015ccdb7a7963900
parent 99f36683

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--) {