SurfaceFlinger启动过程分析

staticvoid android_server_SystemServer_init1(JNIEnv*
 env, jobject clazz)

{

    system_init();

}

if(strcmp(propBuf,"1")
== 0){

        // Start the SurfaceFlinger

        SurfaceFlinger::instantiate();

    }

int main(int argc,char**
 argv)

{

    sp<ProcessState> proc(ProcessState::self());

    sp<IServiceManager> sm= defaultServiceManager();

    LOGI("ServiceManager: %p", sm.get());

    SurfaceFlinger::instantiate();

    ProcessState::self()->startThreadPool();

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

}

void SurfaceFlinger::instantiate(){

    defaultServiceManager()->addService(

            String16("SurfaceFlinger"),new SurfaceFlinger());

}

service surfaceflinger /system/bin/surfaceflinger

    user root

    onrestart restart zygote

    disabled

setprop system_init.startsurfaceflinger 0

status_t SurfaceFlinger::readyToRun()

{

    LOGI( "SurfaceFlinger's main thread ready to run. "

            "Initializing graphics H/W...");

    // we only support one display currently

    int dpy = 0;

    {

        // initialize the main display

        GraphicPlane& plane(graphicPlane(dpy));

        DisplayHardware* const hw = new DisplayHardware(this, dpy);

        plane.setDisplayHardware(hw);

    }

    // create the shared control-block

    mServerHeap = 
new MemoryHeapBase(4096,

            MemoryHeapBase::READ_ONLY,
"SurfaceFlinger read-only heap");

    LOGE_IF(mServerHeap==0,
"can't create shared memory dealer");

    

    mServerCblk = 
static_cast<surface_flinger_cblk_t*>(mServerHeap->getBase());

    LOGE_IF(mServerCblk==0,
"can't get to shared control block's address");   

    new(mServerCblk) surface_flinger_cblk_t;

    // initialize primary screen

    // (other display should be initialized in the same manner, but

    // asynchronously, as they could come and go. None of this is supported

    // yet).

    const GraphicPlane& plane(graphicPlane(dpy));

    const DisplayHardware& hw
= plane.displayHardware();

    const uint32_t w
= hw.getWidth();

    const uint32_t h
= hw.getHeight();

    const uint32_t f
= hw.getFormat();

    hw.makeCurrent();

    // initialize the shared control block

    mServerCblk->connected
|= 1<<dpy;

    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;

    dcblk->xdpi
= hw.getDpiX();

    dcblk->ydpi
= hw.getDpiY();

    dcblk->fps
= hw.getRefreshRate();

    dcblk->density
= hw.getDensity();

    asm volatile
("":::"memory");

    // Initialize OpenGL|ES

    glActiveTexture(GL_TEXTURE0);

    glBindTexture(GL_TEXTURE_2D, 0);

    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

    glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);

    glPixelStorei(GL_PACK_ALIGNMENT, 4);

    glEnableClientState(GL_VERTEX_ARRAY);

    glEnable(GL_SCISSOR_TEST);

    glShadeModel(GL_FLAT);

    glDisable(GL_DITHER);

    glDisable(GL_CULL_FACE);

    const uint16_t g0
= pack565(0x0F,0x1F,0x0F);

    const uint16_t g1
= pack565(0x17,0x2f,0x17);

    const uint16_t textureData[4]
= { g0, g1, g1, g0
};

    glGenTextures(1,
&mWormholeTexName);

    glBindTexture(GL_TEXTURE_2D, mWormholeTexName);

    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);

    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 2, 2,
 0,

            GL_RGB, GL_UNSIGNED_SHORT_5_6_5, textureData);

    glViewport(0, 0, w, h);

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    glOrthof(0, w, h, 0, 0, 1);

   LayerDim::initDimmer(this, w, h);

    mReadyToRunBarrier.open();

    /*

     * We're now ready to accept clients...

     */

    // start boot animation

    property_set("ctl.start",
"bootanim");   

    return NO_ERROR;

}

DisplayHardware::DisplayHardware(

        const sp<SurfaceFlinger>& flinger,

        uint32_t dpy)

    : DisplayHardwareBase(flinger, dpy)

{

    init(dpy);

}

void DisplayHardware::init(uint32_t
 dpy)

{

    mNativeWindow = 
new FramebufferNativeWindow();

FramebufferNativeWindow::FramebufferNativeWindow()

    : BASE(), fbDev(0),
 grDev(0), mUpdateOnDemand(false)

{

    hw_module_t const* module;

    if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID,
&module) 
== 0)
{

        int stride;

        int err;

        err 
= framebuffer_open(module,
&fbDev);

        LOGE_IF(err,
"couldn't open framebuffer HAL (%s)",
strerror(-err));

        

        err 
= gralloc_open(module,
&grDev);

        LOGE_IF(err,
"couldn't open gralloc HAL (%s)",
strerror(-err));

        // bail out if we can't initialize the modules

        if (!fbDev
|| 
!grDev)

            return;        

        mUpdateOnDemand = 
(fbDev->setUpdateRect
!= 0);       

        // initialize the buffer FIFO

        mNumBuffers = 2;

        mNumFreeBuffers = 2;

        mBufferHead = mNumBuffers-1;

        buffers[0]
= new NativeBuffer(

                fbDev->width, fbDev->height, fbDev->format,
 GRALLOC_USAGE_HW_FB);

        buffers[1]
= new NativeBuffer(

                fbDev->width, fbDev->height, fbDev->format,
 GRALLOC_USAGE_HW_FB);

err = 
grDev->alloc(grDev,

                fbDev->width, fbDev->height, fbDev->format,

                GRALLOC_USAGE_HW_FB, 
&buffers[0]->handle,
&buffers[0]->stride);

        LOGE_IF(err,
"fb buffer 0 allocation failed w=%d, h=%d, err=%s",fbDev->width, fbDev->height,
strerror(-err));

        err = 
grDev->alloc(grDev,

                fbDev->width, fbDev->height, fbDev->format,

                GRALLOC_USAGE_HW_FB, 
&buffers[1]->handle,
&buffers[1]->stride);

        LOGE_IF(err,
"fb buffer 1 allocation failed w=%d, h=%d, err=%s",fbDev->width, fbDev->height,
strerror(-err));

...

    } else 
{

        LOGE("Couldn't get gralloc module");

    }

...

}

#define GRALLOC_HARDWARE_MODULE_ID "gralloc"

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);

}

static 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);

}

gralloc.h[hardware\libhardware\include\hardware]

#define GRALLOC_HARDWARE_FB0
"fb0"

#define GRALLOC_HARDWARE_GPU0
"gpu0"

gralloc.cpp[hardware\libhardware\modules\gralloc]

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)

{

    int status =
-EINVAL;

    if (!strcmp(name, GRALLOC_HARDWARE_GPU0))
{

        gralloc_context_t *dev;

        dev = (gralloc_context_t*)malloc(sizeof(*dev));

        /* initialize our state here */

        memset(dev, 0,
sizeof(*dev));

        /* initialize the procs */

        dev->device.common.tag
= HARDWARE_DEVICE_TAG;

        dev->device.common.version
= 0;

        dev->device.common.module
= const_cast<hw_module_t*>(module);

        dev->device.common.close
= gralloc_close;

        dev->device.alloc
= gralloc_alloc;

        dev->device.free
= gralloc_free;

        *device =
&dev->device.common;

        status = 0;

    } else 
{

        status = fb_device_open(module, name, device);

    }

    return status;

}

int fb_device_open(hw_module_t
const* module,
const char* name,        hw_device_t** device){    int status =
-EINVAL;    if (!strcmp(name, GRALLOC_HARDWARE_FB0))
{        alloc_device_t* gralloc_device;        status = 
gralloc_open(module,
&gralloc_device);        if (status
< 0)            return status;        /* initialize our state here */        fb_context_t *dev 
= (fb_context_t*)malloc(sizeof(*dev));        memset(dev, 0,
sizeof(*dev));        /* initialize the procs */        dev->device.common.tag
= HARDWARE_DEVICE_TAG;        dev->device.common.version
= 0;        dev->device.common.module
= const_cast<hw_module_t*>(module);        dev->device.common.close
= fb_close;        dev->device.setSwapInterval
= fb_setSwapInterval;        dev->device.post
= fb_post;        dev->device.setUpdateRect
= 0;        private_module_t* m 
= (private_module_t*)module;        status = 
mapFrameBuffer(m);        if (status
>= 0)
{         ...            *device 
= &dev->device.common;        }    }    return status;}

alloc_device_t* gralloc_device;

status = gralloc_open(module, &gralloc_device);

if (status < 0)

   return status;

int mapFrameBufferLocked(struct private_module_t*
 module)

{

    // already initialized...

    if (module->framebuffer)
{

        return 0;

    }        

    char const
* const device_template[]
= {

            "/dev/graphics/fb%u",

            "/dev/fb%u",

            0 };

    int fd =
-1;

    int i=0;

    char name[64];

    while ((fd==-1)
&& device_template[i])
{

        snprintf(name, 64, device_template[i],
 0);

        fd 
= open(name, O_RDWR, 0);

        i++;

    }

    if (fd 
< 0)

        return -errno;

    struct fb_fix_screeninfo finfo;

    if (ioctl(fd, FBIOGET_FSCREENINFO,
&finfo)
== 
-1)

        return -errno;

    struct fb_var_screeninfo info;

    if (ioctl(fd, FBIOGET_VSCREENINFO,
&info)
== 
-1)

        return -errno;

    info.reserved[0]
= 0;

    info.reserved[1]
= 0;

    info.reserved[2]
= 0;

    info.xoffset = 0;

    info.yoffset = 0;

    info.activate 
= FB_ACTIVATE_NOW;

    /*

     * Explicitly request 5/6/5

     */

    info.bits_per_pixel 
= 16;

    info.red.offset
= 11;

    info.red.length
= 5;

    info.green.offset
= 5;

    info.green.length
= 6;

    info.blue.offset
= 0;

    info.blue.length
= 5;

    info.transp.offset
= 0;

    info.transp.length
= 0;

    /*

     * Request NUM_BUFFERS screens (at lest 2 for page flipping)

     */

    info.yres_virtual 
= info.yres 
* NUM_BUFFERS;

    uint32_t flags 
= PAGE_FLIP;

    if (ioctl(fd, FBIOPUT_VSCREENINFO,
&info)
== 
-1) {

        info.yres_virtual 
= info.yres;

        flags &=
~PAGE_FLIP;

        LOGW("FBIOPUT_VSCREENINFO failed, page flipping not supported");

    }

    if (info.yres_virtual
< info.yres
* 2) 
{

        // we need at least 2 for page-flipping

        info.yres_virtual 
= info.yres;

        flags &=
~PAGE_FLIP;

        LOGW("page flipping not supported (yres_virtual=%d, requested=%d)",

                info.yres_virtual, info.yres*2);

    }

    if (ioctl(fd, FBIOGET_VSCREENINFO,
&info)
== 
-1)

        return -errno;

    int refreshRate 
= 1000000000000000LLU /

    (

            uint64_t( info.upper_margin
+ info.lower_margin
+ info.yres
)

            * ( info.left_margin
+ info.right_margin
+ info.xres
)

            * info.pixclock

    );

    if (refreshRate
== 0)
{

        // bleagh, bad info from the driver

        refreshRate = 60*1000;
// 60 Hz

    }

    if (int(info.width)
<= 0 
|| int(info.height)
<= 0)
{

        // the driver doesn't return that information

        // default to 160 dpi

        info.width 
= ((info.xres
* 25.4f)/160.0f
+ 0.5f);

        info.height 
= ((info.yres
* 25.4f)/160.0f
+ 0.5f);

    }

    float xdpi =
(info.xres 
* 25.4f)
/ info.width;

    float ydpi =
(info.yres 
* 25.4f)
/ info.height;

    float fps = refreshRate
/ 1000.0f;

    LOGI( "using (fd=%d)\n"

            "id = %s\n"

            "xres = %d px\n"

            "yres = %d px\n"

            "xres_virtual = %d px\n"

            "yres_virtual = %d px\n"

            "bpp = %d\n"

            "r = %2u:%u\n"

            "g = %2u:%u\n"

            "b = %2u:%u\n",

            fd,

            finfo.id,

            info.xres,

            info.yres,

            info.xres_virtual,

            info.yres_virtual,

            info.bits_per_pixel,

            info.red.offset, info.red.length,

            info.green.offset, info.green.length,

            info.blue.offset, info.blue.length

    );

    LOGI( "width = %d mm (%f dpi)\n"

            "height = %d mm (%f dpi)\n"

            "refresh rate = %.2f Hz\n",

            info.width, xdpi,

            info.height, ydpi,

            fps

    );

    if (ioctl(fd, FBIOGET_FSCREENINFO,
&finfo)
== 
-1)

        return -errno;

    if (finfo.smem_len
<= 0)

        return -errno;

    module->flags
= flags;

    module->info
= info;

    module->finfo
= finfo;

    module->xdpi
= xdpi;

    module->ydpi
= ydpi;

    module->fps
= fps;

    /*

     * map the framebuffer

     */

    int err;

    size_t fbSize 
= roundUpToPageSize(finfo.line_length
* info.yres_virtual);//对齐页

    module->framebuffer
= new private_handle_t(dup(fd), fbSize,
 0);

    module->numBuffers
= info.yres_virtual
/ info.yres;

    module->bufferMask
= 0;

    void* vaddr
= 
mmap(0, fbSize, PROT_READ|PROT_WRITE, MAP_SHARED,
 fd, 0);

    if (vaddr
== MAP_FAILED)
{

        LOGE("Error mapping the framebuffer (%s)",
strerror(errno));

        return -errno;

    }

    module->framebuffer->base
= intptr_t(vaddr);

    memset(vaddr, 0, fbSize);

    return 0;

}

I/gralloc
( 1620): using
(fd=8)

I/gralloc ( 1620): id
= truly-ILI9327

I/gralloc ( 1620): xres
= 240 px 

I/gralloc ( 1620): yres
= 400 px 

I/gralloc ( 1620): xres_virtual
= 240 px 

I/gralloc ( 1620): yres_virtual
= 800 px 

I/gralloc ( 1620): bpp
= 16 

I/gralloc ( 1620): r
= 11:5 

I/gralloc ( 1620): g
= 5:6 

I/gralloc ( 1620): b
= 0:5 

I/gralloc ( 1620):
width = 38 mm
(160.421051 dpi)

I/gralloc ( 1620): height
= 64 mm (158.750000 dpi)

I/gralloc ( 1620): refresh rate
= 60.00 Hz

mNativeWindow
= new FramebufferNativeWindow();

buffers[0]
= 
new NativeBuffer(

                fbDev->width, fbDev->height, fbDev->format,
 GRALLOC_USAGE_HW_FB);

buffers[1] 
= new NativeBuffer(

                fbDev->width, fbDev->height, fbDev->format,
 GRALLOC_USAGE_HW_FB);

        

        err = 
grDev->alloc(grDev,

                fbDev->width, fbDev->height, fbDev->format,

                GRALLOC_USAGE_HW_FB, 
&buffers[0]->handle,
&buffers[0]->stride);

        LOGE_IF(err,
"fb buffer 0 allocation failed w=%d, h=%d, err=%s", fbDev->width, fbDev->height,
strerror(-err));

        err = 
grDev->alloc(grDev,

                fbDev->width, fbDev->height, fbDev->format,

                GRALLOC_USAGE_HW_FB, 
&buffers[1]->handle,
&buffers[1]->stride);

        LOGE_IF(err,
"fb buffer 1 allocation failed w=%d, h=%d, err=%s",fbDev->width, fbDev->height,
strerror(-err));

dev->device.alloc
= gralloc_alloc;

if
(hw_get_module(OVERLAY_HARDWARE_MODULE_ID,
&module)
== 0)
{

        overlay_control_open(module,
&mOverlayEngine);

    }

// initialize EGL

...

EGLDisplay display
= 
eglGetDisplay(EGL_DEFAULT_DISPLAY);

    eglInitialize(display,
NULL, 
NULL);

    eglGetConfigs(display,
NULL, 0,
&numConfigs);

    EGLConfig config;

    status_t err = EGLUtils::selectConfigForNativeWindow(

            display, attribs, mNativeWindow.get(),
&config);

EGLDisplay
eglGetDisplay(NativeDisplayType display)

{

    uint32_t index 
= uint32_t(display);

    if (index
>= NUM_DISPLAYS)
{

        return setError(EGL_BAD_PARAMETER, EGL_NO_DISPLAY);

    }

    if (egl_init_drivers()
== EGL_FALSE)
{

        return setError(EGL_BAD_PARAMETER, EGL_NO_DISPLAY);

    }   

    EGLDisplay dpy = EGLDisplay(uintptr_t(display)
+ 1LU);

    return dpy;

}

EGLBoolean egl_init_drivers_locked(){    if (sEarlyInitState)
{        // initialized by static ctor. should be set here.        return EGL_FALSE;    }    // get our driver loader    Loader& loader(Loader::getInstance());cnx = &gEGLImpl[IMPL_SOFTWARE];    if (cnx->dso
== 0)
{cnx->hooks[GLESv1_INDEX]
= &gHooks[GLESv1_INDEX][IMPL_SOFTWARE];cnx->hooks[GLESv2_INDEX]
= &gHooks[GLESv2_INDEX][IMPL_SOFTWARE]; cnx->dso 
= loader.open(EGL_DEFAULT_DISPLAY, 0,
 cnx);        if (cnx->dso)
{            EGLDisplay dpy = cnx->egl.eglGetDisplay(EGL_DEFAULT_DISPLAY);            LOGE_IF(dpy==EGL_NO_DISPLAY,
"No EGLDisplay for software EGL!");            d->disp[IMPL_SOFTWARE].dpy
= dpy;             if (dpy
== EGL_NO_DISPLAY)
{                loader.close(cnx->dso);                cnx->dso
= NULL;            }        }    }    cnx = &gEGLImpl[IMPL_HARDWARE];    if (cnx->dso
== 0)
{     ...        } else
{            LOGD("3D hardware acceleration is disabled");        }    }    return EGL_TRUE;}

cnx->hooks[GLESv1_INDEX] = &gHooks[GLESv1_INDEX][IMPL_SOFTWARE];

cnx->hooks[GLESv2_INDEX] = &gHooks[GLESv2_INDEX][IMPL_SOFTWARE]；

Loader::Loader(){    char line[256];    char tag[256];    FILE* cfg
= fopen("/system/lib/egl/egl.cfg",
"r");    if (cfg
== 
NULL) {        // default config        LOGD("egl.cfg not found, using default config");        gConfig.add( entry_t(0, 0,
"android") 
);    } else 
{        while (fgets(line, 256,
 cfg)) 
{            int dpy;            int impl;            if (sscanf(line,
"%u %u %s",
&dpy, 
&impl, tag)
== 3)
{                //LOGD(">>> %u %u %s", dpy, impl, tag);                gConfig.add( entry_t(dpy, impl, tag)
);            }        }        fclose(cfg);    }}

void* Loader::open(EGLNativeDisplayType
 display, int impl, egl_connection_t* cnx){    /*     * TODO: if we don't find display/0, then use 0/0     * (0/0 should always work)     */       void* dso;    char path[PATH_MAX];    int index =
int(display);    driver_t* hnd 
= 0;    const char*
const format =
"/system/lib/egl/lib%s_%s.so";       char const* tag
= getTag(index, impl);    if (tag)
{        snprintf(path, PATH_MAX, format,
"GLES", tag);        dso = 
load_driver(path, cnx, EGL
| GLESv1_CM | GLESv2);        if (dso)
{            hnd = 
new driver_t(dso);        } else
{            // Always load EGL first            snprintf(path, PATH_MAX, format,
"EGL", tag);            dso = load_driver(path, cnx, EGL);            if (dso)
{                hnd = 
new driver_t(dso);                // TODO: make this more automated                snprintf(path, PATH_MAX, format,
"GLESv1_CM", tag);                hnd->set( load_driver(path, cnx,
 GLESv1_CM), GLESv1_CM
);                snprintf(path, PATH_MAX, format,
"GLESv2", tag);                hnd->set( load_driver(path, cnx,
 GLESv2), GLESv2
);            }        }    }    LOG_FATAL_IF(!index
&& 
!impl &&
!hnd,             "couldn't find the default OpenGL ES implementation "            "for default display");        return (void*)hnd;}

struct entry_t
{        entry_t()
{ }        entry_t(int dpy,
int impl, 
const char* tag);        int dpy;        int impl;        String8 tag;};

const
char* Loader::getTag(int dpy,
int impl){    const Vector<entry_t>& cfgs(gConfig);    const size_t c
= cfgs.size();    for (size_t i=0
; i<c 
; i++)
{        if (dpy
== cfgs[i].dpy)            if (impl
== cfgs[i].impl)                return cfgs[i].tag.string();    }    return 0;}

void
*Loader::load_driver(const
char* driver_absolute_path,        egl_connection_t* cnx,
uint32_t mask){    if (access(driver_absolute_path, R_OK))
{        // this happens often, we don't want to log an error        return 0;    }//加载libGLES_android.sovoid* dso 
= dlopen(driver_absolute_path, RTLD_NOW
| RTLD_LOCAL);    if (dso
== 0)
{        const char* err
= dlerror();        LOGE("load_driver(%s): %s", driver_absolute_path, err?err:"unknown");        return 0;    }    LOGD("loaded %s", driver_absolute_path);    if (mask
& EGL) 
{//加载EGL函数库        getProcAddress = 
(getProcAddressType)dlsym(dso,
"eglGetProcAddress");        LOGE_IF(!getProcAddress,                "can't find eglGetProcAddress() in %s", driver_absolute_path);        egl_t* egl 
= &cnx->egl;//把函数赋值到cnx->egl中        __eglMustCastToProperFunctionPointerType* curr
=            (__eglMustCastToProperFunctionPointerType*)egl;        char const
* const 
* api = egl_names;        while (*api)
{            char const
* name = 
*api;            __eglMustCastToProperFunctionPointerType f 
=                 (__eglMustCastToProperFunctionPointerType)dlsym(dso, name);            if (f
== 
NULL) {                // couldn't find the entry-point, use eglGetProcAddress()                f = getProcAddress(name);                if 
(f ==
NULL) 
{                    f = 
(__eglMustCastToProperFunctionPointerType)0;                }            }            *curr++
= f;            api++;        }    }    if (mask
& GLESv1_CM)
{//加载GLESv1_CM函数库        init_api(dso, gl_names,            (__eglMustCastToProperFunctionPointerType*)                &cnx->hooks[GLESv1_INDEX]->gl,            getProcAddress);    }    if (mask
& GLESv2) 
{//加载GLESv2函数库      init_api(dso, gl_names,            (__eglMustCastToProperFunctionPointerType*)                &cnx->hooks[GLESv2_INDEX]->gl,            getProcAddress);    }    return dso;}

dlopen（）　　功能：打开一个动态链接库 　　包含头文件： 　　#include <dlfcn.h> 　　函数定义： 　　void * dlopen( const char * pathname, int mode ); 　　函数描述： 　　在dlopen的（）函数以指定模式打开指定的动态连接库文件，并返回一个句柄给调用进程。使用dlclose（）来卸载打开的库。

dlsym()的函数原型是 　　void* dlsym(void* handle,const char* symbol) 　　该函数在<dlfcn.h>文件中。 　　handle是由dlopen打开动态链接库后返回的指针，symbol就是要求获取的函数的名称，函数返回值是void*,指向函数的地址，供调用使用。