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

Commit 4cdc58f6 authored by Robert Carr's avatar Robert Carr
Browse files

SurfaceFlinger Transactions as distinct objects. 

Essentially a process global singleton for transactions is not so useful once
we make surface control public API as process isn't something an app developer
is really thinking about. It's also nice that we get to delete two of the plumbing layers.

Test: Boots
Change-Id: I8864bd7e2f5865e3c0a425cf82f9928211911774
parent 049c1147

cmds/flatland/GLHelper.cpp

+4 −18
Original line number Original line Diff line number Diff line
@@ -269,24 +269,10 @@ bool GLHelper::createWindowSurface(uint32_t w, uint32_t h, 
        return false;

        return false;

    }

    }





    SurfaceComposerClient::openGlobalTransaction();

    SurfaceComposerClient::Transaction{}.setLayer(sc, 0x7FFFFFFF)

    err = sc->setLayer(0x7FFFFFFF);

            .setMatrix(sc, scale, 0.0f, 0.0f, scale)

    if (err != NO_ERROR) {

            .show(sc)

        fprintf(stderr, "SurfaceComposer::setLayer error: %#x\n", err);

            .apply();

        return false;

    }

    err = sc->setMatrix(scale, 0.0f, 0.0f, scale);

    if (err != NO_ERROR) {

        fprintf(stderr, "SurfaceComposer::setMatrix error: %#x\n", err);

        return false;

    }



    err = sc->show();

    if (err != NO_ERROR) {

        fprintf(stderr, "SurfaceComposer::show error: %#x\n", err);

        return false;

    }

    SurfaceComposerClient::closeGlobalTransaction();





    sp<ANativeWindow> anw = sc->getSurface();

    sp<ANativeWindow> anw = sc->getSurface();

    EGLSurface s = eglCreateWindowSurface(mDisplay, mConfig, anw.get(), NULL);

    EGLSurface s = eglCreateWindowSurface(mDisplay, mConfig, anw.get(), NULL);

cmds/surfacereplayer/replayer/Replayer.cpp

+89 −65
Original line number Original line Diff line number Diff line
@@ -24,9 +24,9 @@ 




#include <gui/BufferQueue.h>

#include <gui/BufferQueue.h>

#include <gui/ISurfaceComposer.h>

#include <gui/ISurfaceComposer.h>

#include <gui/LayerState.h>

#include <gui/Surface.h>

#include <gui/Surface.h>

#include <private/gui/ComposerService.h>

#include <private/gui/ComposerService.h>

#include <private/gui/LayerState.h>





#include <ui/DisplayInfo.h>

#include <ui/DisplayInfo.h>

#include <utils/Log.h>

#include <utils/Log.h>
@@ -338,27 +338,29 @@ status_t Replayer::dispatchEvent(int index) { 
status_t Replayer::doTransaction(const Transaction& t, const std::shared_ptr<Event>& event) {

status_t Replayer::doTransaction(const Transaction& t, const std::shared_ptr<Event>& event) {

    ALOGV("Started Transaction");

    ALOGV("Started Transaction");





    SurfaceComposerClient::openGlobalTransaction();

    SurfaceComposerClient::Transaction liveTransaction;





    status_t status = NO_ERROR;

    status_t status = NO_ERROR;





    status = doSurfaceTransaction(t.surface_change());

    status = doSurfaceTransaction(liveTransaction, t.surface_change());

    doDisplayTransaction(t.display_change());

    doDisplayTransaction(liveTransaction, t.display_change());





    if (t.animation()) {

    if (t.animation()) {

        SurfaceComposerClient::setAnimationTransaction();

        liveTransaction.setAnimationTransaction();

    }

    }





    event->readyToExecute();

    event->readyToExecute();





    SurfaceComposerClient::closeGlobalTransaction(t.synchronous());

    liveTransaction.apply(t.synchronous());





    ALOGV("Ended Transaction");

    ALOGV("Ended Transaction");





    return status;

    return status;

}

}





status_t Replayer::doSurfaceTransaction(const SurfaceChanges& surfaceChanges) {

status_t Replayer::doSurfaceTransaction(

        SurfaceComposerClient::Transaction& transaction,

        const SurfaceChanges& surfaceChanges) {

    status_t status = NO_ERROR;

    status_t status = NO_ERROR;





    for (const SurfaceChange& change : surfaceChanges) {

    for (const SurfaceChange& change : surfaceChanges) {
@@ -369,62 +371,66 @@ status_t Replayer::doSurfaceTransaction(const SurfaceChanges& surfaceChanges) { 




        switch (change.SurfaceChange_case()) {

        switch (change.SurfaceChange_case()) {

            case SurfaceChange::SurfaceChangeCase::kPosition:

            case SurfaceChange::SurfaceChangeCase::kPosition:

                status = setPosition(change.id(), change.position());

                setPosition(transaction, change.id(), change.position());

                break;

                break;

            case SurfaceChange::SurfaceChangeCase::kSize:

            case SurfaceChange::SurfaceChangeCase::kSize:

                status = setSize(change.id(), change.size());

                setSize(transaction, change.id(), change.size());

                break;

                break;

            case SurfaceChange::SurfaceChangeCase::kAlpha:

            case SurfaceChange::SurfaceChangeCase::kAlpha:

                status = setAlpha(change.id(), change.alpha());

                setAlpha(transaction, change.id(), change.alpha());

                break;

                break;

            case SurfaceChange::SurfaceChangeCase::kLayer:

            case SurfaceChange::SurfaceChangeCase::kLayer:

                status = setLayer(change.id(), change.layer());

                setLayer(transaction, change.id(), change.layer());

                break;

                break;

            case SurfaceChange::SurfaceChangeCase::kCrop:

            case SurfaceChange::SurfaceChangeCase::kCrop:

                status = setCrop(change.id(), change.crop());

                setCrop(transaction, change.id(), change.crop());

                break;

                break;

            case SurfaceChange::SurfaceChangeCase::kMatrix:

            case SurfaceChange::SurfaceChangeCase::kMatrix:

                status = setMatrix(change.id(), change.matrix());

                setMatrix(transaction, change.id(), change.matrix());

                break;

                break;

            case SurfaceChange::SurfaceChangeCase::kFinalCrop:

            case SurfaceChange::SurfaceChangeCase::kFinalCrop:

                status = setFinalCrop(change.id(), change.final_crop());

                setFinalCrop(transaction, change.id(), change.final_crop());

                break;

                break;

            case SurfaceChange::SurfaceChangeCase::kOverrideScalingMode:

            case SurfaceChange::SurfaceChangeCase::kOverrideScalingMode:

                status = setOverrideScalingMode(change.id(), change.override_scaling_mode());

                setOverrideScalingMode(transaction, change.id(),

                        change.override_scaling_mode());

                break;

                break;

            case SurfaceChange::SurfaceChangeCase::kTransparentRegionHint:

            case SurfaceChange::SurfaceChangeCase::kTransparentRegionHint:

                status = setTransparentRegionHint(change.id(), change.transparent_region_hint());

                setTransparentRegionHint(transaction, change.id(),

                        change.transparent_region_hint());

                break;

                break;

            case SurfaceChange::SurfaceChangeCase::kLayerStack:

            case SurfaceChange::SurfaceChangeCase::kLayerStack:

                status = setLayerStack(change.id(), change.layer_stack());

                setLayerStack(transaction, change.id(), change.layer_stack());

                break;

                break;

            case SurfaceChange::SurfaceChangeCase::kHiddenFlag:

            case SurfaceChange::SurfaceChangeCase::kHiddenFlag:

                status = setHiddenFlag(change.id(), change.hidden_flag());

                setHiddenFlag(transaction, change.id(), change.hidden_flag());

                break;

                break;

            case SurfaceChange::SurfaceChangeCase::kOpaqueFlag:

            case SurfaceChange::SurfaceChangeCase::kOpaqueFlag:

                status = setOpaqueFlag(change.id(), change.opaque_flag());

                setOpaqueFlag(transaction, change.id(), change.opaque_flag());

                break;

                break;

            case SurfaceChange::SurfaceChangeCase::kSecureFlag:

            case SurfaceChange::SurfaceChangeCase::kSecureFlag:

                status = setSecureFlag(change.id(), change.secure_flag());

                setSecureFlag(transaction, change.id(), change.secure_flag());

                break;

                break;

            case SurfaceChange::SurfaceChangeCase::kDeferredTransaction:

            case SurfaceChange::SurfaceChangeCase::kDeferredTransaction:

                waitUntilDeferredTransactionLayerExists(change.deferred_transaction(), lock);

                waitUntilDeferredTransactionLayerExists(change.deferred_transaction(), lock);

                status = setDeferredTransaction(change.id(), change.deferred_transaction());

                setDeferredTransaction(transaction, change.id(),

                        change.deferred_transaction());

                break;

                break;

            default:

            default:

                status = NO_ERROR;

                status = 1;

                break;

                break;

        }

        }





        if (status != NO_ERROR) {

        if (status != NO_ERROR) {

            ALOGE("SET TRANSACTION FAILED");

            ALOGE("Unknown Transaction Code");

            return status;

            return status;

        }

        }

    }

    }

    return status;

    return status;

}

}





void Replayer::doDisplayTransaction(const DisplayChanges& displayChanges) {

void Replayer::doDisplayTransaction(SurfaceComposerClient::Transaction& t,

        const DisplayChanges& displayChanges) {

    for (const DisplayChange& change : displayChanges) {

    for (const DisplayChange& change : displayChanges) {

        ALOGV("Doing display transaction");

        ALOGV("Doing display transaction");

        std::unique_lock<std::mutex> lock(mDisplayLock);

        std::unique_lock<std::mutex> lock(mDisplayLock);
@@ -434,16 +440,16 @@ void Replayer::doDisplayTransaction(const DisplayChanges& displayChanges) { 




        switch (change.DisplayChange_case()) {

        switch (change.DisplayChange_case()) {

            case DisplayChange::DisplayChangeCase::kSurface:

            case DisplayChange::DisplayChangeCase::kSurface:

                setDisplaySurface(change.id(), change.surface());

                setDisplaySurface(t, change.id(), change.surface());

                break;

                break;

            case DisplayChange::DisplayChangeCase::kLayerStack:

            case DisplayChange::DisplayChangeCase::kLayerStack:

                setDisplayLayerStack(change.id(), change.layer_stack());

                setDisplayLayerStack(t, change.id(), change.layer_stack());

                break;

                break;

            case DisplayChange::DisplayChangeCase::kSize:

            case DisplayChange::DisplayChangeCase::kSize:

                setDisplaySize(change.id(), change.size());

                setDisplaySize(t, change.id(), change.size());

                break;

                break;

            case DisplayChange::DisplayChangeCase::kProjection:

            case DisplayChange::DisplayChangeCase::kProjection:

                setDisplayProjection(change.id(), change.projection());

                setDisplayProjection(t, change.id(), change.projection());

                break;

                break;

            default:

            default:

                break;

                break;
@@ -451,57 +457,66 @@ void Replayer::doDisplayTransaction(const DisplayChanges& displayChanges) { 
    }

    }

}

}





status_t Replayer::setPosition(layer_id id, const PositionChange& pc) {

void Replayer::setPosition(SurfaceComposerClient::Transaction& t,

        layer_id id, const PositionChange& pc) {

    ALOGV("Layer %d: Setting Position -- x=%f, y=%f", id, pc.x(), pc.y());

    ALOGV("Layer %d: Setting Position -- x=%f, y=%f", id, pc.x(), pc.y());

    return mLayers[id]->setPosition(pc.x(), pc.y());

    t.setPosition(mLayers[id], pc.x(), pc.y());

}

}





status_t Replayer::setSize(layer_id id, const SizeChange& sc) {

void Replayer::setSize(SurfaceComposerClient::Transaction& t,

        layer_id id, const SizeChange& sc) {

    ALOGV("Layer %d: Setting Size -- w=%u, h=%u", id, sc.w(), sc.h());

    ALOGV("Layer %d: Setting Size -- w=%u, h=%u", id, sc.w(), sc.h());

    return mLayers[id]->setSize(sc.w(), sc.h());

    t.setSize(mLayers[id], sc.w(), sc.h());

}

}





status_t Replayer::setLayer(layer_id id, const LayerChange& lc) {

void Replayer::setLayer(SurfaceComposerClient::Transaction& t,

        layer_id id, const LayerChange& lc) {

    ALOGV("Layer %d: Setting Layer -- layer=%d", id, lc.layer());

    ALOGV("Layer %d: Setting Layer -- layer=%d", id, lc.layer());

    return mLayers[id]->setLayer(lc.layer());

    t.setLayer(mLayers[id], lc.layer());

}

}





status_t Replayer::setAlpha(layer_id id, const AlphaChange& ac) {

void Replayer::setAlpha(SurfaceComposerClient::Transaction& t,

        layer_id id, const AlphaChange& ac) {

    ALOGV("Layer %d: Setting Alpha -- alpha=%f", id, ac.alpha());

    ALOGV("Layer %d: Setting Alpha -- alpha=%f", id, ac.alpha());

    return mLayers[id]->setAlpha(ac.alpha());

    t.setAlpha(mLayers[id], ac.alpha());

}

}





status_t Replayer::setCrop(layer_id id, const CropChange& cc) {

void Replayer::setCrop(SurfaceComposerClient::Transaction& t,

        layer_id id, const CropChange& cc) {

    ALOGV("Layer %d: Setting Crop -- left=%d, top=%d, right=%d, bottom=%d", id,

    ALOGV("Layer %d: Setting Crop -- left=%d, top=%d, right=%d, bottom=%d", id,

            cc.rectangle().left(), cc.rectangle().top(), cc.rectangle().right(),

            cc.rectangle().left(), cc.rectangle().top(), cc.rectangle().right(),

            cc.rectangle().bottom());

            cc.rectangle().bottom());





    Rect r = Rect(cc.rectangle().left(), cc.rectangle().top(), cc.rectangle().right(),

    Rect r = Rect(cc.rectangle().left(), cc.rectangle().top(), cc.rectangle().right(),

            cc.rectangle().bottom());

            cc.rectangle().bottom());

    return mLayers[id]->setCrop(r);

    t.setCrop(mLayers[id], r);

}

}





status_t Replayer::setFinalCrop(layer_id id, const FinalCropChange& fcc) {

void Replayer::setFinalCrop(SurfaceComposerClient::Transaction& t,

        layer_id id, const FinalCropChange& fcc) {

    ALOGV("Layer %d: Setting Final Crop -- left=%d, top=%d, right=%d, bottom=%d", id,

    ALOGV("Layer %d: Setting Final Crop -- left=%d, top=%d, right=%d, bottom=%d", id,

            fcc.rectangle().left(), fcc.rectangle().top(), fcc.rectangle().right(),

            fcc.rectangle().left(), fcc.rectangle().top(), fcc.rectangle().right(),

            fcc.rectangle().bottom());

            fcc.rectangle().bottom());

    Rect r = Rect(fcc.rectangle().left(), fcc.rectangle().top(), fcc.rectangle().right(),

    Rect r = Rect(fcc.rectangle().left(), fcc.rectangle().top(), fcc.rectangle().right(),

            fcc.rectangle().bottom());

            fcc.rectangle().bottom());

    return mLayers[id]->setFinalCrop(r);

    t.setFinalCrop(mLayers[id], r);

}

}





status_t Replayer::setMatrix(layer_id id, const MatrixChange& mc) {

void Replayer::setMatrix(SurfaceComposerClient::Transaction& t,

        layer_id id, const MatrixChange& mc) {

    ALOGV("Layer %d: Setting Matrix -- dsdx=%f, dtdx=%f, dsdy=%f, dtdy=%f", id, mc.dsdx(),

    ALOGV("Layer %d: Setting Matrix -- dsdx=%f, dtdx=%f, dsdy=%f, dtdy=%f", id, mc.dsdx(),

            mc.dtdx(), mc.dsdy(), mc.dtdy());

            mc.dtdx(), mc.dsdy(), mc.dtdy());

    return mLayers[id]->setMatrix(mc.dsdx(), mc.dtdx(), mc.dsdy(), mc.dtdy());

    t.setMatrix(mLayers[id], mc.dsdx(), mc.dtdx(), mc.dsdy(), mc.dtdy());

}

}





status_t Replayer::setOverrideScalingMode(layer_id id, const OverrideScalingModeChange& osmc) {

void Replayer::setOverrideScalingMode(SurfaceComposerClient::Transaction& t,

        layer_id id, const OverrideScalingModeChange& osmc) {

    ALOGV("Layer %d: Setting Override Scaling Mode -- mode=%d", id, osmc.override_scaling_mode());

    ALOGV("Layer %d: Setting Override Scaling Mode -- mode=%d", id, osmc.override_scaling_mode());

    return mLayers[id]->setOverrideScalingMode(osmc.override_scaling_mode());

    t.setOverrideScalingMode(mLayers[id], osmc.override_scaling_mode());

}

}





status_t Replayer::setTransparentRegionHint(layer_id id, const TransparentRegionHintChange& trhc) {

void Replayer::setTransparentRegionHint(SurfaceComposerClient::Transaction& t,

        layer_id id, const TransparentRegionHintChange& trhc) {

    ALOGV("Setting Transparent Region Hint");

    ALOGV("Setting Transparent Region Hint");

    Region re = Region();

    Region re = Region();
@@ -510,71 +525,80 @@ status_t Replayer::setTransparentRegionHint(layer_id id, const TransparentRegion 
        re.merge(rect);

        re.merge(rect);

    }

    }





    return mLayers[id]->setTransparentRegionHint(re);

    t.setTransparentRegionHint(mLayers[id], re);

}

}





status_t Replayer::setLayerStack(layer_id id, const LayerStackChange& lsc) {

void Replayer::setLayerStack(SurfaceComposerClient::Transaction& t,

        layer_id id, const LayerStackChange& lsc) {

    ALOGV("Layer %d: Setting LayerStack -- layer_stack=%d", id, lsc.layer_stack());

    ALOGV("Layer %d: Setting LayerStack -- layer_stack=%d", id, lsc.layer_stack());

    return mLayers[id]->setLayerStack(lsc.layer_stack());

    t.setLayerStack(mLayers[id], lsc.layer_stack());

}

}





status_t Replayer::setHiddenFlag(layer_id id, const HiddenFlagChange& hfc) {

void Replayer::setHiddenFlag(SurfaceComposerClient::Transaction& t,

        layer_id id, const HiddenFlagChange& hfc) {

    ALOGV("Layer %d: Setting Hidden Flag -- hidden_flag=%d", id, hfc.hidden_flag());

    ALOGV("Layer %d: Setting Hidden Flag -- hidden_flag=%d", id, hfc.hidden_flag());

    layer_id flag = hfc.hidden_flag() ? layer_state_t::eLayerHidden : 0;

    layer_id flag = hfc.hidden_flag() ? layer_state_t::eLayerHidden : 0;





    return mLayers[id]->setFlags(flag, layer_state_t::eLayerHidden);

    t.setFlags(mLayers[id], flag, layer_state_t::eLayerHidden);

}

}





status_t Replayer::setOpaqueFlag(layer_id id, const OpaqueFlagChange& ofc) {

void Replayer::setOpaqueFlag(SurfaceComposerClient::Transaction& t,

        layer_id id, const OpaqueFlagChange& ofc) {

    ALOGV("Layer %d: Setting Opaque Flag -- opaque_flag=%d", id, ofc.opaque_flag());

    ALOGV("Layer %d: Setting Opaque Flag -- opaque_flag=%d", id, ofc.opaque_flag());

    layer_id flag = ofc.opaque_flag() ? layer_state_t::eLayerOpaque : 0;

    layer_id flag = ofc.opaque_flag() ? layer_state_t::eLayerOpaque : 0;





    return mLayers[id]->setFlags(flag, layer_state_t::eLayerOpaque);

    t.setFlags(mLayers[id], flag, layer_state_t::eLayerOpaque);

}

}





status_t Replayer::setSecureFlag(layer_id id, const SecureFlagChange& sfc) {

void Replayer::setSecureFlag(SurfaceComposerClient::Transaction& t,

        layer_id id, const SecureFlagChange& sfc) {

    ALOGV("Layer %d: Setting Secure Flag -- secure_flag=%d", id, sfc.secure_flag());

    ALOGV("Layer %d: Setting Secure Flag -- secure_flag=%d", id, sfc.secure_flag());

    layer_id flag = sfc.secure_flag() ? layer_state_t::eLayerSecure : 0;

    layer_id flag = sfc.secure_flag() ? layer_state_t::eLayerSecure : 0;





    return mLayers[id]->setFlags(flag, layer_state_t::eLayerSecure);

    t.setFlags(mLayers[id], flag, layer_state_t::eLayerSecure);

}

}





status_t Replayer::setDeferredTransaction(layer_id id, const DeferredTransactionChange& dtc) {

void Replayer::setDeferredTransaction(SurfaceComposerClient::Transaction& t,

        layer_id id, const DeferredTransactionChange& dtc) {

    ALOGV("Layer %d: Setting Deferred Transaction -- layer_id=%d, "

    ALOGV("Layer %d: Setting Deferred Transaction -- layer_id=%d, "

          "frame_number=%llu",

          "frame_number=%llu",

            id, dtc.layer_id(), dtc.frame_number());

            id, dtc.layer_id(), dtc.frame_number());

    if (mLayers.count(dtc.layer_id()) == 0 || mLayers[dtc.layer_id()] == nullptr) {

    if (mLayers.count(dtc.layer_id()) == 0 || mLayers[dtc.layer_id()] == nullptr) {

        ALOGE("Layer %d not found in Deferred Transaction", dtc.layer_id());

        ALOGE("Layer %d not found in Deferred Transaction", dtc.layer_id());

        return BAD_VALUE;

        return;

    }

    }





    auto handle = mLayers[dtc.layer_id()]->getHandle();

    auto handle = mLayers[dtc.layer_id()]->getHandle();





    return mLayers[id]->deferTransactionUntil(handle, dtc.frame_number());

    t.deferTransactionUntil(mLayers[id], handle, dtc.frame_number());

}

}





void Replayer::setDisplaySurface(display_id id, const DispSurfaceChange& /*dsc*/) {

void Replayer::setDisplaySurface(SurfaceComposerClient::Transaction& t,

        display_id id, const DispSurfaceChange& /*dsc*/) {

    sp<IGraphicBufferProducer> outProducer;

    sp<IGraphicBufferProducer> outProducer;

    sp<IGraphicBufferConsumer> outConsumer;

    sp<IGraphicBufferConsumer> outConsumer;

    BufferQueue::createBufferQueue(&outProducer, &outConsumer);

    BufferQueue::createBufferQueue(&outProducer, &outConsumer);





    SurfaceComposerClient::setDisplaySurface(mDisplays[id], outProducer);

    t.setDisplaySurface(mDisplays[id], outProducer);

}

}





void Replayer::setDisplayLayerStack(display_id id, const LayerStackChange& lsc) {

void Replayer::setDisplayLayerStack(SurfaceComposerClient::Transaction& t,

    SurfaceComposerClient::setDisplayLayerStack(mDisplays[id], lsc.layer_stack());

        display_id id, const LayerStackChange& lsc) {

    t.setDisplayLayerStack(mDisplays[id], lsc.layer_stack());

}

}





void Replayer::setDisplaySize(display_id id, const SizeChange& sc) {

void Replayer::setDisplaySize(SurfaceComposerClient::Transaction& t,

    SurfaceComposerClient::setDisplaySize(mDisplays[id], sc.w(), sc.h());

        display_id id, const SizeChange& sc) {

    t.setDisplaySize(mDisplays[id], sc.w(), sc.h());

}

}





void Replayer::setDisplayProjection(display_id id, const ProjectionChange& pc) {

void Replayer::setDisplayProjection(SurfaceComposerClient::Transaction& t,

        display_id id, const ProjectionChange& pc) {

    Rect viewport = Rect(pc.viewport().left(), pc.viewport().top(), pc.viewport().right(),

    Rect viewport = Rect(pc.viewport().left(), pc.viewport().top(), pc.viewport().right(),

            pc.viewport().bottom());

            pc.viewport().bottom());

    Rect frame = Rect(pc.frame().left(), pc.frame().top(), pc.frame().right(), pc.frame().bottom());

    Rect frame = Rect(pc.frame().left(), pc.frame().top(), pc.frame().right(), pc.frame().bottom());





    SurfaceComposerClient::setDisplayProjection(mDisplays[id], pc.orientation(), viewport, frame);

    t.setDisplayProjection(mDisplays[id], pc.orientation(), viewport, frame);

}

}





status_t Replayer::createSurfaceControl(

status_t Replayer::createSurfaceControl(

cmds/surfacereplayer/replayer/Replayer.h

+42 −22
Original line number Original line Diff line number Diff line
@@ -77,28 +77,48 @@ class Replayer { 
    void deleteDisplay(const DisplayDeletion& delete_, const std::shared_ptr<Event>& event);

    void deleteDisplay(const DisplayDeletion& delete_, const std::shared_ptr<Event>& event);

    void updatePowerMode(const PowerModeUpdate& update, const std::shared_ptr<Event>& event);

    void updatePowerMode(const PowerModeUpdate& update, const std::shared_ptr<Event>& event);





    status_t doSurfaceTransaction(const SurfaceChanges& surfaceChange);

    status_t doSurfaceTransaction(SurfaceComposerClient::Transaction& transaction,

    void doDisplayTransaction(const DisplayChanges& displayChange);

            const SurfaceChanges& surfaceChange);



    void doDisplayTransaction(SurfaceComposerClient::Transaction& transaction,

    status_t setPosition(layer_id id, const PositionChange& pc);

            const DisplayChanges& displayChange);

    status_t setSize(layer_id id, const SizeChange& sc);



    status_t setAlpha(layer_id id, const AlphaChange& ac);

    void setPosition(SurfaceComposerClient::Transaction& t,

    status_t setLayer(layer_id id, const LayerChange& lc);

            layer_id id, const PositionChange& pc);

    status_t setCrop(layer_id id, const CropChange& cc);

    void setSize(SurfaceComposerClient::Transaction& t,

    status_t setFinalCrop(layer_id id, const FinalCropChange& fcc);

            layer_id id, const SizeChange& sc);

    status_t setMatrix(layer_id id, const MatrixChange& mc);

    void setAlpha(SurfaceComposerClient::Transaction& t,

    status_t setOverrideScalingMode(layer_id id, const OverrideScalingModeChange& osmc);

            layer_id id, const AlphaChange& ac);

    status_t setTransparentRegionHint(layer_id id, const TransparentRegionHintChange& trgc);

    void setLayer(SurfaceComposerClient::Transaction& t,

    status_t setLayerStack(layer_id id, const LayerStackChange& lsc);

            layer_id id, const LayerChange& lc);

    status_t setHiddenFlag(layer_id id, const HiddenFlagChange& hfc);

    void setCrop(SurfaceComposerClient::Transaction& t,

    status_t setOpaqueFlag(layer_id id, const OpaqueFlagChange& ofc);

            layer_id id, const CropChange& cc);

    status_t setSecureFlag(layer_id id, const SecureFlagChange& sfc);

    void setFinalCrop(SurfaceComposerClient::Transaction& t,

    status_t setDeferredTransaction(layer_id id, const DeferredTransactionChange& dtc);

            layer_id id, const FinalCropChange& fcc);



    void setMatrix(SurfaceComposerClient::Transaction& t,

    void setDisplaySurface(display_id id, const DispSurfaceChange& dsc);

            layer_id id, const MatrixChange& mc);

    void setDisplayLayerStack(display_id id, const LayerStackChange& lsc);

    void setOverrideScalingMode(SurfaceComposerClient::Transaction& t,

    void setDisplaySize(display_id id, const SizeChange& sc);

            layer_id id, const OverrideScalingModeChange& osmc);

    void setDisplayProjection(display_id id, const ProjectionChange& pc);

    void setTransparentRegionHint(SurfaceComposerClient::Transaction& t,

            layer_id id, const TransparentRegionHintChange& trgc);

    void setLayerStack(SurfaceComposerClient::Transaction& t,

            layer_id id, const LayerStackChange& lsc);

    void setHiddenFlag(SurfaceComposerClient::Transaction& t,

            layer_id id, const HiddenFlagChange& hfc);

    void setOpaqueFlag(SurfaceComposerClient::Transaction& t,

            layer_id id, const OpaqueFlagChange& ofc);

    void setSecureFlag(SurfaceComposerClient::Transaction& t,

            layer_id id, const SecureFlagChange& sfc);

    void setDeferredTransaction(SurfaceComposerClient::Transaction& t,

            layer_id id, const DeferredTransactionChange& dtc);



    void setDisplaySurface(SurfaceComposerClient::Transaction& t,

            display_id id, const DispSurfaceChange& dsc);

    void setDisplayLayerStack(SurfaceComposerClient::Transaction& t,

            display_id id, const LayerStackChange& lsc);

    void setDisplaySize(SurfaceComposerClient::Transaction& t,

            display_id id, const SizeChange& sc);

    void setDisplayProjection(SurfaceComposerClient::Transaction& t,

            display_id id, const ProjectionChange& pc);





    void doDeleteSurfaceControls();

    void doDeleteSurfaceControls();

    void waitUntilTimestamp(int64_t timestamp);

    void waitUntilTimestamp(int64_t timestamp);

libs/gui/ISurfaceComposer.cpp

+1 −2
Original line number Original line Diff line number Diff line
@@ -29,8 +29,7 @@ 
#include <gui/ISurfaceComposer.h>

#include <gui/ISurfaceComposer.h>

#include <gui/ISurfaceComposerClient.h>

#include <gui/ISurfaceComposerClient.h>

#include <gui/LayerDebugInfo.h>

#include <gui/LayerDebugInfo.h>



#include <gui/LayerState.h>

#include <private/gui/LayerState.h>





#include <system/graphics.h>

#include <system/graphics.h>

libs/gui/LayerState.cpp

+1 −1
Original line number Original line Diff line number Diff line
@@ -18,7 +18,7 @@ 
#include <binder/Parcel.h>

#include <binder/Parcel.h>

#include <gui/ISurfaceComposerClient.h>

#include <gui/ISurfaceComposerClient.h>

#include <gui/IGraphicBufferProducer.h>

#include <gui/IGraphicBufferProducer.h>

#include <private/gui/LayerState.h>

#include <gui/LayerState.h>





namespace android {

namespace android {