SurfaceFlinger学习2

Layer

class Layer : public virtual RefBase, compositionengine::LayerFE {
    mutable bool contentDirty{false};
    Region surfaceDamageRegion;

    // Layer serial number.  This gives layers an explicit ordering, so we
    // have a stable sort order when their layer stack and Z-order are
    // the same.
    int32_t sequence{sSequence++};
        // constant
    sp mFlinger;

    protected:
    compositionengine::OutputLayer* findOutputLayerForDisplay(const DisplayDevice*) const;//OutputLayer最后合成的layer
    
        // these are protected by an external lock (mStateLock)
    State mCurrentState;
        // These are only accessed by the main thread or the tracing thread.
    State mDrawingState;
    const wp mClientRef;//who? mClientRef(args.client),
    /*
        // constant
    sp mFlinger;

    // protected by mLock
    DefaultKeyedVector< wp, wp > mLayers;
    */
    
    // Child list about to be committed/used for editing.
    LayerVector mCurrentChildren{LayerVector::StateSet::Current};
    // Child list used for rendering.
    LayerVector mDrawingChildren{LayerVector::StateSet::Drawing};

    wp mCurrentParent;
    wp mDrawingParent;

virtual bool isOpaque(const Layer::State&) const { return false; }
bool isSecure() const;
virtual bool isVisible() const = 0;
virtual bool isProtected() const { return false; }
virtual bool canReceiveInput() const;
bool isHiddenByPolicy() const;

    /*
     * doTransaction - process the transaction. This is a good place to figure
     * out which attributes of the surface have changed.
     */
    uint32_t doTransaction(uint32_t transactionFlags);

    /*
     * latchBuffer - called each time the screen is redrawn and returns whether
     * the visible regions need to be recomputed (this is a fairly heavy
     * operation, so this should be set only if needed). Typically this is used
     * to figure out if the content or size of a surface has changed.
     */
    virtual bool latchBuffer(bool& /*recomputeVisibleRegions*/, nsecs_t /*latchTime*/,
                             nsecs_t /*expectedPresentTime*/) {
        return false;
    }

    virtual bool isBufferLatched() const { return false; }

    virtual void latchAndReleaseBuffer() {}

bool Layer::attachChildren() {
    bool changed = false;
    for (const sp& child : mCurrentChildren) {
        sp parentClient = mClientRef.promote();
        sp client(child->mClientRef.promote());//class Client : public BnSurfaceComposerClient
        if (client != nullptr && parentClient != client) {
            if (child->mLayerDetached) {
                child->mLayerDetached = false;
                changed = true;
            }
            changed |= child->attachChildren();
        }
    }

    return changed;
}

BufferLayer

class BufferLayer : public Layer {
    
        bool latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime,
                     nsecs_t expectedPresentTime) override;

    bool isBufferLatched() const override { return mRefreshPending; }//override显示指明需要重写的方法

    BufferInfo mBufferInfo;

BufferLayerConsumer

BufferLayerConsumer consumes buffers of graphics data from a BufferQueue,
and makes them available to RenderEngine as a texture.

class BufferLayerConsumer : public ConsumerBase {
  
        // mCurrentTextureBuffer is the buffer containing the current texture. It's
    // possible that this buffer is not associated with any buffer slot, so we
    // must track it separately in order to support the getCurrentBuffer method.
    std::shared_ptr mCurrentTextureBuffer;
        // mCurrentCrop is the crop rectangle that applies to the current texture.
    // It gets set each time updateTexImage is called.
    Rect mCurrentCrop;
        // The portion of this surface that has changed since the previous frame
    Region mCurrentSurfaceDamage;
    
        // Utility class for managing GraphicBuffer references into renderengine
    class Image {
    public:
        Image(const sp& graphicBuffer, renderengine::RenderEngine& engine);
        virtual ~Image();
        const sp& graphicBuffer() { return mGraphicBuffer; }

    private:
        // mGraphicBuffer is the buffer that was used to create this image.
        sp mGraphicBuffer;
        // Back-reference into renderengine to initiate cleanup.
        renderengine::RenderEngine& mRE;
        DISALLOW_COPY_AND_ASSIGN(Image);
    };

BufferQueueLayer

/*
 * A new BufferQueue and a new BufferLayerConsumer are created when the
 * BufferLayer is first referenced.
 *
 * This also implements onFrameAvailable(), which notifies SurfaceFlinger
 * that new data has arrived.
 */

class BufferQueueLayer : public BufferLayer {
class BufferStateLayer : public BufferLayer {//Interface implementation for Layer
    sp mConsumer;
    sp mProducer;
    
    Vector mQueueItems;
    sp mContentsChangedListener;

    // -----------------------------------------------------------------------
    // Interface implementation for BufferLayerConsumer::ContentsChangedListener
    // -----------------------------------------------------------------------
    class ContentsChangedListener : public BufferLayerConsumer::ContentsChangedListener {
    public:
        ContentsChangedListener(BufferQueueLayer* bufferQueueLayer)
              : mBufferQueueLayer(bufferQueueLayer) {}
        void abandon();

    protected:
        void onFrameAvailable(const BufferItem& item) override;
        void onFrameReplaced(const BufferItem& item) override;
        void onSidebandStreamChanged() override;
        void onFrameDequeued(const uint64_t bufferId) override;
        void onFrameDetached(const uint64_t bufferId) override;
        void onFrameCancelled(const uint64_t bufferId) override;

    private:
        BufferQueueLayer* mBufferQueueLayer = nullptr;
        Mutex mMutex;
    };

Client

SurfaceComposerClient服务的本地Binder实现

class Client : public BnSurfaceComposerClient
    
        // constant
    sp mFlinger;

    // protected by mLock
    DefaultKeyedVector< wp, wp > mLayers;

从return mFlinger->createLayer可知，Client是暴露给producer的接口，Client又是一个转接类，真正的实现，由mFlinger完成

Client属于匿名binder服务，外界的进程不可能直接获取到，因而首先需要借助SurfaceFlinger这一实名binder Service

sp SurfaceFlinger::createConnection() {
    const sp client = new Client(this);
    return client->initCheck() == NO_ERROR ? client : nullptr;
}

Client::Client(const sp& flinger)
    : mFlinger(flinger)
{
}

sp Client::getLayerUser(const sp& handle) const
{
    Mutex::Autolock _l(mLock);
    sp lbc;
    wp layer(mLayers.valueFor(handle));
    if (layer != 0) {
        lbc = layer.promote();
        ALOGE_IF(lbc==0, "getLayerUser(name=%p) is dead", handle.get());
    }
    return lbc;
}

status_t Client::createSurface(const String8& name, uint32_t w, uint32_t h, PixelFormat format,
                               uint32_t flags, const sp& parentHandle,
                               LayerMetadata metadata, sp* handle,
                               sp* gbp, uint32_t* outTransformHint) {
    // We rely on createLayer to check permissions.
    return mFlinger->createLayer(name, this, w, h, format, flags, std::move(metadata), handle, gbp,
                                 parentHandle, nullptr, outTransformHint);
}

MonitoredProducer

// MonitoredProducer wraps an IGraphicBufferProducer so that SurfaceFlinger will
// be notified upon its destruction
class MonitoredProducer : public BnGraphicBufferProducer {
    public:
    MonitoredProducer(const sp& producer,
            const sp& flinger,
            const wp& layer);
        // The Layer which created this producer, and on which queued Buffer's will be displayed.
    sp getLayer() const;

private:
    sp mProducer;
    sp mFlinger;
    // The Layer which created this producer, and on which queued Buffer's will be displayed.
    wp mLayer;
};

MonitoredProducerde 功能与Client差不多

status_t MonitoredProducer::dequeueBuffer(int* slot, sp* fence, uint32_t w, uint32_t h,
                                          PixelFormat format, uint64_t usage,
                                          uint64_t* outBufferAge,
                                          FrameEventHistoryDelta* outTimestamps) {
    return mProducer->dequeueBuffer(slot, fence, w, h, format, usage, outBufferAge, outTimestamps);
}

LayerVector

/*
 * Used by the top-level SurfaceFlinger state and individual layers
 * to track layers they own sorted according to Z-order. Provides traversal
 * functions for traversing all owned layers, and their descendents.
 */
class LayerVector : public SortedVector> {
public:
    enum class StateSet {
        Invalid,
        Current,
        Drawing,
    };
    
private:
    const StateSet mStateSet;

ComposerService

class ComposerService : public Singleton
{
    sp mComposerService;
    sp mDeathObserver;
    Mutex mLock;

    ComposerService();
    void connectLocked();
    void composerServiceDied();
    friend class Singleton;
public:

    // Get a connection to the Composer Service.  This will block until
    // a connection is established.
    static sp getComposerService();//得到SurfaceFlinger的Binder代理对象

};

sp composer;
composer = ComposerService::getComposerService();
或者 getService("SurfaceFlinger", &composer);

ISurfaceComposerClient，得到SurfaceComposerClient的Binder代理对象，ISurfaceComposerClient is the interface to create Surface。

sp composerClient = composer->createConnection();

要操作Surface，需要得到SurfaceControl

sp surfaceControl = composerClient->createSurface();

int Surface::lock(ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds);//得到一块surface(Layer)
int Surface::unlockAndPost();

all-kinds-of-buffers.png

SurfaceFlinger

SurfaceFlinger实现了ISurfaceComposer接口，是服务端

参考资料：https://waynewolf.github.io/2014/06/22/surfaceflinger-and-client/

class SurfaceFlinger : public BnSurfaceComposer,
                       public PriorityDumper,
                       public ClientCache::ErasedRecipient,
                       private IBinder::DeathRecipient,
                       private HWC2::ComposerCallback,
                       private ISchedulerCallback {

status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) override;
     /* ISurfaceComposer interface
     */
    sp createConnection() override;

handleMessageRefresh
     |—> preComposition
     |—> rebuildLayerStacks
     |—> setUpHWComposer
          |—> HWComposer::createWorkList <== hwc="" structures="" are="" allocated="" |—=""> Layer::setGeometry()
          |—  set per frame data
          |—  HWComposer::prepare
               |—> hwc prepare
     |—> doComposition
          |---- skip composition on external display if condition meets
          |—> doDisplayComposition
          |    |—> doComposeSurfaces
          |     |—> DisplayDevice::swapBuffers
          |          |—> eglSwapBuffers
          |          |—> FramebufferSurface::advanceFrame
          |—> DisplayDevice::flip(…)     <== just="" update="" statistics="" count="" |--=""> Call DisplayDevice::compositionComplete(), notify each display
               |--> DisplaySurface::compositionComplete()
                    |--> FramebufferSurface::compositionComplete()
                         |--> HWComposer::fbCompositionComplete()
                              |--> NoOP if HWC >= 1.1
                              |--> used only in framebuffer device case.
          |—> postFrameBuffer
               |—> HWComposer::commit
                    |—> hwc set
                    |—> update retireFenceFd of hwc_display_contents_1
               |—> DisplayDevice::onSwapBuffersCompleted
                    |—> FramebufferSurface::onFrameComitted
               |—> Layer::onLayerDisplayed
               |—   update some statistics
     |—> postCom

CompositionRefreshArgs

/**
 * A parameter object for refreshing a set of outputs
 */
struct CompositionRefreshArgs {
    // All the outputs being refreshed
    Outputs outputs;

    // All the layers that are potentially visible in the outputs. The order of
    // the layers is important, and should be in traversal order from back to
    // front.
    Layers layers;

    // All the layers that have queued updates.
    Layers layersWithQueuedFrames;

    // If true, forces the entire display to be considered dirty and repainted
    bool repaintEverything{false};

/**
 * An output layer contains the output-dependent composition state for a layer
 */
class OutputLayer {
    
/**
 * Encapsulates all the state involved with composing layers for an output
 */
class Output {