1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

frameworks/native/services/surfaceflinger
    SurfaceFlinger.cpp
    main_surfaceflinger.cpp
    MessageQueue.cpp
    EventControlThread.cpp
    DispSync.cpp
    DisplayHardware/HWComposer.cpp

frameworks/native/libs/binder
    ProcessState.cpp

system/core/libutils
    Looper.cpp

frameworks/native/libs/gui/
    DisplayEventReceiver.cpp
    BitTube.cpp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

//service和四大组件中的service无关。会解析为启动阶段系统服务的对象，并启动
//指定服务名，执行文件位置
service surfaceflinger /system/bin/surfaceflinger
    //核心class，表面启动时间是boot后就启动
    class core
	//用户 system，其它的还有root adb 等
    user system
	//用户组
    group graphics drmrpc
	//如果重启会导致zygote重启
    onrestart restart zygote
    writepid /dev/cpuset/system-background/tasks

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

int main(int, char**) {
    // When SF is launched in its own process, limit the number of
    // binder threads to 4.
    //self方法，获取ProcessState单例
    ProcessState::self()->setThreadPoolMaxThreadCount(4);

    // start the thread pool
    //引用计数
    sp<ProcessState> ps(ProcessState::self());
    //启动binder 线程池
    ps->startThreadPool();

    // instantiate surfaceflinger
    sp<SurfaceFlinger> flinger = new SurfaceFlinger();

    //进程优先级 URGENT 紧迫的
    setpriority(PRIO_PROCESS, 0, PRIORITY_URGENT_DISPLAY);
	//调度策略 前台
    set_sched_policy(0, SP_FOREGROUND);

    // initialize before clients can connect
    flinger->init();

    // publish surface flinger
    sp<IServiceManager> sm(defaultServiceManager());
    sm->addService(String16(SurfaceFlinger::getServiceName()), flinger, false);

    // run in this thread
    flinger->run();

    return 0;
}

1
2
3
4

//最终继承到RefBase，主要是引用计数的，智能指针，引用为0后会回收
SurfaceFlinger:BnSurfaceComposer:BnInterface:ISurfaceComposer,BBinder:IBinder:RefBase
//binder通信接口定义，用于访问surfaceFlinger的方法
ISurfaceComposer:IInterface:RefBase

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

void SurfaceFlinger::onFirstRef()
{
    mEventQueue.init(this);
}


void MessageQueue::init(const sp<SurfaceFlinger>& flinger)
{
    mFlinger = flinger;
    mLooper = new Looper(true);
    mHandler = new Handler(*this);
}


class MessageQueue {
    class Handler : public MessageHandler {
        enum {
            eventMaskInvalidate     = 0x1,
            eventMaskRefresh        = 0x2,
            eventMaskTransaction    = 0x4
        };
        MessageQueue& mQueue;
        int32_t mEventMask;
    public:
        Handler(MessageQueue& queue) : mQueue(queue), mEventMask(0) { }
        virtual void handleMessage(const Message& message);
        void dispatchRefresh();
        void dispatchInvalidate();
        void dispatchTransaction();
    };
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

//SurfaceFlinger.cpp
void SurfaceFlinger::run() {
    do {
        waitForEvent();
    } while (true);
}

void SurfaceFlinger::waitForEvent() {
    mEventQueue.waitMessage();
}

//MessageQueue.cpp
void MessageQueue::waitMessage() {
    do {
        IPCThreadState::self()->flushCommands();
        int32_t ret = mLooper->pollOnce(-1);
        switch (ret) {
            case Looper::POLL_WAKE:
            case Looper::POLL_CALLBACK:
                continue;
            case Looper::POLL_ERROR:
                ALOGE("Looper::POLL_ERROR");
            case Looper::POLL_TIMEOUT:
                // timeout (should not happen)
                continue;
            default:
                // should not happen
                ALOGE("Looper::pollOnce() returned unknown status %d", ret);
                continue;
        }
    } while (true);
}