Android SurfaceFlinger服務（二） ----- 本地Surface創建

Android顯示系統層次分析

應用層，app從WindowManager服務獲取圖層，渲染圖層
WindowManager管理層，主要管理APP渲染的圖層，調用SurfaceFlinger服務，創建Surface,並將Surface傳遞給應用
SurfaceFlinger層，對上層負責Surface的創建，對下層管理各個顯示設備，以及將Surface合成合顯示到顯示設備上
顯示驅動層，屬於內核層次。SurfaceFlinger最終調用顯示驅動顯示圖像

有了上面的這個整體把握，我們就可以一層一層的去分析整個顯示系統源碼了。首先，以SurfaceFlinger測試程序resize來看看本地SufaceFlinger的創建和使用。

Surface本地創建

// resize測試程序源碼，略有修改，解決編譯不通過的問題
int main(void)
{
    // set up the thread-pool
    sp<ProcessState> proc(ProcessState::self());
    ProcessState::self()->startThreadPool();

    // create a client to surfaceflinger
    sp<SurfaceComposerClient> client = new SurfaceComposerClient();

    sp<SurfaceControl> surfaceControl = client->createSurface(String8("resize"), 160, 240, PIXEL_FORMAT_RGB_565, 0);

    sp<Surface> surface = surfaceControl->getSurface();

    SurfaceComposerClient::openGlobalTransaction();
    surfaceControl->setLayer(100000);
    SurfaceComposerClient::closeGlobalTransaction();

    ANativeWindow_Buffer outBuffer;
    surface->lock(&outBuffer, NULL);
    ssize_t bpr = outBuffer.stride * bytesPerPixel(outBuffer.format);
    android_memset16((uint16_t*)outBuffer.bits, 0xF800, bpr*outBuffer.height);
    surface->unlockAndPost();

    surface->lock(&outBuffer, NULL);
    android_memset16((uint16_t*)outBuffer.bits, 0x07E0, bpr*outBuffer.height);
    surface->unlockAndPost();

    SurfaceComposerClient::openGlobalTransaction();
    surfaceControl->setSize(320, 240);
    SurfaceComposerClient::closeGlobalTransaction();


    IPCThreadState::self()->joinThreadPool();

    return 0;
}

創建一個SurfaceComposerClient對象
調用SurfaceComposerClient對象的createSurface方法，得到一個SurfaceControl的引用
調用SurfaceControl的getSurface方法得到一個Surface引用

創建Surface的代碼看上去沒幾行，但涉及的內容遠不止看上去的這些。下面來逐一分析，先看看SurfaceComposerClient這個類：

class SurfaceComposerClient : public RefBase
{   
    friend class Composer;
public:
                SurfaceComposerClient();
    virtual     ~SurfaceComposerClient();

    ......

    // Return the connection of this client
    sp<IBinder> connection() const;
        
    ......

    //! Create a surface
    sp<SurfaceControl> createSurface(
            const String8& name,// name of the surface
            uint32_t w,         // width in pixel
            uint32_t h,         // height in pixel
            PixelFormat format, // pixel-format desired
            uint32_t flags = 0  // usage flags
    );


private:
    virtual void onFirstRef();
    Composer& getComposer();

    mutable     Mutex                       mLock;
                status_t                    mStatus;
                sp<ISurfaceComposerClient>  mClient;
                Composer&                   mComposer;
};

SurfaceComposerClient繼承於RefBase，所以他new一個SurfaceComposerClient對象時。其構造方法和onFirstRef方法被調用。

// 構造函數
SurfaceComposerClient::SurfaceComposerClient()
    : mStatus(NO_INIT), mComposer(Composer::getInstance())
{
}

mStatus狀態設置爲NO_INIT
mComposer指向單實例類Composer

void SurfaceComposerClient::onFirstRef() {
    sp<ISurfaceComposer> sm(ComposerService::getComposerService());
    if (sm != 0) {
        sp<ISurfaceComposerClient> conn = sm->createConnection();
        if (conn != 0) {
            mClient = conn;
            mStatus = NO_ERROR;
        }
    }
}

獲取ISurfaceComposer代理對象接口。
調用ISurfaceComposer接口方法createConnection得到ISurfaceComposerClient代理對象接口。如果獲取成功，將ISurfaceComposerClient代理對象接口賦值給mClient，並將mStatus設置爲NO_ERROR

創建ISurfaceComposerClientBinder實體對象過程就要去看看ISurfaceComposer的遠程實現。正好ISurfaceComposer的遠程實現類就是SurfaceFlinger類。

sp<ISurfaceComposerClient> SurfaceFlinger::createConnection()
{
    sp<ISurfaceComposerClient> bclient;
    sp<Client> client(new Client(this));
    status_t err = client->initCheck();
    if (err == NO_ERROR) {
        bclient = client;
    }  
    return bclient;
}

new一個Client類對象，構造函數中傳入SurfaceFlinger對象指針。
調用initCheck函數進行初始化，如果初始化成功就返回該對象引用，否則返回空
每次調用createConnection都會創建一個Client類對象，每個對象都是一個遠程服務實體，爲客戶端服務（既mClient方法的實現）。

從SurfaceComposerClient::onFirstRef可以看出，SurfaceComposerClient類裏有一個比較重要的成員變量mClient，它指向ISurfaceComposerClient代理對象。
SurfaceComposerClient創建完成了，接下來看看它的createSurface方法。研究下如何創建SurfaceControl對象。

sp<SurfaceControl> SurfaceComposerClient::createSurface(
        const String8& name,
        uint32_t w,
        uint32_t h,
        PixelFormat format,
        uint32_t flags)
{
    sp<SurfaceControl> sur;
    if (mStatus == NO_ERROR) {
        sp<IBinder> handle;
        sp<IGraphicBufferProducer> gbp;
        status_t err = mClient->createSurface(name, w, h, format, flags,                                                                                                                     
                &handle, &gbp);
        ALOGE_IF(err, "SurfaceComposerClient::createSurface error %s", strerror(-err));
        if (err == NO_ERROR) {
            sur = new SurfaceControl(this, handle, gbp);
        }
    }  
    return sur;
}

調用mClient（ISurfaceComposerClient）的createSurface方法，然而，這個方法好像並沒有返回Surface對象。但是我們得到了另外兩個東西，hander和gbp。這些是什麼怪物，下篇文章在分析。
通過上面獲取的兩個怪物創建SurfaceControl對象，構造函數中傳入有三個參數。this指針（SurfaceComposerClient對象）、handle、gbp。

ISurfaceComposerClient爲Binder接口，createSurface方法最終在遠程服務中實現。直接看看這個方法的遠程實現

// FILE: frameworks/native/services/surfaceflinger/Client.cpp
status_t Client::createSurface(
        const String8& name,            
        uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
        sp<IBinder>* handle,            
        sp<IGraphicBufferProducer>* gbp)
{
    /*
     * createSurface must be called from the GL thread so that it can
     * have access to the GL context.   
     */

    class MessageCreateLayer : public MessageBase {
        SurfaceFlinger* flinger;
        Client* client;
        sp<IBinder>* handle;
        sp<IGraphicBufferProducer>* gbp;
        status_t result;
        const String8& name;
        uint32_t w, h;                  
        PixelFormat format;
        uint32_t flags;
    public:
        MessageCreateLayer(SurfaceFlinger* flinger,      
                const String8& name, Client* client,     
                uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
                sp<IBinder>* handle,
                sp<IGraphicBufferProducer>* gbp)     
            : flinger(flinger), client(client),        
              handle(handle), gbp(gbp),
              name(name), w(w), h(h), format(format), flags(flags) {                                                                                                                         
        }
        status_t getResult() const { return result; }
        virtual bool handler() {
            result = flinger->createLayer(name, client, w, h, format, flags,                                                                                                                 
                    handle, gbp);
            return true;
        }
    };

    sp<MessageBase> msg = new MessageCreateLayer(mFlinger.get(), 
            name, this, w, h, format, flags, handle, gbp);
    mFlinger->postMessageSync(msg);
    return static_cast<MessageCreateLayer*>( msg.get() )->getResult();                                                                                                                       
}

這個函數啥也沒幹，只是把工作給轉移了。發消息給SurfaceFlinger創建Layer。
消息發送與處理不是關心的重點就不展開了。只要知道最後SurfaceFlinger工作線程去執行Message的handler函數就行了
看看這個消息的handler函數，還是去調用SurfaceFlinger的createLayer函數去創建Layer，真是繞啊。

status_t SurfaceFlinger::createLayer(
        const String8& name,
        const sp<Client>& client,
        uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
        sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp)
{   
    //ALOGD("createLayer for (%d x %d), name=%s", w, h, name.string());
    if (int32_t(w|h) < 0) {
        ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
                int(w), int(h));
        return BAD_VALUE;
    }

    status_t result = NO_ERROR;
    
    sp<Layer> layer;
    
    switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
        case ISurfaceComposerClient::eFXSurfaceNormal:
            result = createNormalLayer(client,
                    name, w, h, flags, format,
                    handle, gbp, &layer);
            break;
        case ISurfaceComposerClient::eFXSurfaceDim:
            result = createDimLayer(client,
                    name, w, h, flags,
                    handle, gbp, &layer);
            break;
        default:
            result = BAD_VALUE;
            break;
    }

    if (result != NO_ERROR) {
        return result;
    }

    result = addClientLayer(client, *handle, *gbp, layer);
    if (result != NO_ERROR) {
        return result;
    }

    setTransactionFlags(eTransactionNeeded);
    return result;
}

根據flags調用不同的函數創建Layer
調用addClientLayer將創建的Layer添加到相關的數據結構中
handler gbp將在創建layer時賦值。關於Layer創建下篇文章在分析，一下子寫多了容易糊塗。

在回來看看得到handle gbp以後，用它們來構造一個SurfaceControl對象。

SurfaceControl::SurfaceControl(
        const sp<SurfaceComposerClient>& client, 
        const sp<IBinder>& handle,
        const sp<IGraphicBufferProducer>& gbp) 
    : mClient(client), mHandle(handle), mGraphicBufferProducer(gbp)
{
}

handle賦值給了成員變量mHandler
gbp賦值給了成員變量mGraphicBufferProducer, 圖像緩衝區生產者接口

然後調用SurfaceControl的getSurface方法得到Surface,看看該方法

sp<Surface> SurfaceControl::getSurface() const
{
    Mutex::Autolock _l(mLock);
    if (mSurfaceData == 0) {
        // This surface is always consumed by SurfaceFlinger, so the
        // producerControlledByApp value doesn't matter; using false.
        mSurfaceData = new Surface(mGraphicBufferProducer, false);
    }  
    return mSurfaceData;
}

構造函數中主要傳入的是mGraphicBufferProducer

Surface::Surface(
        const sp<IGraphicBufferProducer>& bufferProducer,
        bool controlledByApp)
    : mGraphicBufferProducer(bufferProducer),
      mGenerationNumber(0)
{
    // Initialize the ANativeWindow function pointers.
    ANativeWindow::setSwapInterval  = hook_setSwapInterval;
    ANativeWindow::dequeueBuffer    = hook_dequeueBuffer;
    ANativeWindow::cancelBuffer     = hook_cancelBuffer;
    ANativeWindow::queueBuffer      = hook_queueBuffer;
    ANativeWindow::query            = hook_query;
    ANativeWindow::perform          = hook_perform;

    ANativeWindow::dequeueBuffer_DEPRECATED = hook_dequeueBuffer_DEPRECATED;
    ANativeWindow::cancelBuffer_DEPRECATED  = hook_cancelBuffer_DEPRECATED;
    ANativeWindow::lockBuffer_DEPRECATED    = hook_lockBuffer_DEPRECATED;
    ANativeWindow::queueBuffer_DEPRECATED   = hook_queueBuffer_DEPRECATED;
    ......
}

Surface在構造函數中最終將gbp賦值給了成員變量mGraphicBufferProducer。
每個Surface對象中都含有一個圖像緩衝區生產者接口用於畫圖。

做個總結：

客戶端首先通過ISurfaceComposer接口創建與SurfaceFlinger的連接，得到ISurfaceComposerClient代理接口。
調用ISurfaceComposerClient的createSurface,得到handle和gdp
客戶端利用SurfaceComposerClient對象指針、handle、gdp創建SurfaceControl對象。
最後通過SurfaceControl的getSurface得到surface對象引用

Android SurfaceFlinger服務（二） ----- 本地Surface創建

Android顯示系統層次分析

Surface本地創建

螞蟻面試：Springcloud核心組件的底層原理，你知道多少？

認知提升的方法

C#開源的兩款功能強大的錄屏神器

很好的PyQt5中文教程

Windows 中使用python 一鍵下載android r代碼

Android SurfaceFlinger服務（二） ----- 本地Surface創建

Android SurfaceFlinger服務（四） ----- 消息機制MessageQueue

Android SurfaceFlinger服務（七） ----- 圖像的合成

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結