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

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

SurfaceFlinger: make sync transactions explicit

This change enables a layer or orientation update transaction sent to
SurfaceFlinger to explicitly request a synchronous transaction.

Change-Id: I97cbba610c13679849f66114b216fa6dbf12f2a9
parent 5dff2beb
Loading
Loading
Loading
Loading
+6 −2
Original line number Diff line number Diff line
@@ -84,6 +84,10 @@ public:
        eOrientationSwapMask    = 0x01
    };

    enum {
        eSynchronous            = 0x01,
    };

    enum {
        eElectronBeamAnimationOn  = 0x01,
        eElectronBeamAnimationOff = 0x10
@@ -103,7 +107,7 @@ public:

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

    /* signal that we're done booting.
     * Requires ACCESS_SURFACE_FLINGER permission
+1 −1
Original line number Diff line number Diff line
@@ -112,7 +112,7 @@ public:
    static void openGlobalTransaction();
        
    //! Close a composer transaction on all active SurfaceComposerClients.
    static void closeGlobalTransaction();
    static void closeGlobalTransaction(bool synchronous = false);
    
    //! Freeze the specified display but not transactions.
    static status_t freezeDisplay(DisplayID dpy, uint32_t flags = 0);
+4 −2
Original line number Diff line number Diff line
@@ -79,7 +79,7 @@ public:
    }

    virtual void setTransactionState(const Vector<ComposerState>& state,
            int orientation)
            int orientation, uint32_t flags)
    {
        Parcel data, reply;
        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
@@ -90,6 +90,7 @@ public:
            b->write(data);
        }
        data.writeInt32(orientation);
        data.writeInt32(flags);
        remote()->transact(BnSurfaceComposer::SET_TRANSACTION_STATE, data, &reply);
    }

@@ -204,7 +205,8 @@ status_t BnSurfaceComposer::onTransact(
                state.add(s);
            }
            int orientation = data.readInt32();
            setTransactionState(state, orientation);
            uint32_t flags = data.readInt32();
            setTransactionState(state, orientation, flags);
        } break;
        case BOOT_FINISHED: {
            CHECK_INTERFACE(ISurfaceComposer, data, reply);
+25 −8
Original line number Diff line number Diff line
@@ -92,11 +92,14 @@ class Composer : public Singleton<Composer>
    mutable Mutex               mLock;
    SortedVector<ComposerState> mStates;
    int                         mOrientation;
    uint32_t                    mForceSynchronous;

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

    void closeGlobalTransactionImpl();
    void closeGlobalTransactionImpl(bool synchronous);

    layer_state_t* getLayerStateLocked(
            const sp<SurfaceComposerClient>& client, SurfaceID id);
@@ -123,8 +126,8 @@ public:
            uint32_t tint);
    status_t setOrientation(int orientation);

    static void closeGlobalTransaction() {
        Composer::getInstance().closeGlobalTransactionImpl();
    static void closeGlobalTransaction(bool synchronous) {
        Composer::getInstance().closeGlobalTransactionImpl(synchronous);
    }
};

@@ -132,11 +135,12 @@ ANDROID_SINGLETON_STATIC_INSTANCE(Composer);

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

void Composer::closeGlobalTransactionImpl() {
void Composer::closeGlobalTransactionImpl(bool synchronous) {
    sp<ISurfaceComposer> sm(getComposerService());

    Vector<ComposerState> transaction;
    int orientation;
    uint32_t flags = 0;

    { // scope for the lock
        Mutex::Autolock _l(mLock);
@@ -145,9 +149,14 @@ void Composer::closeGlobalTransactionImpl() {

        orientation = mOrientation;
        mOrientation = ISurfaceComposer::eOrientationUnchanged;

        if (synchronous || mForceSynchronous) {
            flags |= ISurfaceComposer::eSynchronous;
        }
        mForceSynchronous = false;
    }

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

layer_state_t* Composer::getLayerStateLocked(
@@ -188,6 +197,10 @@ status_t Composer::setSize(const sp<SurfaceComposerClient>& client,
    s->what |= ISurfaceComposer::eSizeChanged;
    s->w = w;
    s->h = h;

    // Resizing a surface makes the transaction synchronous.
    mForceSynchronous = true;

    return NO_ERROR;
}

@@ -270,6 +283,10 @@ status_t Composer::setFreezeTint(const sp<SurfaceComposerClient>& client,
status_t Composer::setOrientation(int orientation) {
    Mutex::Autolock _l(mLock);
    mOrientation = orientation;

    // Changing the orientation makes the transaction synchronous.
    mForceSynchronous = true;

    return NO_ERROR;
}

@@ -375,8 +392,8 @@ void SurfaceComposerClient::openGlobalTransaction() {
    // Currently a no-op
}

void SurfaceComposerClient::closeGlobalTransaction() {
    Composer::closeGlobalTransaction();
void SurfaceComposerClient::closeGlobalTransaction(bool synchronous) {
    Composer::closeGlobalTransaction(synchronous);
}

// ----------------------------------------------------------------------------
+15 −16
Original line number Diff line number Diff line
@@ -79,7 +79,7 @@ const String16 sDump("android.permission.DUMP");
SurfaceFlinger::SurfaceFlinger()
    :   BnSurfaceComposer(), Thread(false),
        mTransactionFlags(0),
        mResizeTransationPending(false),
        mTransationPending(false),
        mLayersRemoved(false),
        mBootTime(systemTime()),
        mVisibleRegionsDirty(false),
@@ -748,7 +748,7 @@ void SurfaceFlinger::computeVisibleRegions(
void SurfaceFlinger::commitTransaction()
{
    mDrawingState = mCurrentState;
    mResizeTransationPending = false;
    mTransationPending = false;
    mTransactionCV.broadcast();
}

@@ -1235,15 +1235,14 @@ uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags)


void SurfaceFlinger::setTransactionState(const Vector<ComposerState>& state,
        int orientation) {
        int orientation, uint32_t flags) {
    Mutex::Autolock _l(mStateLock);

    uint32_t flags = 0;
    uint32_t transactionFlags = 0;
    if (mCurrentState.orientation != orientation) {
        if (uint32_t(orientation)<=eOrientation270 || orientation==42) {
            mCurrentState.orientation = orientation;
            flags |= eTransactionNeeded;
            mResizeTransationPending = true;
            transactionFlags |= eTransactionNeeded;
        } else if (orientation != eOrientationUnchanged) {
            LOGW("setTransactionState: ignoring unrecognized orientation: %d",
                    orientation);
@@ -1254,23 +1253,24 @@ void SurfaceFlinger::setTransactionState(const Vector<ComposerState>& state,
    for (size_t i=0 ; i<count ; i++) {
        const ComposerState& s(state[i]);
        sp<Client> client( static_cast<Client *>(s.client.get()) );
        flags |= setClientStateLocked(client, s.state);
        transactionFlags |= setClientStateLocked(client, s.state);
    }
    if (flags) {
        setTransactionFlags(flags);
    if (transactionFlags) {
        setTransactionFlags(transactionFlags);
    }

    signalEvent();

    // if there is a transaction with a resize, wait for it to
    // take effect before returning.
    while (mResizeTransationPending) {
    // if this is a synchronous transaction, wait for it to take effect before
    // returning.
    if (flags & eSynchronous) {
        mTransationPending = true;
    }
    while (mTransationPending) {
        status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
        if (CC_UNLIKELY(err != NO_ERROR)) {
            // just in case something goes wrong in SF, return to the
            // called after a few seconds.
            LOGW_IF(err == TIMED_OUT, "closeGlobalTransaction timed out!");
            mResizeTransationPending = false;
            mTransationPending = false;
            break;
        }
    }
@@ -1489,7 +1489,6 @@ uint32_t SurfaceFlinger::setClientStateLocked(
        if (what & eSizeChanged) {
            if (layer->setSize(s.w, s.h)) {
                flags |= eTraversalNeeded;
                mResizeTransationPending = true;
            }
        }
        if (what & eAlphaChanged) {
Loading