1. The document describes the initialization process of SurfaceFlingerService in Android. 2. SurfaceFlinger is instantiated which creates the main SurfaceFlinger instance. This triggers the initialization of various core Android services. 3. The main display is initialized by creating a DisplayHardware instance and a graphic plane for the display. Shared memory is allocated to share display information.

1. SurfaceFlingerService
(서피스플링거서비스초기화)
박철희
1

2. 1.Surfaceflinger 전체 구조
SurfaceFlinger
Client NaitveWindow
App SurfacecomposerClient
layer1 OpenGL ES
Graphic buffer API NativeBuffer
Front buffer
*EGL
layer2
NativeBuffer
layer3 back buffer
Android mmap으로
mapping mapping
kernel
FrameBuffer
Graphic buffer
공유 메모리
Front buffer Lcd Pannel
……
back buffer
*EGL:Embedded Graphic Library
2

3. 2.SurfaceFlinger 클래스의 인스턴스 생성
Systemserver.java
public class SystemServer {
public static void main(String[] args) {
System.loadLibrary("android_servers");
init1(args);
}
native public static void init1(String[] args);
}
Com_android_server_systemserser.cpp
static JNINativeMethod gMethods[] = {
/* name, signature, funcPtr */
{ "init1", "([Ljava/lang/String;)V", (void*) android_server_SystemServer_init1 },
};
static void android_server_SystemServer_init1(JNIEnv* env, jobject clazz)
{
system_init();
}
System_init.cpp
extern "C" status_t system_init()
{
SurfaceFlinger::instantiate();
SensorService::instantiate();
jclass clazz = env->FindClass("com/android/server/SystemServer");
jmethodID methodId = env->GetStaticMethodID(clazz, "init2", "()V");
env->CallStaticVoidMethod(clazz, methodId);
}
3

4. 2.SurfaceFlinger 클래스의 인스턴스 생성
Pthread_create
2 3
Thread
Run() _threadLoop()
Refbase
4 1회호출 5 반복호출
1
SurfaceFlinger
onFirstRef() ReadyToRun() ThreadLoop()
RefBase.cpp
void RefBase::incStrong(const void* id) const{
const_cast<RefBase*>(this)->onFirstRef();
}
SurfaceFlinger..cpp
void SurfaceFlinger::onFirstRef()
{
run("SurfaceFlinger", PRIORITY_URGENT_DISPLAY);
1 // Wait for the main thread to be done with its initialization
mReadyToRunBarrier.wait();  ReadyToRun 함수에서 mReadyToRunBarrier.open()가 불릴때 까지 기다린다.
}
4

5. 2.SurfaceFlinger 클래스의 인스턴스 생성
Threads.cpp
status_t Thread::run(const char* name, int32_t priority, size_t stack){
res = androidCreateRawThreadEtc
(_threadLoop,this, name, priority, stack, &mThread);
}
2
int androidCreateRawThreadEtc(){
int result = pthread_create(&thread, &attr,
(android_pthread_entry)entryFunction, userData);
} 3
int Thread::_threadLoop(void* user)
{
do {
bool result;
if (first) {
first = false;
self->mStatus = self->readyToRun(); 4
}
else{
result = self->threadLoop(); 5
}
}
}
5

6. 2.SurfaceFlinger 클래스의 인스턴스 생성-readyToRun()
SurfacefFlinger.cpp
status_t SurfaceFlinger::readyToRun()
(
1.메인 디스 플레이 초기화
// initialize the main display
GraphicPlane& plane(graphicPlane(dpy));
DisplayHardware* const hw = new DisplayHardware(this, dpy);
plane.setDisplayHardware(hw);
2. 디스 플레이 공유 메모리 생성
// create the shared control-block
mServerHeap = new MemoryHeapBase(4096, MemoryHeapBase::READ_ONLY, "SurfaceFlinger read-only heap");
mServerCblk = static_cast<surface_flinger_cblk_t*>(mServerHeap->getBase());
new(mServerCblk) surface_flinger_cblk_t;
3. initialize the shared control block
mServerCblk->connected |= 1<<dpy;
display_cblk_t* dcblk = mServerCblk->displays + dpy;
memset(dcblk, 0, sizeof(display_cblk_t));
4.open GL ES 초기화
// Initialize OpenGL|ES
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
glPixelStorei(GL_PACK_ALIGNMENT, 4);
glEnableClientState(GL_VERTEX_ARRAY);
5.onfirstref()에서 기다리고 있는 thread에 signal 보냄.
mReadyToRunBarrier.open();
6.부트 애니메이션 시작
// start boot animation
property_set("ctl.start", "bootanim");  /system/bin/bootanimation 프로세스 실행.
}
6

7. 3.메인 디스플레이 초기화
1.GraphicPlane& plane(graphicPlane(dpy));
디스플레이의 정보를 가지는 graphicplane calss를 생성하고 , 0번째 요소를 메인 디스플레이로 설정한다.
GraphicPlane& plane(graphicPlane(dpy)); //dpy=0;
GraphicPlane& SurfaceFlinger::graphicPlane(int dpy)
{
return const_cast<GraphicPlane&>(const_cast<SurfaceFlinger const *>(this)->graphicPlane(dpy));
}
const GraphicPlane& SurfaceFlinger::graphicPlane(int dpy) const
{
const GraphicPlane& plane(mGraphicPlanes[dpy]);
return plane;
}
2. DisplayHardware* const hw = new DisplayHardware(this, dpy);
DisplayHardware를 생성하고, EGL 네이티브 윈도우를 생성하고 초기화 한다.
DisplayHardware::DisplayHardware(..): DisplayHardwareBase(flinger, dpy),mFlinger(flinger), mFlags(0), mHwc(0)
{
init(dpy);
}
void DisplayHardware::init(uint32_t dpy)
{
mNativeWindow = new FramebufferNativeWindow(); Native window 생성
//EGL 초기화 수행
}
7

8. 3.메인 디스플레이 초기화
FramebufferNativeWindow::FramebufferNativeWindow()
{
if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module) == 0)
{ gralloc.msm8960.so 를 load해서
err = framebuffer_open(module, &fbDev);
framebuffer device를 open하고 framebuffer에 접근할 수 있는 변수를 fbDev에 저장한다.
static inline int framebuffer_open(const struct hw_module_t* module,
struct framebuffer_device_t** device) {
return module->methods->open(module,
GRALLOC_HARDWARE_FB0, (struct hw_device_t**)device);
} "fb0"
err = gralloc_open(module, &grDev);
그래픽 버퍼 할당 device를 open하고 ,device에 접근 할 수 있는 변수를 grDev에 저장한다.
tatic inline int gralloc_open(const struct hw_module_t* module,
struct alloc_device_t** device) {
return module->methods->open(module,
GRALLOC_HARDWARE_GPU0, (struct hw_device_t**)device);
} “gpu0”
for (i = 0; i < mNumBuffers; i++)
{
buffers[i] = new NativeBuffer( fbDev->width, fbDev->height, fbDev->format, GRALLOC_USAGE_HW_FB);
}
framebuffer를 가리키는 Nativebuffer 구조체를 생성한다.
Nativebuffer의 그래픽 버퍼가
프레임 버퍼에 매핑되어 있다는 의미
8

9. 3.메인 디스플레이 초기화
for (i = 0; i < mNumBuffers; i++) 프레임 버퍼에 메모리를 할당한다는 의미
{
err = grDev->alloc(grDev,
fbDev->width, fbDev->height, fbDev->format,
GRALLOC_USAGE_HW_FB, &buffers[i]->handle, &buffers[i]->stride);
}
 Nativebuffer 와 mapping된 framebuffer에 메모리를 할당한다.
ANativeWindow::setSwapInterval = setSwapInterval; int FramebufferNativeWindow::lockBuffer(..){
ANativeWindow::dequeueBuffer = dequeueBuffer; framebuffer_device_t* fb = self->fbDev;
ANativeWindow::lockBuffer = lockBuffer; fb-> lockBuffer(fb, index);
ANativeWindow::queueBuffer = queueBuffer; }
…
NativeWindow method와 framebuffer method를 mapping한다.
}
3. plane.setDisplayHardware(hw);
생성한 displayHardware의 정보들을 GraphicPlane class에 설정해 준다.(withd,height,orientation)
void GraphicPlane::setDisplayHardware(DisplayHardware *hw)
{
mHw = hw;
const float w = hw->getWidth();
const float h = hw->getHeight();
GraphicPlane::orientationToTransfrom(displayOrientation, w, h,&mDisplayTransform);
}
9

10. 4.디스플레이 공유 메모리 생성 및 초기화
1. mServerHeap = new MemoryHeapBase(4096, MemoryHeapBase::READ_ONLY, "SurfaceFlinger read-only heap");
디스플레이의 정보를 공유할 디스플레이 공유 메모리 생성
2. mServerCblk = static_cast<surface_flinger_cblk_t*>(mServerHeap->getBase());
생성된 공유 메모리의 시작점을 얻어 옴.
3. new(mServerCblk) surface_flinger_cblk_t;
시작점에 surface_flinger_cblk_t를 생성하고, mServerCblk 멤버 변수가 가리킴.
4. mServerCblk->connected |= 1<<dpy;
connected 변수에 연결된 display의 식별번호를 저장(1개인 경우 0x00000001, 두개인 경우 0x00000011)
5. display_cblk_t* dcblk = mServerCblk->displays + dpy;
memset(dcblk, 0, sizeof(display_cblk_t));
dcblk->w = plane.getWidth();
dcblk->h = plane.getHeight();
dcblk->format = f;
dcblk->orientation = ISurfaceComposer::eOrientationDefault;
display_cblk_t 를 생성하고 displayhardware 구조체 value로 초기화 함.
디스플레이 공유 메모리
surface_flinger_cblk_t surfaceflinger
connected mServerCblk
Dislay_cblk_t dcblk
w,h:프레임 버퍼 너비,높이
Density,fps
Format,orientation
Xdpi,ydpi
10

11. 참고. Android HAL 구조 분석(Framebuffer_open 분석)
1.Android HAL의 일반적인 구조
xxx_module_t Xxx_device_t
hw_module_t hw_device_t
Module
id Xxx_HARDWARE_MODULE_I
D close
methods 생성 Xxx_close
Xxx_module_methods
open Xxx_device_open
Struct xxx_module_t HAL_MODULE_INFO_SYM={ Static int xxx_device_open(…){
common:{
tag:HARDWARE_MODULE_TAG, xxx_device_t *dev;
version_major:1, dev=(xxx_device_t *)malloc(sizeof(xxx_device_t));
version_minor:0,
id:xxx_HARDWARE_MODULD_ID, dev->common.module=<hw_module_t>(module);
name:”xxx module” Dev->close=xxx_close
author:”xxx”
methods :&xxx_module_medthods *device=&dev->device.common;
}
} }
Static struct hw_module_methods_t xxx_module_methods={
open:xxx_device_open
};
11

12. 참고. Android HAL 구조 분석(Framebuffer_open 분석)
2.framebuffer_open 분석
if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module) == 0)
{
err = framebuffer_open(module, &fbDev); struct private_module_t HAL_MODULE_INFO_SYM = {
} base: {
common: {
tag: HARDWARE_MODULE_TAG,
version_major: 1,
static inline int framebuffer_open(const struct hw_module_t*
version_minor: 0,
module,
id: GRALLOC_HARDWARE_MODULE_ID,
struct framebuffer_device_t** device) {
name: "Graphics Memory Allocator Module",
return module->methods->open(module,
author: "The Android Open Source Project",
GRALLOC_HARDWARE_FB0, (struct
methods: &gralloc_module_methods,
hw_device_t**)device);
dso: 0,
}
reserved: {0},
},
static struct hw_module_methods_t gralloc_module_methods = {
open: gralloc_device_open
};
int gralloc_device_open(const hw_module_t* module, const char* name,hw_device_t** device)
{
status = fb_device_open(module, name, device);
}
int fb_device_open(hw_module_t const* module, const char* name,hw_device_t** device){
fb_context_t *dev = (fb_context_t*)malloc(sizeof(*dev));
dev->device.common.module = const_cast<hw_module_t*>(module); dev->device.setSwapInterval = fb_setSwapInterval;
dev->device.common.close = fb_close; dev->device.post = fb_post;
12

13. 참고. Android HAL 구조 분석(Framebuffer_open 분석)
private_module_t fb_context_t
hw_module_t hw_device_t
Module
id GRALLOC_HARDWARE_MODULE_
ID close
methods 생성 fb_close
setSwapInterval fb_setSwapInterval
post fb_post
gralloc_module_methods
open gralloc_device_open dev->device.width;
dev->device.height;
dev->device.format
13