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

Commit 456bbb2a authored by Vishnu Nair's avatar Vishnu Nair
Browse files

Add more layer state changes to SurfaceInterceptor 

Track flag set and clear state changes.
Track reparenting, detach children and relative z changes.

Test: run surface interceptor and view results
Test: atest SurfaceFlinger_test:SurfaceInterceptorTest#*
Change-Id: I0c55e6d45034e180a3c8970c60af21bf8f2bb01c
parent ea7b7ec2

cmds/surfacereplayer/proto/src/trace.proto

+21 −0
Original line number Diff line number Diff line
@@ -46,6 +46,10 @@ message SurfaceChange { 
        SecureFlagChange            secure_flag             = 14;

        DeferredTransactionChange   deferred_transaction    = 15;

        CornerRadiusChange          corner_radius           = 16;

        ReparentChange              reparent                = 17;

        RelativeParentChange        relative_parent         = 18;

        DetachChildrenChange        detach_children         = 19;

        ReparentChildrenChange      reparent_children       = 20;

    }

}
@@ -177,3 +181,20 @@ message PowerModeUpdate { 
    required int32  id   = 1;

    required int32  mode = 2;

}



message ReparentChange {

    required int32 parent_id = 1;

}



message ReparentChildrenChange {

    required int32 parent_id = 1;

}



message RelativeParentChange {

    required int32 relative_parent_id = 1;

    required int32 z = 2;

}



message DetachChildrenChange {

    required bool detach_children = 1;

}

cmds/surfacereplayer/replayer/Replayer.cpp

+44 −0
Original line number Diff line number Diff line
@@ -412,6 +412,18 @@ status_t Replayer::doSurfaceTransaction( 
                setDeferredTransaction(transaction, change.id(),

                        change.deferred_transaction());

                break;

            case SurfaceChange::SurfaceChangeCase::kReparent:

                setReparentChange(transaction, change.id(), change.reparent());

                break;

            case SurfaceChange::SurfaceChangeCase::kReparentChildren:

                setReparentChildrenChange(transaction, change.id(), change.reparent_children());

                break;

            case SurfaceChange::SurfaceChangeCase::kRelativeParent:

                setRelativeParentChange(transaction, change.id(), change.relative_parent());

                break;

            case SurfaceChange::SurfaceChangeCase::kDetachChildren:

                setDetachChildrenChange(transaction, change.id(), change.detach_children());

                break;

            default:

                status = 1;

                break;
@@ -680,3 +692,35 @@ status_t Replayer::loadSurfaceComposerClient() { 
    mComposerClient = new SurfaceComposerClient;

    return mComposerClient->initCheck();

}



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

        layer_id id, const ReparentChange& c) {

    sp<IBinder> newParentHandle = nullptr;

    if (mLayers.count(c.parent_id()) != 0 && mLayers[c.parent_id()] != nullptr) {

        newParentHandle = mLayers[c.parent_id()]->getHandle();

    }

    t.reparent(mLayers[id], newParentHandle);

}



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

        layer_id id, const RelativeParentChange& c) {

    if (mLayers.count(c.relative_parent_id()) == 0 || mLayers[c.relative_parent_id()] == nullptr) {

        ALOGE("Layer %d not found in set relative parent transaction", c.relative_parent_id());

        return;

    }

    t.setRelativeLayer(mLayers[id], mLayers[c.relative_parent_id()]->getHandle(), c.z());

}



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

        layer_id id, const DetachChildrenChange& c) {

    t.detachChildren(mLayers[id]);

}



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

        layer_id id, const ReparentChildrenChange& c) {

    if (mLayers.count(c.parent_id()) == 0 || mLayers[c.parent_id()] == nullptr) {

        ALOGE("Layer %d not found in reparent children transaction", c.parent_id());

        return;

    }

    t.reparentChildren(mLayers[id], mLayers[c.parent_id()]->getHandle());

}

cmds/surfacereplayer/replayer/Replayer.h

+8 −0
Original line number Diff line number Diff line
@@ -108,6 +108,14 @@ class Replayer { 
            layer_id id, const SecureFlagChange& sfc);

    void setDeferredTransaction(SurfaceComposerClient::Transaction& t,

            layer_id id, const DeferredTransactionChange& dtc);

    void setReparentChange(SurfaceComposerClient::Transaction& t,

            layer_id id, const ReparentChange& c);

    void setRelativeParentChange(SurfaceComposerClient::Transaction& t,

            layer_id id, const RelativeParentChange& c);

    void setDetachChildrenChange(SurfaceComposerClient::Transaction& t,

            layer_id id, const DetachChildrenChange& c);

    void setReparentChildrenChange(SurfaceComposerClient::Transaction& t,

            layer_id id, const ReparentChildrenChange& c);



    void setDisplaySurface(SurfaceComposerClient::Transaction& t,

            display_id id, const DispSurfaceChange& dsc);

services/surfaceflinger/SurfaceInterceptor.cpp

+79 −14
Original line number Diff line number Diff line
@@ -116,7 +116,14 @@ void SurfaceInterceptor::addInitialSurfaceStateLocked(Increment* increment, 
                                  layer->mCurrentState.frameNumber_legacy);

    }

    addOverrideScalingModeLocked(transaction, layerId, layer->getEffectiveScalingMode());

    addFlagsLocked(transaction, layerId, layer->mCurrentState.flags);

    addFlagsLocked(transaction, layerId, layer->mCurrentState.flags,

                   layer_state_t::eLayerHidden | layer_state_t::eLayerOpaque |

                           layer_state_t::eLayerSecure);

    addReparentLocked(transaction, layerId, getLayerIdFromWeakRef(layer->mCurrentParent));

    addDetachChildrenLocked(transaction, layerId, layer->isLayerDetached());

    addRelativeParentLocked(transaction, layerId,

                            getLayerIdFromWeakRef(layer->mCurrentState.zOrderRelativeOf),

                            layer->mCurrentState.z);

}



void SurfaceInterceptor::addInitialDisplayStateLocked(Increment* increment,
@@ -150,7 +157,7 @@ status_t SurfaceInterceptor::writeProtoFileLocked() { 
    return NO_ERROR;

}



const sp<const Layer> SurfaceInterceptor::getLayer(const wp<const IBinder>& weakHandle) {

const sp<const Layer> SurfaceInterceptor::getLayer(const wp<const IBinder>& weakHandle) const {

    const sp<const IBinder>& handle(weakHandle.promote());

    const auto layerHandle(static_cast<const Layer::Handle*>(handle.get()));

    const sp<const Layer> layer(layerHandle->owner.promote());
@@ -158,14 +165,31 @@ const sp<const Layer> SurfaceInterceptor::getLayer(const wp<const IBinder>& weak 
    return layer;

}



const std::string SurfaceInterceptor::getLayerName(const sp<const Layer>& layer) {

const std::string SurfaceInterceptor::getLayerName(const sp<const Layer>& layer) const {

    return layer->getName().string();

}



int32_t SurfaceInterceptor::getLayerId(const sp<const Layer>& layer) {

int32_t SurfaceInterceptor::getLayerId(const sp<const Layer>& layer) const {

    return layer->sequence;

}



int32_t SurfaceInterceptor::getLayerIdFromWeakRef(const wp<const Layer>& layer) const {

    if (layer == nullptr) {

        return -1;

    }

    auto strongLayer = layer.promote();

    return strongLayer == nullptr ? -1 : getLayerId(strongLayer);

}



int32_t SurfaceInterceptor::getLayerIdFromHandle(const sp<const IBinder>& handle) const {

    if (handle == nullptr) {

        return -1;

    }

    const auto layerHandle(static_cast<const Layer::Handle*>(handle.get()));

    const sp<const Layer> layer(layerHandle->owner.promote());

    return layer == nullptr ? -1 : getLayerId(layer);

}



Increment* SurfaceInterceptor::createTraceIncrementLocked() {

    Increment* increment(mTrace.add_increment());

    increment->set_time_stamp(systemTime());
@@ -252,24 +276,23 @@ void SurfaceInterceptor::addTransparentRegionLocked(Transaction* transaction, 
    }

}



void SurfaceInterceptor::addFlagsLocked(Transaction* transaction, int32_t layerId,

        uint8_t flags)

{

void SurfaceInterceptor::addFlagsLocked(Transaction* transaction, int32_t layerId, uint8_t flags,

                                        uint8_t mask) {

    // There can be multiple flags changed

    if (flags & layer_state_t::eLayerHidden) {

    if (mask & layer_state_t::eLayerHidden) {

        SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));

        HiddenFlagChange* flagChange(change->mutable_hidden_flag());

        flagChange->set_hidden_flag(true);

        flagChange->set_hidden_flag(flags & layer_state_t::eLayerHidden);

    }

    if (flags & layer_state_t::eLayerOpaque) {

    if (mask & layer_state_t::eLayerOpaque) {

        SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));

        OpaqueFlagChange* flagChange(change->mutable_opaque_flag());

        flagChange->set_opaque_flag(true);

        flagChange->set_opaque_flag(flags & layer_state_t::eLayerOpaque);

    }

    if (flags & layer_state_t::eLayerSecure) {

    if (mask & layer_state_t::eLayerSecure) {

        SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));

        SecureFlagChange* flagChange(change->mutable_secure_flag());

        flagChange->set_secure_flag(true);

        flagChange->set_secure_flag(flags & layer_state_t::eLayerSecure);

    }

}
@@ -320,6 +343,35 @@ void SurfaceInterceptor::addOverrideScalingModeLocked(Transaction* transaction, 
    overrideChange->set_override_scaling_mode(overrideScalingMode);

}



void SurfaceInterceptor::addReparentLocked(Transaction* transaction, int32_t layerId,

                                           int32_t parentId) {

    SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));

    ReparentChange* overrideChange(change->mutable_reparent());

    overrideChange->set_parent_id(parentId);

}



void SurfaceInterceptor::addReparentChildrenLocked(Transaction* transaction, int32_t layerId,

                                                   int32_t parentId) {

    SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));

    ReparentChildrenChange* overrideChange(change->mutable_reparent_children());

    overrideChange->set_parent_id(parentId);

}



void SurfaceInterceptor::addDetachChildrenLocked(Transaction* transaction, int32_t layerId,

                                                 bool detached) {

    SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));

    DetachChildrenChange* overrideChange(change->mutable_detach_children());

    overrideChange->set_detach_children(detached);

}



void SurfaceInterceptor::addRelativeParentLocked(Transaction* transaction, int32_t layerId,

                                                 int32_t parentId, int z) {

    SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));

    RelativeParentChange* overrideChange(change->mutable_relative_parent());

    overrideChange->set_relative_parent_id(parentId);

    overrideChange->set_z(z);

}



void SurfaceInterceptor::addSurfaceChangesLocked(Transaction* transaction,

        const layer_state_t& state)

{
@@ -351,7 +403,7 @@ void SurfaceInterceptor::addSurfaceChangesLocked(Transaction* transaction, 
        addTransparentRegionLocked(transaction, layerId, state.transparentRegion);

    }

    if (state.what & layer_state_t::eFlagsChanged) {

        addFlagsLocked(transaction, layerId, state.flags);

        addFlagsLocked(transaction, layerId, state.flags, state.mask);

    }

    if (state.what & layer_state_t::eLayerStackChanged) {

        addLayerStackLocked(transaction, layerId, state.layerStack);
@@ -380,6 +432,19 @@ void SurfaceInterceptor::addSurfaceChangesLocked(Transaction* transaction, 
    if (state.what & layer_state_t::eOverrideScalingModeChanged) {

        addOverrideScalingModeLocked(transaction, layerId, state.overrideScalingMode);

    }

    if (state.what & layer_state_t::eReparent) {

        addReparentLocked(transaction, layerId, getLayerIdFromHandle(state.parentHandleForChild));

    }

    if (state.what & layer_state_t::eReparentChildren) {

        addReparentChildrenLocked(transaction, layerId, getLayerIdFromHandle(state.reparentHandle));

    }

    if (state.what & layer_state_t::eDetachChildren) {

        addDetachChildrenLocked(transaction, layerId, true);

    }

    if (state.what & layer_state_t::eRelativeLayerChanged) {

        addRelativeParentLocked(transaction, layerId,

                                getLayerIdFromHandle(state.relativeLayerHandle), state.z);

    }

}



void SurfaceInterceptor::addDisplayChangesLocked(Transaction* transaction,

services/surfaceflinger/SurfaceInterceptor.h

+11 −4
Original line number Diff line number Diff line
@@ -116,9 +116,11 @@ private: 
    void addInitialDisplayStateLocked(Increment* increment, const DisplayDeviceState& display);



    status_t writeProtoFileLocked();

    const sp<const Layer> getLayer(const wp<const IBinder>& weakHandle);

    const std::string getLayerName(const sp<const Layer>& layer);

    int32_t getLayerId(const sp<const Layer>& layer);

    const sp<const Layer> getLayer(const wp<const IBinder>& weakHandle) const;

    const std::string getLayerName(const sp<const Layer>& layer) const;

    int32_t getLayerId(const sp<const Layer>& layer) const;

    int32_t getLayerIdFromWeakRef(const wp<const Layer>& layer) const;

    int32_t getLayerIdFromHandle(const sp<const IBinder>& weakHandle) const;



    Increment* createTraceIncrementLocked();

    void addSurfaceCreationLocked(Increment* increment, const sp<const Layer>& layer);
@@ -141,7 +143,7 @@ private: 
            const layer_state_t::matrix22_t& matrix);

    void addTransparentRegionLocked(Transaction* transaction, int32_t layerId,

            const Region& transRegion);

    void addFlagsLocked(Transaction* transaction, int32_t layerId, uint8_t flags);

    void addFlagsLocked(Transaction* transaction, int32_t layerId, uint8_t flags, uint8_t mask);

    void addLayerStackLocked(Transaction* transaction, int32_t layerId, uint32_t layerStack);

    void addCropLocked(Transaction* transaction, int32_t layerId, const Rect& rect);

    void addCornerRadiusLocked(Transaction* transaction, int32_t layerId, float cornerRadius);
@@ -153,6 +155,11 @@ private: 
    void addTransactionLocked(Increment* increment, const Vector<ComposerState>& stateUpdates,

            const DefaultKeyedVector< wp<IBinder>, DisplayDeviceState>& displays,

            const Vector<DisplayState>& changedDisplays, uint32_t transactionFlags);

    void addReparentLocked(Transaction* transaction, int32_t layerId, int32_t parentId);

    void addReparentChildrenLocked(Transaction* transaction, int32_t layerId, int32_t parentId);

    void addDetachChildrenLocked(Transaction* transaction, int32_t layerId, bool detached);

    void addRelativeParentLocked(Transaction* transaction, int32_t layerId, int32_t parentId,

                                 int z);



    // Add display transactions to the trace

    DisplayChange* createDisplayChangeLocked(Transaction* transaction, int32_t sequenceId);