Glib事件源

GLib 实现了一个功能强大的事件循环分发处理机制，GLib 内部实现了三种类型的事件源，分别是 Timeout, Idle, Child Watch。

同时也支持创建自定义的事件源——也就是添加child watch

李先静老师的FTK就是仿照glib的事件源来实现的

1. Timeout事件源

//mainloop1.c

#include<glib.h> 
GMainLoop* loop;

gint counter = 10;
gboolean callback(gpointer arg)
{
    g_print(".");
    if(--counter ==0){
        g_print("\n");
        //退出循环
        g_main_loop_quit(loop);
        //注销定时器
        return FALSE;
    }
    //定时器继续运行
    return TRUE;
}

int main(int argc, char* argv[])
{
    if(g_thread_supported() == 0)
        g_thread_init(NULL);
    g_print("g_main_loop_new\n");
    loop = g_main_loop_new(NULL, FALSE);
    //增加一个定时器，100毫秒运行一次callback
    g_timeout_add(100,callback,NULL);
    g_print("g_main_loop_run\n");
    g_main_loop_run(loop);
    g_print("g_main_loop_unref\n");
    g_main_loop_unref(loop);
    return 0;
}

编译运行:
gcc -g `pkg-config --cflags --libs glib-2.0 gthread-2.0` mainloop1.c -o mainloop1

 

2. Idle事件源

已经在另一篇博客中介绍了

 

3. Child Watch——系统定义的事件源

#include <glib.h>    
#include <stdio.h>    
#include <strings.h>    
GMainLoop* loop;    
//当stdin有数据可读时被GSource调用的回调函数    
gboolean callback(GIOChannel *channel)    
{    
    gchar* str;    
    gsize len;    
    //从stdin读取一行字符串    
    g_io_channel_read_line(channel, &str, &len, NULL, NULL);    
    //去掉回车键()    
    while(len > 0 && (str[len-1] == '\r' || str[len-1] == '\n'))    
        str[--len]='\0';    
    //反转字符串    
    for(;len;len--)    
        g_print("%c",str[len-1]);    
    g_print("\n");    
    //判断结束符    
    if(strcasecmp(str, "q") == 0){    
        g_main_loop_quit(loop);    
    }    
    g_free(str);    
}    
void add_source(GMainContext *context)    
{    
    GIOChannel* channel;    
    GSource* source;    
    //这里我们监视stdin是否可读， stdin的fd默认等于1    
    channel = g_io_channel_unix_new(1);    
    //g_io_create_watch创建一个默认的io监视作用的GSource，下次再研究自定义GSource。参数G_IO_IN表示监视stdin的读取状态。   
    source = g_io_create_watch(channel, G_IO_IN);    
    g_io_channel_unref(channel);    
    //设置stdin可读的时候调用的回调函数    
    g_source_set_callback(source, (GSourceFunc)callback, channel, NULL);    
    //把GSource附加到GMainContext    
    g_source_attach(source, context);    
    g_source_unref(source);    
}    
int main(int argc, char* argv[])    
{    
    GMainContext *context;    
    if(g_thread_supported() == 0)    
        g_thread_init(NULL);    
    //新建一个GMainContext    
    context = g_main_context_new();    
    //然后把GSource附到这个Context上    
    add_source(context);    
    //把Context赋给GMainLoop    
    loop = g_main_loop_new(context, FALSE);    
    g_print("input string('q' to quit)\n");    
    g_main_loop_run(loop);    
    g_main_loop_unref(loop);    
    //Context用完计数器减1    
    g_main_context_unref(context);    
    return 0;    
}

 

4. Child Watch——自定义事件源

GSource * g_source_new(GSourceFuncs * source_funcs, guint struct_size);

这个函数用于创建一个自定义事件源，新的事件源可以使用 g_source_attach() 函数加入到主循环上下文中。
source_funcs : 包含用于实现事件行为的函数的结构
struct_size : 创建的 GSource 结构大小，不能小于 sizeof(GSource)
返回值 : 返回新创建的 GSource

创建一个新的事件源包含用于实现事件行为的函数的结构体。
prepare : 设置检查事件时间超时。如果返回 TRUE, check 会立刻被调用；如果返回 FALSE 并设置了 timeout ， timeout 时间后 check 会被调用。
check ： 检查事件是否准备完毕。返回 TRUE 为准备完毕， dispatch 会被立刻调用；返回 FALSE 不调用 dispatch，进入下一次事件循环。
dispatch : 分发事件。返回 TRUE 将继续下一次操作循环；返回 FALSE 中止本事件源的事件循环。
finalize : 当事件源被移除时被调用。

#include <glib.h>

gboolean source_prepare_cb(GSource * source,
            gint * timeout)
{
    g_printf("prepare\n");
    *timeout = 1000;
    return FALSE;
}

gboolean source_check_cb(GSource * source)
{
    g_printf("check\n");
    return TRUE;
}

gboolean source_dispatch_cb(GSource * source,
            GSourceFunc callback, gpointer data)
{
    g_printf("dispatch\n");
    return TRUE;
}

void source_finalize_cb(GSource * source)
{
    g_printf("finalize\n");
}

int main(int argc, char * argv[])
{
    GMainLoop * mainloop;
    GMainContext * maincontext;
    GSource * source;
    GSourceFuncs sourcefuncs;

    sourcefuncs.prepare = source_prepare_cb;
    sourcefuncs.check = source_check_cb;
    sourcefuncs.dispatch = source_dispatch_cb;
    sourcefuncs.finalize = source_finalize_cb;

    mainloop = g_main_loop_new(NULL, FALSE);
    maincontext = g_main_loop_get_context(mainloop);
    source = g_source_new(&sourcefuncs, sizeof(GSource));
    g_source_attach(source, maincontext);

    g_main_loop_run(mainloop);

    return 0;
}

注意prepare 中会返回一个超时时间