Merge lp:~mimose/kydevmonit/test into lp:kydevmonit

[guoyalong]

[guoyalong (mimose)]

review: Approve

=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2017-10-10 00:58:46 +0000
@@ -0,0 +1,10 @@
+kydevmonit
+debian/debhelper-build-stamp
+debian/files
+debian/kydevmonit
+debian/kydevmonit.debhelper.log
+debian/kydevmonit.substvars
+debian/kydevmonit/DEBIAN
+debian/kydevmonit/etc
+debian/kydevmonit/lib
+debian/kydevmonit/usr
 
=== modified file 'Makefile'
--- Makefile	2017-09-05 05:53:02 +0000
+++ Makefile	2017-10-10 00:58:46 +0000
@@ -1,24 +1,30 @@
 all=kydevmonit
 CC=gcc
 
-INTERLAYER_DIR=./src/interlayer/
+MANAGER_LAYER_DIR=./src/managerlayer/
 DBUSLAYER_DIR=./src/dbuslayer/
 
-INCLUDE=-I$(INTERLAYER_DIR) -I$(DBUSLAYER_DIR) -I/usr/include/libxml2/ `pkg-config --cflags glib-2.0 gobject-2.0 dbus-glib-1 dbus-1` 
-LIBS=`pkg-config --libs glib-2.0 gobject-2.0 dbus-glib-1 dbus-1`  -lxml2 -ldl
-
-SRCS=./src/main.c $(DBUSLAYER_DIR)monitor_dbus.c $(DBUSLAYER_DIR)marshal.c $(INTERLAYER_DIR)interlayer.c
+MY_CFLAGS= $(CFLAGS) -I$(MANAGER_LAYER_DIR) -I$(DBUSLAYER_DIR) -I/usr/include/libxml2/ `pkg-config --cflags glib-2.0 gobject-2.0 dbus-glib-1 dbus-1` 
+MY_LDFLAGS=$(LDFLAGS) `pkg-config --libs glib-2.0 gobject-2.0 dbus-glib-1 dbus-1`  -lxml2 -ldl
+
+SRCS=./src/main.c $(DBUSLAYER_DIR)monitor_dbus.c $(DBUSLAYER_DIR)marshal.c $(MANAGER_LAYER_DIR)manager.c $(MANAGER_LAYER_DIR)_configure.c
+
 OBJS=$(SRCS:.c=.o)
-
 kydevmonit:$(OBJS)
-	$(CC) -g -O0 -o $@ $^ $(INCLUDE) $(LIBS)
+	$(CC) -g -O0 -o $@ $^ $(MY_CFLAGS) $(MY_LDFLAGS)
+
+monitor_dbus_glue.h:$(DBUSLAYER_DIR)com.jd.test.xml
+	dbus-binding-tool --prefix=monitor --mode=glib-server --output=$(DBUSLAYER_DIR)monitor_dbus_glue.h $^
+
 install:
-	install kydevmonit /usr/bin/
-	cp kydevmonit.service /lib/systemd/system/
-	cp com.jd.test.conf /etc/dbus-1/system.d/
-	systemctl daemon-reload
+	install -d -m755 $(DESTDIR)/usr/bin/
+	install -m755 ./kydevmonit $(DESTDIR)/usr/bin/
+	install -d -m755 $(DESTDIR)/lib/systemd/system/
+	install -m644 ./kydevmonit.service $(DESTDIR)/lib/systemd/system/
+	install -d -m755 $(DESTDIR)/etc/dbus-1/system.d/
+	install -m644 ./com.jd.test.conf $(DESTDIR)/etc/dbus-1/system.d/
 clean:
 	rm -rf $(OBJS) kydevmonit 
 
 %.o:%.c
-	$(CC) $(INCLUDE) -o $@ -c $<
+	$(CC) $(MY_CFLAGS) -o $@ -c $<
 
=== removed file 'com.jd.test.xml'
--- com.jd.test.xml	2017-09-05 05:53:02 +0000
+++ com.jd.test.xml	1970-01-01 00:00:00 +0000
@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" ?>
-<node name="/com/jd/test">
-  <interface name="com.jd.test.interface">
-    <method name="call_monitor_method">
-      <annotation name="org.freedesktop.DBus.GLib.Async" value="" />
-      <arg type="(iiiis)" name="hw_method_t" direction="in" />
-      <arg type="(iis)" name="hw_return_t" direction="out" />
-    </method>
-    <method name="intropect">
-      <annotation name="org.freedesktop.DBus.GLib.Async" value="" />
-      <arg type="s" name="name" direction="in"/> 
-      <arg type="s" name="data" direction="out"/> 
-    </method>
-  </interface>
-</node>
 
=== added directory 'debian'
=== added file 'debian/changelog'
--- debian/changelog	1970-01-01 00:00:00 +0000
+++ debian/changelog	2017-10-10 00:58:46 +0000
@@ -0,0 +1,5 @@
+kydevmonit (1.0.0kord1) juniper; urgency=medium
+
+  * Initial release.
+
+ -- guoyalong <[e-mail]>  Mon, 25 Sep 2017 11:30:12 +0800
 
=== added file 'debian/compat'
--- debian/compat	1970-01-01 00:00:00 +0000
+++ debian/compat	2017-10-10 00:58:46 +0000
@@ -0,0 +1,1 @@
+9
 
=== added file 'debian/control'
--- debian/control	1970-01-01 00:00:00 +0000
+++ debian/control	2017-10-10 00:58:46 +0000
@@ -0,0 +1,15 @@
+Source: kydevmonit
+Section: x11
+Priority: optional
+Maintainer: Ubuntu Kylin Team <[e-mail]>
+Build-Depends: debhelper(>= 9),
+			   libxml2-dev,
+			   libdbus-glib-1-dev,
+			   libglib2.0-dev				
+Standards-Version: 3.9.8
+Homepage: https://launchpad.net/kydevmonit
+
+Package: kydevmonit
+Architecture: any
+Depends: ${shlibs:Depends}, ${misc:Depends}
+Description: This is a devices manager based on dbus. 
 
=== added file 'debian/copyright'
--- debian/copyright	1970-01-01 00:00:00 +0000
+++ debian/copyright	2017-10-10 00:58:46 +0000
@@ -0,0 +1,1 @@
+
 
=== added file 'debian/rules'
--- debian/rules	1970-01-01 00:00:00 +0000
+++ debian/rules	2017-10-10 00:58:46 +0000
@@ -0,0 +1,8 @@
+#!/usr/bin/make -f
+# debian/rules for kydevmonit
+##
+##  Build-tree preparation
+##
+%:
+	dh $@
+
 
=== added directory 'debian/source'
=== added file 'debian/source/format'
--- debian/source/format	1970-01-01 00:00:00 +0000
+++ debian/source/format	2017-10-10 00:58:46 +0000
@@ -0,0 +1,1 @@
+3.0 (native)
 
=== added file 'src/dbuslayer/com.jd.test.xml'
--- src/dbuslayer/com.jd.test.xml	1970-01-01 00:00:00 +0000
+++ src/dbuslayer/com.jd.test.xml	2017-10-10 00:58:46 +0000
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<node name="/com/jd/test">
+  <interface name="com.jd.test.interface">
+    <method name="dbus_get_all_device_static_info">
+      <annotation name="org.freedesktop.DBus.GLib.Async" value="" />
+      <arg type="a(isi)" name="devices_static_return_t" direction="out"/>
+    </method>
+    <method name="dbus_get_device_interfaces_info">
+      <annotation name="org.freedesktop.DBus.GLib.Async" value="" />
+      <arg type="i" name="device_code" direction="in"/>
+      <arg type="isaav" name="device_interfaces_return_t" direction="out"/>
+    </method>
+    <method name="dbus_call_device_method">
+      <annotation name="org.freedesktop.DBus.GLib.Async" value="" />
+      <arg type="(iiiis)" name="device_method_input_t" direction="in" />
+      <arg type="(iis)" name="dbus_return_t" direction="out" />
+    </method>
+    <method name="dbus_regist_new_device">
+      <annotation name="org.freedesktop.DBus.GLib.Async" value="" />
+      <arg type="i" name="device_code" direction="in"/>
+      <arg type="(iis)" name="dbus_return_t" direction="out"/>
+    </method>
+    <method name="dbus_logout_device">
+      <annotation name="org.freedesktop.DBus.GLib.Async" value="" />
+      <arg type="i" name="device_code" direction="in"/>
+      <arg type="(iis)" name="dbus_return_t" direction="out"/>
+    </method>
+  </interface>
+</node>
 
=== modified file 'src/dbuslayer/monitor_dbus.c'
--- src/dbuslayer/monitor_dbus.c	2017-09-05 05:53:02 +0000
+++ src/dbuslayer/monitor_dbus.c	2017-10-10 00:58:46 +0000
@@ -32,7 +32,7 @@
 #include <malloc.h>
 #include <unistd.h>
 
-#include "../interlayer/interlayer.h"
+#include "../managerlayer/manager.h"
 
 static GMainLoop *loop = NULL;
 MonitorDbus * dbus;
@@ -63,75 +63,167 @@
 void monitor_dbus_class_init(MonitorDbusClass * kclass)
 {
     mnsignals[SIG_DATA_ALERT] = g_signal_new("monitor_alert",
-                                           G_TYPE_FROM_CLASS(kclass),
-                                           G_SIGNAL_RUN_FIRST,
-                                           G_STRUCT_OFFSET(MonitorWarnDbusClass, event),
-                                           NULL,
-                                           NULL,
-                                           monitor_marshal_VOID__UINT_BOXED,
-                                           G_TYPE_NONE,
-                                           3,
-                                           G_TYPE_UINT,
-                                           G_TYPE_UINT,
-                       G_TYPE_UINT);
-}
-
-
+	    G_TYPE_FROM_CLASS(kclass),
+	    G_SIGNAL_RUN_FIRST,
+	    G_STRUCT_OFFSET(MonitorWarnDbusClass, event),
+	    NULL,
+	    NULL,
+	    monitor_marshal_VOID__UINT_BOXED,
+	    G_TYPE_NONE,
+	    3,
+	    G_TYPE_UINT,
+	    G_TYPE_UINT,
+	    G_TYPE_UINT);
+}
+
+gint monitor_dbus_get_all_device_static_info(MonitorDbus * dbus, DBusGMethodInvocation * ret_value){
+	GList* value_list_ptr = manager_get_all_device_static_t();
+	guint len = g_list_length(value_list_ptr);
+	GArray * array_return = g_array_new(FALSE,TRUE,sizeof(GValueArray));
+	printf("len=%u\n",len);	
+	int i;
+	for(i=0; i<len;i++){
+		manager_device_static_t* ds = (manager_device_static_t*)g_list_nth_data(value_list_ptr,i);
+		GValueArray* static_struct = g_value_array_new(0);
+		GValue device_code={0};
+		GValue device_name={0};
+		GValue is_registed={0};
+		g_value_init (&device_code, G_TYPE_INT);
+		g_value_init (&device_name, G_TYPE_STRING);
+		g_value_init (&is_registed, G_TYPE_INT);
+		g_value_set_int(&device_code, ds->device_code);
+		g_value_set_string(&device_name, ds->device_name);
+		g_value_set_int(&is_registed, ds->is_registed);
+		static_struct = g_value_array_append(static_struct,&device_code);	
+		static_struct = g_value_array_append(static_struct,&device_name);	
+		static_struct = g_value_array_append(static_struct,&is_registed);
+		array_return = g_array_append_val(array_return,static_struct);		
+		printf("0x%.2x  %s  %d successfully\n",ds->device_code,ds->device_name,ds->is_registed);
+	}
+    	dbus_g_method_return(ret_value,array_return);
+	return 1;	
+}
+gint monitor_dbus_get_device_interfaces_info(MonitorDbus * dbus, int device_code, DBusGMethodInvocation * ret_value){
+
+}
 
 //客户端-监控统一入口
-gint monitor_dbus_call_monitor_method(MonitorDbus * dbus,GValueArray * method_value ,DBusGMethodInvocation * ret_value)
+gint monitor_dbus_call_device_method(MonitorDbus * dbus,GValueArray * method_value ,DBusGMethodInvocation * ret_value)
 {
     GValue * input[5] = {{0}};
-    for(int i =0; i < 5;i++){
-        input[i] = g_value_array_get_nth(method_value, i);
-    }
-    gint value1 = g_value_get_int(input[0]);
-    gint value2 = g_value_get_int(input[1]);
-    gint value3 = g_value_get_int(input[2]);
-    gint value4 = g_value_get_int(input[3]);
-    gchar * value5 = g_value_dup_string(input[4]);
-    printf("input value1: %d\n", value1);
-    printf("input value2: %d\n", value2);
-    printf("input value3: %d\n", value3);
-    printf("input value4: %d\n", value4);
-    printf("input value5: %s\n", value5);
-    
-
-    gint statuscode = -1;
-    gint count = -1;
-    gchar statusdesc[1024] = {0};
-
-    interlayer_call_device_method(value1, value2,value5, &statuscode,&count,statusdesc); 
-
-    GValueArray *struct_return;
-    GValue struct_container[3] = {{0}};
-    
-    g_value_init (&struct_container[0], G_TYPE_INT);
-    g_value_set_int (&struct_container[0], statuscode);
-    g_value_init (&struct_container[1], G_TYPE_INT);
-    g_value_set_int (&struct_container[1], count);
-    g_value_init (&struct_container[2], G_TYPE_STRING);
-    g_value_set_string (&struct_container[2], statusdesc);
-
-    struct_return = g_value_array_new(0);
-    for(int j =0; j <3; j++){
-        struct_return = g_value_array_append(struct_return, &struct_container[j]);
-    }
-
-	dbus_g_method_return(ret_value,struct_return);	
-	return 1;
-}
-gint monitor_dbus_intropect(MonitorDbus* dbus, const char* devicename,DBusGMethodInvocation * ret_value){
-    //char* message = "hello";
-    //GValue data = g_value_set_string("hello");
-    //printf("devicename= %s\n", devicename);
-    char desc[1024];
-    memset(desc, 0, 1024);
-    interlayer_get_devices_intropect(LISTEN_DBUS_NAME, LISTEN_DBUS_PATH, devicename,desc); 
-    printf("Desc: %s\n", desc);
-    dbus_g_method_return(ret_value, desc);
-    return 0;
-}
+    dbus_return_t rt={0,0,{0}};// state_code ; exception_code; exception_desc;
+
+    guint size = 5;//g_array_get_element_size(method_value);
+    if(size < 5){
+	rt.state_code = WORK_STATE_UNKNOW;
+	rt.exception_code = 0x30000;
+	snprintf(rt.desc,DESC_BUF_LEN,"The method_value at least 5 elements!\n");
+    }else{
+	if(method_value == NULL){
+	    printf("method_value is null\n");
+	}
+	/*
+	gint device_code = g_array_index(method_value,int,0);
+	gint method_code = g_array_index(method_value, int,1);
+	gint value3 = g_array_index(method_value, int,2);
+	gint value4 = g_array_index(method_value, int,3);
+	gchar* method_param = g_array_index(method_value,char*,4);
+	*/
+	int i;	
+	for(i =0; i < size;i++){
+	    input[i] = g_value_array_get_nth(method_value, i);
+	}
+	gint device_code = g_value_get_int(input[0]);
+	gint method_code = g_value_get_int(input[1]);
+	gint value3 = g_value_get_int(input[2]);
+	gint value4 = g_value_get_int(input[3]);
+	gchar * method_param = g_value_dup_string(input[4]);
+	
+	printf("input value1: 0x%.2x\n", device_code);
+	printf("input value2: 0x%.3x\n", method_code);
+	printf("input value3: %d\n", value3);
+	printf("input value4: %d\n", value4);
+	printf("input value5: %s\n", method_param);
+
+	manager_call_device_method(device_code, method_code,(const char*)method_param,&rt);	
+	//interlayer_call_device_method(value1, value2,value5, &statuscode,&count,statusdesc); 
+    }
+    GValueArray* struct_return;// = g_array_new(TRUE,TRUE,sizeof(GValue));
+    GValue struct_container[3] = {{0}};
+
+    g_value_init (&struct_container[0], G_TYPE_INT);
+    g_value_set_int (&struct_container[0], rt.state_code);
+    g_value_init (&struct_container[1], G_TYPE_INT);
+    g_value_set_int (&struct_container[1], rt.exception_code);
+    g_value_init (&struct_container[2], G_TYPE_STRING);
+    g_value_set_string (&struct_container[2], rt.desc);
+
+    struct_return = g_value_array_new(0);
+    int j;
+    for(j =0; j <3; j++){
+	struct_return = g_value_array_append(struct_return, &struct_container[j]);
+    }
+
+    dbus_g_method_return(ret_value,struct_return);	
+    return 1;
+}
+gint monitor_dbus_regist_new_device(MonitorDbus * dbus, int device_code, DBusGMethodInvocation * ret_value){
+		
+    //printf("Hello,here, 0x%.2x\n",device_code);
+    //printf("Hello,here\n");
+    dbus_return_t rt={0,0,{0}};// state_code ; exception_code; exception_desc;
+    manager_regist_device(device_code,&rt);
+    
+    GValueArray* struct_return;// = g_array_new(TRUE,TRUE,sizeof(GValue));
+    GValue struct_container[3] = {{0}};
+
+    g_value_init (&struct_container[0], G_TYPE_INT);
+    g_value_set_int (&struct_container[0], rt.state_code);
+    g_value_init (&struct_container[1], G_TYPE_INT);
+    g_value_set_int (&struct_container[1], rt.exception_code);
+    g_value_init (&struct_container[2], G_TYPE_STRING);
+    g_value_set_string (&struct_container[2], rt.desc);
+
+    struct_return = g_value_array_new(0);
+    int j;
+    for(j =0; j <3; j++){
+	struct_return = g_value_array_append(struct_return, &struct_container[j]);
+    }
+
+    dbus_g_method_return(ret_value,struct_return);	
+    return 1;
+}
+gint monitor_dbus_logout_device(MonitorDbus * dbus, int device_code, DBusGMethodInvocation * ret_value){
+    //printf("Hello,here, 0x%.2x\n",device_code);
+    //printf("Hello,here\n");
+    dbus_return_t rt={0,0,{0}};// state_code ; exception_code; exception_desc;
+    manager_logout_device(device_code,&rt);
+    
+    GValueArray* struct_return;// = g_array_new(TRUE,TRUE,sizeof(GValue));
+    GValue struct_container[3] = {{0}};
+
+    g_value_init (&struct_container[0], G_TYPE_INT);
+    g_value_set_int (&struct_container[0], rt.state_code);
+    g_value_init (&struct_container[1], G_TYPE_INT);
+    g_value_set_int (&struct_container[1], rt.exception_code);
+    g_value_init (&struct_container[2], G_TYPE_STRING);
+    g_value_set_string (&struct_container[2], rt.desc);
+
+    struct_return = g_value_array_new(0);
+    int j;
+    for(j =0; j <3; j++){
+	struct_return = g_value_array_append(struct_return, &struct_container[j]);
+    }
+    dbus_g_method_return(ret_value,struct_return);	
+    return 1;
+}
+
+
+
+void _send_string_signal(manager_callback_return_t* rt){
+    //
+}
+
 int send_signal(MonitorDbus * dbus, gint s1){
     g_signal_emit(dbus, mnsignals[SIG_DATA_ALERT], 0, s1);
     return 0;
@@ -142,7 +234,11 @@
     send_signal(dbus, 1);
     return 1;
 }
-
+int dbus_exit(void){
+    manager_exit();
+    g_main_loop_unref(loop);
+    g_object_unref(dbus);	
+}
 int dbus_init(void)
 {
     DBusGConnection * connection = NULL;
@@ -158,40 +254,39 @@
 
     connection = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);
     if(connection == NULL){
-        g_error("%s", error->message);
-        goto out;
+	g_error("%s", error->message);
+	goto out;
     }
 
     dbus_proxy = dbus_g_proxy_new_for_name(connection, DBUS_SERVICE_DBUS,
-                                           DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS);
+	    DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS);
 
     ret = dbus_g_proxy_call(dbus_proxy, "RequestName", &error,
-                            G_TYPE_STRING, LISTEN_DBUS_NAME,
-                            G_TYPE_UINT,
-                            DBUS_NAME_FLAG_DO_NOT_QUEUE,
-                            G_TYPE_INVALID,
-                            G_TYPE_UINT, &request_name_result,
-                            G_TYPE_INVALID);
+	    G_TYPE_STRING, LISTEN_DBUS_NAME,
+	    G_TYPE_UINT,
+	    DBUS_NAME_FLAG_DO_NOT_QUEUE,
+	    G_TYPE_INVALID,
+	    G_TYPE_UINT, &request_name_result,
+	    G_TYPE_INVALID);
     if(!ret){
-        g_error("RequestName failed:%s", error->message);
-        g_error_free(error);
-        exit(EXIT_FAILURE);
+	g_error("RequestName failed:%s", error->message);
+	g_error_free(error);
+	exit(EXIT_FAILURE);
     }
 
     g_object_unref(G_OBJECT(dbus_proxy));
 
     if(request_name_result != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)
-        exit(EXIT_FAILURE);
+	exit(EXIT_FAILURE);
 
     dbus_g_object_type_install_info(LISTEN_TYPE_DBUS,
-                                    &dbus_glib_monitor_dbus_object_info);
+	    &dbus_glib_monitor_object_info);
     dbus_g_connection_register_g_object(connection, LISTEN_DBUS_PATH,G_OBJECT(dbus));
 
     // 定时发送signal
     //g_timeout_add_seconds(5, (GSourceFunc)send_mnsignals_timer_handler, dbus);
-
-    interlayer_load_devices(LISTEN_DBUS_NAME, LISTEN_DBUS_PATH);
-
+    //printf("before manager_init\n");
+    manager_init(LISTEN_DBUS_NAME, LISTEN_DBUS_PATH,(MANAGER_CALLBACK_FUNC)_send_string_signal);
     g_main_loop_run(loop);
 out:
     g_main_loop_unref(loop);
 
=== modified file 'src/dbuslayer/monitor_dbus.h'
--- src/dbuslayer/monitor_dbus.h	2017-09-05 05:53:02 +0000
+++ src/dbuslayer/monitor_dbus.h	2017-10-10 00:58:46 +0000
@@ -70,14 +70,17 @@
 
 GType monitor_dbus_get_type(void);
 MonitorDbus * monitor_dbus_new(void);
-gint monitor_dbus_call_monitor_method(MonitorDbus * dbus,GValueArray * method_value ,DBusGMethodInvocation * ret_value);
-gint monitor_dbus_intropect(MonitorDbus * dbus,const char* devicename,DBusGMethodInvocation * ret_value);
+gint monitor_dbus_get_all_device_static_info(MonitorDbus* dbus,DBusGMethodInvocation* ret_value);
+gint monitor_dbus_get_device_interfaces_info(MonitorDbus* dbus, int device_code, DBusGMethodInvocation* ret_value);
+gint monitor_dbus_call_device_method(MonitorDbus * dbus,GValueArray * method_value ,DBusGMethodInvocation * ret_value);
+gint monitor_dbus_regist_new_device(MonitorDbus* dbus, int device_code, DBusGMethodInvocation * ret_value);
+gint monitor_dbus_logout_device(MonitorDbus* dbus, int device_code, DBusGMethodInvocation* ret_value);
 #define DBUS_STRUCT_INT_INT_STRING (dbus_g_type_get_struct("GValueArray", G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING))
 
 G_END_DECLS
 
 int dbus_init(void);
-
+int dbus_exit(void);
 
 void signal_handler();
 #endif
 
=== added file 'src/dbuslayer/monitor_dbus.h.backup'
--- src/dbuslayer/monitor_dbus.h.backup	1970-01-01 00:00:00 +0000
+++ src/dbuslayer/monitor_dbus.h.backup	2017-10-10 00:58:46 +0000
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2013 National University of Defense Technology(NUDT) & Kylin Ltd.
+ *
+ * Authors:
+ *  Kobe Lee   [e-mail]
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __LISTEN_DBUS_H__
+#define __LISTEN_DBUS_H__
+
+#include <glib-object.h>
+#include <glib.h>
+#include <dbus/dbus-glib.h>
+#include <dbus/dbus-glib-lowlevel.h>
+#include <gio/gio.h>
+
+G_BEGIN_DECLS
+
+
+enum {
+    SIG_DATA_ALERT,
+    SIG_LAST_SIGNAL,
+};
+
+#define LISTEN_DBUS_NAME	"com.jd.test"
+#define LISTEN_DBUS_PATH	"/com/jd/test"
+#define LISTEN_DBUS_INTERFACE	"com.jd.monitor.test"
+#define LISTEN_DBUS_ACTION_ID	"com.jd.monitor.authentication"
+#define LISTEN_TYPE_DBUS	(monitor_dbus_get_type())
+
+#define LISTEN_DBUS(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), LISTEN_TYPE_DBUS, MonitorDbus))
+#define LISTEN_DBUS_CLASS(k)	(G_TYPE_CHECK_CLASS_CAST((k), LISTEN_TYPE_DBUS, MonitorDbusClass))
+#define LISTEN_IS_DBUS(o)	(G_TYPE_CHECK_INSTANCE_TYPE((o), LISTEN_TYPE_DBUS))
+#define LISTEN_IS_DBUS_CLASS(k)	(G_TYPE_CHECK_CLASS_TPYE((k), LISTEN_TYPE_DBUS))
+#define LISTEN_DBUS_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS((o), LISTEN_TYPE_DBUS, MonitorClass))
+
+typedef struct _MonitorDbusPrivate MonitorDbusPrivate;
+typedef struct _MonitorDbus MonitorDbus;
+typedef struct _MonitorDbusClass MonitorDbusClass;
+typedef struct _MonitorWarnDbusClass MonitorWarnDbusClass;
+
+struct _MonitorDbus {
+    GObject parent;
+    MonitorDbusPrivate *priv;
+};
+
+struct _MonitorDbusClass {
+    GObjectClass parent_class;
+    void (*event)(MonitorDbus* dbus, guint type, GValue * value);
+
+};
+
+struct _MonitorWarnDbusClass {
+    GObjectClass parent_class;
+    void (*event)(MonitorDbus* dbus, guint tag ,guint type, guint subtype);
+
+};
+
+GType monitor_dbus_get_type(void);
+MonitorDbus * monitor_dbus_new(void);
+gint monitor_dbus_call_monitor_method(MonitorDbus * dbus,GValueArray * method_value ,DBusGMethodInvocation * ret_value);
+gint monitor_dbus_intropect(MonitorDbus * dbus,const char* devicename,DBusGMethodInvocation * ret_value);
+#define DBUS_STRUCT_INT_INT_STRING (dbus_g_type_get_struct("GValueArray", G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING))
+
+G_END_DECLS
+
+int dbus_init(void);
+
+
+void signal_handler();
+#endif
+
 
=== modified file 'src/dbuslayer/monitor_dbus_glue.h'
--- src/dbuslayer/monitor_dbus_glue.h	2017-09-05 05:53:02 +0000
+++ src/dbuslayer/monitor_dbus_glue.h	2017-10-10 00:58:46 +0000
@@ -1,8 +1,8 @@
 /* Generated by dbus-binding-tool; do not edit! */
 
 
-#ifndef __dbus_glib_marshal_monitor_dbus_MARSHAL_H__
-#define __dbus_glib_marshal_monitor_dbus_MARSHAL_H__
+#ifndef __dbus_glib_marshal_monitor_MARSHAL_H__
+#define __dbus_glib_marshal_monitor_MARSHAL_H__
 
 #include	<glib-object.h>
 
@@ -55,26 +55,30 @@
 #endif /* !G_ENABLE_DEBUG */
 
 
-/* NONE:STRING,POINTER */
-extern void dbus_glib_marshal_monitor_dbus_VOID__STRING_POINTER (GClosure     *closure,
-                                                                 GValue       *return_value,
-                                                                 guint         n_param_values,
-                                                                 const GValue *param_values,
-                                                                 gpointer      invocation_hint,
-                                                                 gpointer      marshal_data);
+/* NONE:POINTER */
+#define dbus_glib_marshal_monitor_VOID__POINTER	g_cclosure_marshal_VOID__POINTER
+#define dbus_glib_marshal_monitor_NONE__POINTER	dbus_glib_marshal_monitor_VOID__POINTER
+
+/* NONE:INT,POINTER */
+extern void dbus_glib_marshal_monitor_VOID__INT_POINTER (GClosure     *closure,
+                                                         GValue       *return_value,
+                                                         guint         n_param_values,
+                                                         const GValue *param_values,
+                                                         gpointer      invocation_hint,
+                                                         gpointer      marshal_data);
 void
-dbus_glib_marshal_monitor_dbus_VOID__STRING_POINTER (GClosure     *closure,
-                                                     GValue       *return_value G_GNUC_UNUSED,
-                                                     guint         n_param_values,
-                                                     const GValue *param_values,
-                                                     gpointer      invocation_hint G_GNUC_UNUSED,
-                                                     gpointer      marshal_data)
+dbus_glib_marshal_monitor_VOID__INT_POINTER (GClosure     *closure,
+                                             GValue       *return_value G_GNUC_UNUSED,
+                                             guint         n_param_values,
+                                             const GValue *param_values,
+                                             gpointer      invocation_hint G_GNUC_UNUSED,
+                                             gpointer      marshal_data)
 {
-  typedef void (*GMarshalFunc_VOID__STRING_POINTER) (gpointer     data1,
-                                                     gpointer     arg_1,
-                                                     gpointer     arg_2,
-                                                     gpointer     data2);
-  GMarshalFunc_VOID__STRING_POINTER callback;
+  typedef void (*GMarshalFunc_VOID__INT_POINTER) (gpointer     data1,
+                                                  gint         arg_1,
+                                                  gpointer     arg_2,
+                                                  gpointer     data2);
+  GMarshalFunc_VOID__INT_POINTER callback;
   GCClosure *cc = (GCClosure*) closure;
   gpointer data1, data2;
 
@@ -90,29 +94,29 @@
       data1 = g_value_peek_pointer (param_values + 0);
       data2 = closure->data;
     }
-  callback = (GMarshalFunc_VOID__STRING_POINTER) (marshal_data ? marshal_data : cc->callback);
+  callback = (GMarshalFunc_VOID__INT_POINTER) (marshal_data ? marshal_data : cc->callback);
 
   callback (data1,
-            g_marshal_value_peek_string (param_values + 1),
+            g_marshal_value_peek_int (param_values + 1),
             g_marshal_value_peek_pointer (param_values + 2),
             data2);
 }
-#define dbus_glib_marshal_monitor_dbus_NONE__STRING_POINTER	dbus_glib_marshal_monitor_dbus_VOID__STRING_POINTER
+#define dbus_glib_marshal_monitor_NONE__INT_POINTER	dbus_glib_marshal_monitor_VOID__INT_POINTER
 
 /* NONE:BOXED,POINTER */
-extern void dbus_glib_marshal_monitor_dbus_VOID__BOXED_POINTER (GClosure     *closure,
-                                                                GValue       *return_value,
-                                                                guint         n_param_values,
-                                                                const GValue *param_values,
-                                                                gpointer      invocation_hint,
-                                                                gpointer      marshal_data);
+extern void dbus_glib_marshal_monitor_VOID__BOXED_POINTER (GClosure     *closure,
+                                                           GValue       *return_value,
+                                                           guint         n_param_values,
+                                                           const GValue *param_values,
+                                                           gpointer      invocation_hint,
+                                                           gpointer      marshal_data);
 void
-dbus_glib_marshal_monitor_dbus_VOID__BOXED_POINTER (GClosure     *closure,
-                                                    GValue       *return_value G_GNUC_UNUSED,
-                                                    guint         n_param_values,
-                                                    const GValue *param_values,
-                                                    gpointer      invocation_hint G_GNUC_UNUSED,
-                                                    gpointer      marshal_data)
+dbus_glib_marshal_monitor_VOID__BOXED_POINTER (GClosure     *closure,
+                                               GValue       *return_value G_GNUC_UNUSED,
+                                               guint         n_param_values,
+                                               const GValue *param_values,
+                                               gpointer      invocation_hint G_GNUC_UNUSED,
+                                               gpointer      marshal_data)
 {
   typedef void (*GMarshalFunc_VOID__BOXED_POINTER) (gpointer     data1,
                                                     gpointer     arg_1,
@@ -141,22 +145,25 @@
             g_marshal_value_peek_pointer (param_values + 2),
             data2);
 }
-#define dbus_glib_marshal_monitor_dbus_NONE__BOXED_POINTER	dbus_glib_marshal_monitor_dbus_VOID__BOXED_POINTER
+#define dbus_glib_marshal_monitor_NONE__BOXED_POINTER	dbus_glib_marshal_monitor_VOID__BOXED_POINTER
 
 G_END_DECLS
 
-#endif /* __dbus_glib_marshal_monitor_dbus_MARSHAL_H__ */
+#endif /* __dbus_glib_marshal_monitor_MARSHAL_H__ */
 
 #include <dbus/dbus-glib.h>
-static const DBusGMethodInfo dbus_glib_monitor_dbus_methods[] = {
-  { (GCallback) monitor_dbus_call_monitor_method, dbus_glib_marshal_monitor_dbus_NONE__BOXED_POINTER, 0 },
-  { (GCallback) monitor_dbus_intropect, dbus_glib_marshal_monitor_dbus_NONE__STRING_POINTER, 91 },
+static const DBusGMethodInfo dbus_glib_monitor_methods[] = {
+  { (GCallback) monitor_dbus_get_all_device_static_info, dbus_glib_marshal_monitor_NONE__POINTER, 0 },
+  { (GCallback) monitor_dbus_get_device_interfaces_info, dbus_glib_marshal_monitor_NONE__INT_POINTER, 94 },
+  { (GCallback) monitor_dbus_call_device_method, dbus_glib_marshal_monitor_NONE__BOXED_POINTER, 206 },
+  { (GCallback) monitor_dbus_regist_new_device, dbus_glib_marshal_monitor_NONE__INT_POINTER, 313 },
+  { (GCallback) monitor_dbus_logout_device, dbus_glib_marshal_monitor_NONE__INT_POINTER, 403 },
 };
 
-const DBusGObjectInfo dbus_glib_monitor_dbus_object_info = {  1,
-  dbus_glib_monitor_dbus_methods,
-  2,
-"com.jd.test.interface\0call_monitor_method\0A\0hw_method_t\0I\0(iiiis)\0hw_return_t\0O\0F\0N\0(iis)\0\0com.jd.test.interface\0intropect\0A\0name\0I\0s\0data\0O\0F\0N\0s\0\0\0",
+const DBusGObjectInfo dbus_glib_monitor_object_info = {  1,
+  dbus_glib_monitor_methods,
+  5,
+"com.jd.test.interface\0dbus_get_all_device_static_info\0A\0devices_static_return_t\0O\0F\0N\0a(isi)\0\0com.jd.test.interface\0dbus_get_device_interfaces_info\0A\0device_code\0I\0i\0device_interfaces_return_t\0O\0F\0N\0isaav\0\0com.jd.test.interface\0dbus_call_device_method\0A\0device_method_input_t\0I\0(iiiis)\0dbus_return_t\0O\0F\0N\0(iis)\0\0com.jd.test.interface\0dbus_regist_new_device\0A\0device_code\0I\0i\0dbus_return_t\0O\0F\0N\0(iis)\0\0com.jd.test.interface\0dbus_logout_device\0A\0device_code\0I\0i\0dbus_return_t\0O\0F\0N\0(iis)\0\0\0",
 "\0",
 "\0"
 };
 
=== removed directory 'src/interlayer'
=== removed file 'src/interlayer/interlayer.c'
--- src/interlayer/interlayer.c	2017-09-05 05:53:02 +0000
+++ src/interlayer/interlayer.c	1970-01-01 00:00:00 +0000
@@ -1,351 +0,0 @@
-#include "interlayer.h"
-#include <unistd.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/types.h>
-#include <dlfcn.h>
-#include <dirent.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <glib.h>
-//#include <libxml2/libxml/parser.h>
-//#include <libxml2/libxml/tree.h>
-#include <libxml/parser.h>
-#include <libxml/tree.h>
-
-#define WORK_ROOT_DIR "/etc/kydevmonit/"
-typedef void (*NO_DBUS_INPUT_FUNC)(void* return_t);
-typedef void (*HAS_DBUS_INPUT_FUNC)(const char* input, void* return_t);
-typedef struct{
-    int error_no;
-    int count;
-    char * desc;
-}hw_return_t;
-
-#define NO_DBUS_INPUT_TYPE 0
-#define HAS_DBUS_INPUT_TYPE 1
-typedef struct{
-    void * address;
-    int type;    
-}device_method_t;
-
-
-static xmlDocPtr intropectdoc;
-static xmlNodePtr intropectdoc_rootnode;
-static int
-_init_write_devices_intropect_xml(const char* object_name){
-    if(intropectdoc == NULL && intropectdoc_rootnode == NULL)    {
-        intropectdoc = xmlNewDoc("1.0");
-        intropectdoc_rootnode = xmlNewNode(NULL, "object");
-        xmlNewProp(intropectdoc_rootnode,"name", object_name);
-        xmlDocSetRootElement(intropectdoc, intropectdoc_rootnode);
-    }
-    return 0;
-}
-static int
-_end_write_devices_intropect_xml(const char* dbus_name){
-    if(intropectdoc == NULL || intropectdoc_rootnode == NULL)
-        return -1;
-    char filename[1024]={0};
-    sprintf(filename,"%sdevices.", WORK_ROOT_DIR);
-    sprintf(filename, "%s%s.xml", filename,dbus_name);
-    printf("intropect xml filename: %s\n", filename);
-    if(xmlSaveFormatFileEnc(filename, intropectdoc, "UTF-8", 1) >=0){
-        printf("Save intropectdoc xml file successful\n");
-    }else{
-        printf("Save intropectdoc xml file failed\n");
-    }
-    xmlFreeDoc(intropectdoc);
-    xmlCleanupParser();
-    return 0;
-}
-static int
-_add_device_to_intropect_xml(const xmlChar* devicename,const char* devicecode){
-    if(intropectdoc == NULL || intropectdoc_rootnode == NULL || devicename == NULL){
-        fprintf(stderr, "doc or node or devicename is null\n");
-        return -1;
-    }
-    xmlNodePtr devicenode = xmlNewChild(intropectdoc_rootnode, NULL, "device", "");
-    xmlNewProp(devicenode, "name", devicename);
-    xmlNewProp(devicenode, "code",devicecode);
-    return 0;
-}
-
-static GHashTable * method_table = NULL;
-static int
-_init_method_hashtable(){
-    if(method_table == NULL){
-        method_table = g_hash_table_new(g_str_hash, g_str_equal);
-    }
-    return 0; 
-}
-static int
-_insert_method_hashtable(gpointer key, gpointer value){
-    if(method_table == NULL || key == NULL)
-        return -1;
-    g_hash_table_insert(method_table, key, value);
-    return 0;
-}
-static gpointer
-_get_method_address(gpointer key){
-    if(method_table == NULL || key == NULL){
-        //fprintf(stderr, "ERROR: method_table or key is null\n");
-        return NULL;
-    }
-    return g_hash_table_lookup(method_table,key);
-}
-static void
-_ms_print_key_value(gpointer key, gpointer value, gpointer user_data){
-    printf("key: %s, value: %u\n", key, (unsigned int)value);
-}
-static void
-_ms_display_method_hashtable(){
-    g_hash_table_foreach(method_table, _ms_print_key_value, NULL);
-}
-static int
-_parse_device_xml(const char * filename, const char* object_name){
-    //if(filename == NULL)
-      //  return -1;
-    char filepath[1024]={0};
-    sprintf(filepath,"%s",WORK_ROOT_DIR);
-    sprintf(filepath,"%s%s",filepath,filename);
-    xmlNodePtr curnode;
-    xmlDocPtr doc;
-    void * sharelibHandle;
-    xmlInitParser();
-    doc = xmlReadFile(filepath, "UTF-8", XML_PARSE_RECOVER) ;
-    if(doc == NULL){
-        fprintf(stderr, "xmlReadFile %s failed\n", filepath);
-        return -1;
-    }
-    curnode = xmlDocGetRootElement(doc);
-    if(curnode == NULL){
-        fprintf(stderr, "empty document\n");
-        xmlFreeDoc(doc);
-        return -1;
-    }
-   // printf("curnode->name: %s\n", curnode->name);
-   // curnode = curnode->xmlChildrenNode;
-    xmlChar * nodevalue = NULL;
-    xmlChar * devicecode = NULL;
-    xmlChar * methodcode = NULL;
-    xmlChar * devicepath = NULL;
-    int statuscode = 0;
-    while(curnode != NULL){
-        if(xmlStrcmp(curnode->name, (const xmlChar*)"object") == 0){
-            nodevalue = xmlGetProp(curnode, (const xmlChar*)"name");
-            //printf("nodevalue: %s\n", nodevalue);
-            if(xmlStrncmp(nodevalue, object_name, strlen(object_name)) != 0){
-               fprintf(stderr,"The object_name %s is not matched\n", nodevalue);
-               xmlFree(nodevalue);
-               statuscode = -1;
-               break;
-            }else{
-                _init_write_devices_intropect_xml(object_name);
-                xmlFree(nodevalue);
-                curnode = curnode->xmlChildrenNode;
-                continue;
-            }
-        }
-        else if(xmlStrcmp(curnode->name, (const xmlChar*)"device") == 0){
-            nodevalue = xmlGetProp(curnode, "name");
-            if(nodevalue == NULL){
-                fprintf(stderr, "The device hasn't name,this is invailed!\n");
-                statuscode = -1;
-                break;
-            }
-            devicecode = xmlGetProp(curnode, "code");
-            if(devicecode == NULL){
-                fprintf(stderr, "The device hasn't code,this is invailed!\n");
-                xmlFree(nodevalue);
-                statuscode = -1;
-                break;
-            }
-            // load so
-            devicepath = xmlGetProp(curnode, "path");
-            if(devicepath == NULL){
-                fprintf(stderr, "The device hasn't path,this is invailed!\n");
-                statuscode = -1;
-                xmlFree(nodevalue);
-                xmlFree(devicecode); 
-                break; 
-            }
-            printf("path: %s\n", devicepath);
-            sharelibHandle = dlopen(devicepath, RTLD_NOW); 
-            if(sharelibHandle == NULL){
-                fprintf(stderr, "%s sharelibHandle is NULL\n", devicepath);
-                xmlFree(devicepath);
-                xmlFree(nodevalue);
-                xmlFree(devicecode); 
-                statuscode = -1;
-                break;
-            }else{
-                _add_device_to_intropect_xml(nodevalue, devicecode);
-                _init_method_hashtable();
-                xmlFree(nodevalue);
-                xmlFree(devicepath);
-            }
-            curnode = curnode->xmlChildrenNode;
-            continue;
-        }else if(xmlStrcmp(curnode->name, (const xmlChar*)"method") == 0){
-            nodevalue = xmlGetProp(curnode, "name");
-            if(nodevalue == NULL){
-                fprintf(stderr, "method hasn't name, this is invaild!\n");
-                curnode = curnode->next;
-                continue;
-            } 
-            methodcode = xmlGetProp(curnode, "code");
-            if(methodcode == NULL){
-                fprintf(stderr, "method %s hasn't code, this is invaild!\n", nodevalue);
-                curnode = curnode->next;
-                xmlFree(nodevalue);
-                continue;
-            } 
-            void* methodaddr = dlsym(sharelibHandle,nodevalue);
-            char* key = malloc(20*sizeof(char));
-            device_method_t* method_ptr = malloc(sizeof(device_method_t));
-            method_ptr->address = methodaddr;
-            xmlFree(nodevalue);
-
-            nodevalue = xmlGetProp(curnode, "type");
-            if(nodevalue == NULL){
-                fprintf(stderr, "method hasn't type, this is invaild!\n");
-                xmlFree(methodcode);
-                curnode = curnode->next;
-                continue;
-            }
-            else if(xmlStrcmp(nodevalue, "nodbusinput") == 0){
-                method_ptr->type = NO_DBUS_INPUT_TYPE;
-            }else if(xmlStrcmp(nodevalue, "hasdbusinput") == 0){
-                method_ptr->type = HAS_DBUS_INPUT_TYPE;
-            }else{
-            
-            }
-
-            sprintf(key, "%s%s", devicecode,methodcode);
-            printf("key: %s len=%lu\n", key, strlen(key));
-            _insert_method_hashtable(key, method_ptr);
-
-            printf("method name : %s, address : %u\n", nodevalue, (unsigned int)methodaddr);
-            xmlFree(nodevalue);
-            xmlFree(methodcode);
-        }
-        curnode = curnode->next;
-    }
-    if(devicecode != NULL)
-        xmlFree(devicecode);
-    if(doc != NULL)
-        xmlFreeDoc(doc);
-    
-    return statuscode;
-}
-int interlayer_load_devices(const char* dbus_name, const char* object_name){
-    if(dbus_name == NULL || object_name == NULL){
-        fprintf(stderr, "ERROR: The dbus_name or object_name is null!\n");
-        return -1;
-    }
-    // Loop match xml file
-    DIR *workdp;
-    struct dirent *entry;
-    if((workdp = opendir(WORK_ROOT_DIR)) == NULL){ 
-        fprintf(stderr, "opendir %s failed,no devices\n", WORK_ROOT_DIR);
-        return -1;
-    }
-    //chdir(WORK_ROOT_DIR);
-    while((entry = readdir(workdp)) != NULL){
-        if(strncmp(dbus_name,entry->d_name, strlen(dbus_name)) == 0){
-            
-            if(_parse_device_xml(entry->d_name, object_name) < 0){
-                fprintf(stderr, "%s parse failed!\n", entry->d_name);
-            }
-            else{
-                printf("%s load successful\n", entry->d_name);
-            }
-        }
-    }
-    closedir(workdp);
-    _end_write_devices_intropect_xml(dbus_name);
-    //_ms_display_method_hashtable();
-    return 0;   
-}
-
-int interlayer_get_devices_intropect(const char* dbus_name, const char* object_name, const char* devicename,char* ret_desc){
-    if(dbus_name == NULL || object_name == NULL || ret_desc == NULL){
-        fprintf(stderr, "ERROR: The dbus_name or object_name or ret_desc is null!\n");
-        return -1;
-    }
-    char filename[1024];
-    memset(filename, 0, 1024);
-    size_t len=0;
-    if(strlen(devicename) == 0){
-        sprintf(filename,"%sdevices.%s.xml", WORK_ROOT_DIR, dbus_name);
-        printf("filename= %s\n", filename);
-        int fd=open(filename, O_RDONLY);
-        if(fd < 0){
-            fprintf(stderr, "%s open failed\n", filename);
-            return -1;
-        }
-        
-        if((len = read(fd, ret_desc, 1024-1)) < 0){
-            fprintf(stderr, "%s read failed\n", filename);
-            close(fd);
-            return -1;
-        }
-        ret_desc[len] = '\0';
-        //printf("ret_desc = %s\n", ret_desc);
-        close(fd) ;
-    }else{
-        memset(filename, 0, 1024);
-        sprintf(filename,"%s%s.%s.xml", WORK_ROOT_DIR, dbus_name,devicename);
-        printf("filename= %s\n", filename);
-        int fd=open(filename, O_RDONLY);
-        if(fd < 0){
-            fprintf(stderr, "%s open failed\n", filename);
-            return -1;
-        }
-        
-        if((len = read(fd, ret_desc, 1024-1)) < 0){
-            fprintf(stderr, "%s read failed\n", filename);
-            close(fd);
-            return -1;
-        }
-        ret_desc[len] = '\0';
-        //printf("ret_desc = %s\n", ret_desc);
-        close(fd) ;
-        
-    }
-    return 0;
-}
-int interlayer_call_device_method(int devicecode, int methodcode, const char* param, int* statuscode, int * count, char* desc){
-    if(param == NULL || statuscode == NULL || count == NULL || desc == NULL){
-        fprintf(stderr, "ERROR: Please input vaild paramters\n");
-        return -1;
-    }
-    //_ms_display_method_hashtable();
-    char key[20] = {0};
-    sprintf(key,"0x%.2x0x%.2x", devicecode, methodcode);
-    printf("call_key: %s ,len=%lu\n", key, strlen(key));
-    device_method_t * method_ptr = _get_method_address(key);
-    if(method_ptr == NULL){
-        fprintf(stderr,"The method_ptr is NULL\n");
-        return -1;
-    }
-    printf("method address : %u\n", (unsigned int)(method_ptr->address));
-    
-    hw_return_t result={0,0,NULL};
-    result.desc = desc;
-    
-    if(method_ptr->type == NO_DBUS_INPUT_TYPE){
-        NO_DBUS_INPUT_FUNC method_func = (NO_DBUS_INPUT_FUNC)(method_ptr->address);
-        method_func(&result);
-    }else if(method_ptr->type == HAS_DBUS_INPUT_TYPE){
-        HAS_DBUS_INPUT_FUNC method_func = (HAS_DBUS_INPUT_FUNC)(method_ptr->address);
-        method_func(param,&result);
-    }else{
-        //
-    }
-    *statuscode = result.error_no;
-    *count = result.count;
-    return 0;
-}
 
=== removed file 'src/interlayer/interlayer.h'
--- src/interlayer/interlayer.h	2017-09-05 05:53:02 +0000
+++ src/interlayer/interlayer.h	1970-01-01 00:00:00 +0000
@@ -1,34 +0,0 @@
-#ifndef __INTER_LAYER_H__
-#define __INTER_LAYER_H__
-
-
-/**
- * The device's register info at /etc/kydevmonit/ xml file. 
- * This method find and load the device's xml file that match the
- * dbus_name and object_name. 
- * And load the share library of matched dervice.
- * @return 0 successful; 1 failed
- */
-int interlayer_load_devices(const char* dbus_name, const char* object_name);
-
-/**
- * Return the information to ret_desc about had registered device.
- * If the len(devicename) == 0 , the information only include device_name,device_code.
- * else the information include all method's name, method's code, method's type for the
- * special device by param 'devicename' point.
- *
- * @return 0 successful ; 1 failed
- */
-int interlayer_get_devices_intropect(const char* dbus_name, const char* object_name, const char* devicename,char* ret_desc);
-
-/**
-  * Call the device method by devicecode and methodcode point.
-  * @param If this device method need a param
-  * @error_no the device method invoke return statuscode
-  * @count
-  * @desc The describtion about the error_no
-  * @return 0 successful ; 1 failed
- */
-int interlayer_call_device_method(int devicecode, int methodcode,const char* param, int* error_no, int* count, char* desc);
-
-#endif
 
=== modified file 'src/main.c'
--- src/main.c	2017-09-05 05:53:02 +0000
+++ src/main.c	2017-10-10 00:58:46 +0000
@@ -1,9 +1,18 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <signal.h>
 #include "./dbuslayer/monitor_dbus.h"
 
-int main()
-{
-    // load all device
-    dbus_init();
-	return 0;
+void sigint_handler(int sig){
+	dbus_exit();	
+	printf("dbus_exit here\n");
+	exit(EXIT_SUCCESS);
+}
+int main(int argc, char* argv[]){
 
+	signal(SIGINT,sigint_handler);
+	dbus_init();
+	exit(EXIT_SUCCESS);
 }
 
=== added directory 'src/managerlayer'
=== added file 'src/managerlayer/_configure.c'
--- src/managerlayer/_configure.c	1970-01-01 00:00:00 +0000
+++ src/managerlayer/_configure.c	2017-10-10 00:58:46 +0000
@@ -0,0 +1,440 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <dlfcn.h>
+#include <dirent.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <glib.h>
+//#include <libxml2/libxml/parser.h>
+//#include <libxml2/libxml/tree.h>
+#include <libxml/parser.h>
+#include <libxml/tree.h>
+#include "_configure.h"
+
+#define WORK_ROOT_DIR "/etc/kydevmonit"
+#define CONF_SELFCHECK_METHOD_CODE "0x006"
+
+typedef manager_device_soft_t _conf_device_soft_t;
+typedef manager_device_static_t _conf_device_static_t;
+typedef hw_return_t _conf_hw_return_t;
+
+//static char STOP_STRING[]="\0";
+static char _upstream_dbus_name[DESC_BUF_LEN] = {0};
+static char _upstream_object_name[DESC_BUF_LEN] = {0};
+static CONF_CALLBACK_FUNC _upstream_cb = NULL;
+
+static GHashTable* _sharelibHandle_ht = NULL;
+
+void free_hashTable_key(gpointer data){
+    free(data);
+}
+void free_hashTable_value(gpointer data){
+    free(data);
+}
+void free_hashTable_sharelib_value(gpointer data){
+    dlclose((void*)data);
+}
+int
+_parse_device_conf_xml(
+	GHashTable** devices_static_ht,
+	GHashTable** devices_soft_ht,
+	GHashTable** devices_methods_ht,
+	const char* filename){
+    //if(filename == NULL)
+    //  return -1;
+    char filepath[DESC_BUF_LEN]={0};
+    snprintf(filepath,DESC_BUF_LEN,"%s/%s",WORK_ROOT_DIR, filename);
+
+    xmlNodePtr curnode;
+    xmlDocPtr doc;
+    xmlInitParser();
+    doc = xmlReadFile(filepath, "UTF-8", XML_PARSE_RECOVER) ;
+    if(doc == NULL){
+	fprintf(stderr, "xmlReadFile %s failed\n", filepath);
+	return -1;
+    }
+    curnode = xmlDocGetRootElement(doc);
+    if(curnode == NULL){
+	fprintf(stderr, "empty document\n");
+	xmlFreeDoc(doc);
+	return -1;
+    }
+    // printf("curnode->name: %s\n", curnode->name);
+    // curnode = curnode->xmlChildrenNode;
+    xmlChar * nodevalue = NULL;
+    xmlChar * devicecode = NULL;
+    xmlChar * methodcode = NULL;
+    xmlChar * methodtype = NULL;
+    xmlChar * devicedriver = NULL;
+    void * sharelibHandle = NULL;
+    _conf_device_soft_t* soft_value_ptr = NULL;
+    int statuscode = 0;
+    while(curnode != NULL){
+	if(xmlStrcmp(curnode->name, (const xmlChar*)"object") == 0){
+	    nodevalue = xmlGetProp(curnode, (const xmlChar*)"name");
+	    //printf("nodevalue: %s\n", nodevalue);
+	    if(xmlStrncmp(nodevalue, _upstream_object_name, strlen(_upstream_object_name)) != 0){
+		fprintf(stderr,"The object_name %s is not matched\n", nodevalue);
+		statuscode = -1;
+	    }else{
+		//_init_write_devices_intropect_xml(object_name);
+		//printf("DEBUG: new device finded\n");
+		if(*devices_static_ht == NULL)
+		    *devices_static_ht = g_hash_table_new_full(g_str_hash, g_str_equal,free_hashTable_key,free_hashTable_value);
+		//if(devices_static_ht == NULL)
+		//   printf("DEBUG: g_hash_table_new_full failed! devices_static_ht is null\n");
+		if(*devices_soft_ht == NULL)
+		    *devices_soft_ht = g_hash_table_new_full(g_str_hash,g_str_equal, free_hashTable_key, free_hashTable_value);
+		if(*devices_methods_ht == NULL)
+		    *devices_methods_ht = g_hash_table_new_full(g_str_hash, g_str_equal, free_hashTable_key,free_hashTable_value);
+	    }
+	    xmlFree(nodevalue);
+	    curnode = curnode->xmlChildrenNode;
+	    if(statuscode < 0) break;
+	}
+	else if(xmlStrcmp(curnode->name, (const xmlChar*)"device") == 0){
+	    devicecode = xmlGetProp(curnode, "code");
+	    if(devicecode == NULL){
+		fprintf(stderr, "The device hasn't code,this is invailed!\n");
+		statuscode = -1;
+		break;
+	    }
+	    // check this device is registed?
+	    _conf_device_static_t* ds_value_ptr = (_conf_device_static_t*)g_hash_table_lookup(*devices_static_ht,devicecode);
+	    if(ds_value_ptr != NULL && ds_value_ptr->is_registed != 1){
+		xmlFree(devicecode);
+		//statuscode = -1;
+		break; // Skip this device.
+	    }
+	    nodevalue = xmlGetProp(curnode, "name");
+	    if(nodevalue == NULL){
+		fprintf(stderr, "The device hasn't name,this is invailed!\n");
+		statuscode = -1;
+		xmlFree(devicecode);
+		break;
+	    }
+	    // load so
+	    devicedriver = xmlGetProp(curnode, "driver");
+	    if(devicedriver == NULL){
+		fprintf(stderr, "The device hasn't driver,this is invailed!\n");
+		statuscode = -1;
+		xmlFree(nodevalue);
+		xmlFree(devicecode); 
+		break; 
+	    }
+	    memset(filepath, 0 , DESC_BUF_LEN);
+	    snprintf(filepath, DESC_BUF_LEN, "%s/%s",WORK_ROOT_DIR,devicedriver);
+	    printf("driver path: %s\n", filepath);
+	    sharelibHandle = dlopen(filepath, RTLD_LAZY); 
+	    if(sharelibHandle == NULL){
+		fprintf(stderr, "%s sharelibHandle is NULL\n", filepath);
+		xmlFree(devicecode); 
+		statuscode = -1;
+	    }else{
+		//_add_device_to_intropect_xml(nodevalue, devicecode);
+		//_init_method_hashtable(); 
+		if(ds_value_ptr == NULL){ // new device, add to queue
+		    _upstream_cb(CONF_CBTYPE_DRIVER_ADDED,devicecode,nodevalue);
+		    dlclose(sharelibHandle);
+		    xmlFree(devicecode);
+		    xmlFree(nodevalue);
+		    xmlFree(devicedriver);
+		    break; // Skip this device;
+		}else{
+		    if(_sharelibHandle_ht == NULL)
+			_sharelibHandle_ht = g_hash_table_new_full(g_str_hash, g_str_equal,free_hashTable_key,free_hashTable_sharelib_value);
+		    char* key_ptr = (char*)malloc(strlen(devicecode)+1);
+		    snprintf(key_ptr, sizeof(key_ptr),"%s",devicecode);
+		    g_hash_table_insert(_sharelibHandle_ht,key_ptr,sharelibHandle);
+		    soft_value_ptr = (_conf_device_soft_t*)malloc(sizeof(_conf_device_soft_t));
+		    soft_value_ptr->device_code = strtol(devicecode,NULL,16);
+		    soft_value_ptr->is_online = 0;
+		    soft_value_ptr->workstate = WORK_STATE_UNKNOW;
+		    // other entry unknow.
+		    g_hash_table_insert(*devices_soft_ht,strdup(key_ptr),soft_value_ptr); // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+		   // don't usr the same key_ptr??
+		}
+	    }
+	    curnode = curnode->xmlChildrenNode;
+	    xmlFree(nodevalue);
+	    xmlFree(devicedriver);
+
+	    if(statuscode < 0) break;
+	    else continue;
+	}else if(xmlStrcmp(curnode->name, (const xmlChar*)"method") == 0){
+	    nodevalue = xmlGetProp(curnode, "name");
+	    if(nodevalue == NULL){
+		fprintf(stderr, "method hasn't name, this is invaild!\n");
+		curnode = curnode->next;
+		continue;
+	    } 
+	    methodcode = xmlGetProp(curnode, "code");
+	    if(methodcode == NULL){
+		fprintf(stderr, "method %s hasn't code, this is invaild!\n", nodevalue);
+		curnode = curnode->next;
+		xmlFree(nodevalue);
+		continue;
+	    } 
+	    methodtype = xmlGetProp(curnode, "type");
+	    if(methodtype == NULL){
+		fprintf(stderr, "method hasn't type, this is invaild!\n");
+		xmlFree(methodcode);
+		xmlFree(nodevalue);
+		curnode = curnode->next;
+		continue;
+	    }
+	    
+	    void* methodaddr = dlsym(sharelibHandle,nodevalue);
+	    conf_device_method_t* method_value_ptr = malloc(sizeof(conf_device_method_t));
+	    method_value_ptr->address = methodaddr;
+
+	    printf("method name : %s, address : %u\n", nodevalue, (unsigned int)methodaddr);
+
+	    method_value_ptr->type = strtol(methodtype,NULL,10);
+	    
+	    char* key_ptr = malloc(strlen(devicecode)+strlen(methodcode)+1);
+	    sprintf(key_ptr, "%s%s", devicecode,methodcode);
+	    printf("key: %s len=%lu\n", key_ptr, strlen(key_ptr));
+	    g_hash_table_insert(*devices_methods_ht, key_ptr, method_value_ptr); 
+	    if(xmlStrcmp(methodcode, CONF_SELFCHECK_METHOD_CODE) == 0){
+		// call self_check;
+		
+		_conf_hw_return_t result={0,0,{0}};
+		//result.desc = soft_value_ptr->desc;
+		NO_INPUT_NO_BLOCK_FUNC self_check = (NO_INPUT_NO_BLOCK_FUNC)methodaddr;
+		self_check(&result);
+		soft_value_ptr->workstate = result.state_code;
+		soft_value_ptr->exception_code = result.exception_code;
+		soft_value_ptr->is_online = (result.exception_code == 0x01)?1:0;
+		memset(soft_value_ptr->desc,0,DESC_BUF_LEN);
+		snprintf(soft_value_ptr->desc,DESC_BUF_LEN,"%s",result.desc);
+		
+	    }
+	    xmlFree(methodtype);
+	    xmlFree(nodevalue);
+	    xmlFree(methodcode);
+	}
+	curnode = curnode->next;
+    }
+    xmlFreeDoc(doc);
+    return statuscode;
+}
+int _parse_devices_state_xml(GHashTable** devices_static_ht){
+    // load state informations for all devices.
+    char path_buf[1024] = {0};
+    snprintf(path_buf, 1024, "%s/devices.%s.xml",WORK_ROOT_DIR,_upstream_dbus_name);
+    printf("DEBUG: static file path: %s\n", path_buf);
+
+    xmlNodePtr curnode;
+    xmlDocPtr doc;
+    int statuscode = 0;
+
+    xmlInitParser();
+    doc = xmlReadFile(path_buf, "UTF-8", XML_PARSE_RECOVER);
+    if(doc == NULL){
+	fprintf(stderr, "%s read failed, it exist?\n", path_buf);
+	devices_static_ht == NULL;
+	return 0;
+    }
+    curnode = xmlDocGetRootElement(doc);
+    if(curnode == NULL){
+	fprintf(stderr, "empty document\n");
+	xmlFreeDoc(doc);
+	return -1;
+    }
+    // printf("curnode->name: %s\n", curnode->name);
+    // curnode = curnode->xmlChildrenNode;
+    xmlChar* namevalue = NULL;
+    xmlChar* codevalue = NULL;
+    xmlChar* registervalue = NULL;
+
+    while(curnode != NULL){
+	if(xmlStrcmp(curnode->name, (const xmlChar*)"object") == 0){
+	    namevalue = xmlGetProp(curnode, (const xmlChar*)"name");
+	    //printf("nodevalue: %s\n", nodevalue);
+	    if(xmlStrncmp(namevalue, _upstream_object_name, strlen(_upstream_object_name)) != 0){
+		fprintf(stderr,"The object_name %s is not matched\n", namevalue);
+		statuscode = -1;
+	    }else{
+		// init hashtable
+		*devices_static_ht=g_hash_table_new_full(g_str_hash, g_str_equal, free_hashTable_key, free_hashTable_value);
+		if(*devices_static_ht == NULL){
+		    fprintf(stderr,"device_static_ht create failed\n");
+		    statuscode = -1;
+		}
+	    }
+	    xmlFree(namevalue);
+	    curnode = curnode->xmlChildrenNode;
+	    if(statuscode < 0) break;
+	}
+	else if(xmlStrcmp(curnode->name, (const xmlChar*)"device") == 0){
+	    if(devices_static_ht == NULL){
+		fprintf(stderr, "The device_static_ht is NULL, it is invaild!\n");
+		statuscode = -1;
+		break;
+	    }
+	    namevalue = xmlGetProp(curnode, "name");
+	    if(namevalue == NULL){
+		fprintf(stderr, "The device hasn't name,this is invailed!\n");
+		statuscode = -1;
+		break;
+	    }
+	    codevalue = xmlGetProp(curnode, "code");
+	    if(codevalue == NULL){
+		fprintf(stderr, "The device hasn't code,this is invailed!\n");
+		xmlFree(namevalue);
+		statuscode = -1;
+		break;
+	    }
+	    registervalue = xmlGetProp(curnode, "regist");
+	    if(registervalue == NULL){
+		fprintf(stderr, "The device no regist info, this is invailed!\n");
+		xmlFree(namevalue);
+		xmlFree(codevalue);
+		statuscode = -1;
+		break;
+	    }
+	    _conf_device_static_t* value_ptr = (_conf_device_static_t*)malloc(sizeof(_conf_device_static_t));
+	    value_ptr->device_code = strtol(codevalue,NULL,16);
+	    snprintf(value_ptr->device_name, sizeof(value_ptr->device_name),"%s",namevalue);
+	    value_ptr->is_registed = strtol(registervalue,NULL,10);
+	    char* key_ptr = (char*)malloc(strlen(codevalue)+1);
+	    snprintf(key_ptr, sizeof(key_ptr),"%s",codevalue);
+
+	    g_hash_table_insert(*devices_static_ht, key_ptr, value_ptr);
+
+	    xmlFree(namevalue);
+	    xmlFree(codevalue);
+	    xmlFree(registervalue);
+
+	    curnode = curnode->next;
+	}
+	else{
+	    fprintf(stderr,"DEBUG: Go to Next node!\n");
+	    curnode = curnode->next;
+	}
+    }
+    xmlFreeDoc(doc);
+    return statuscode;
+}
+
+int 
+conf_init(const char* dbus_name, const char* object_name,
+	GHashTable** devices_methods_ht,
+	GHashTable** devices_soft_ht,
+	GHashTable** devices_static_ht,
+	CONF_CALLBACK_FUNC upstream_callback){
+    // copy name	
+    strncpy(_upstream_dbus_name, dbus_name, MIN(strlen(dbus_name), DESC_BUF_LEN));
+    strncpy(_upstream_object_name,object_name, MIN(strlen(object_name), DESC_BUF_LEN));
+    if(upstream_callback == NULL){
+	fprintf(stderr, "_conf_callback is null!\n");
+	return -1;
+    }
+    _upstream_cb = upstream_callback;
+
+    if(_parse_devices_state_xml(devices_static_ht) < 0){
+	fprintf(stderr, "_parse_devices_state_xml failed!\n");
+	return -1;
+    }
+
+    // Loop match xml file
+    DIR *workdp;
+    struct dirent *entry;
+    if((workdp = opendir(WORK_ROOT_DIR)) == NULL){ 
+	fprintf(stderr, "opendir %s failed,no devices\n", WORK_ROOT_DIR);
+	return -1;
+    }
+    //chdir(WORK_ROOT_DIR);
+    while((entry = readdir(workdp)) != NULL){
+	if(strncmp(dbus_name,entry->d_name, strlen(dbus_name)) == 0){
+
+	    if(_parse_device_conf_xml(devices_static_ht, devices_soft_ht, devices_methods_ht,entry->d_name) < 0){
+		fprintf(stderr, "%s parse failed!\n", entry->d_name);
+	    }
+	    else{
+		printf("%s load successful\n", entry->d_name);
+	    }
+	}
+    }
+    closedir(workdp);
+	if(*devices_static_ht == NULL){
+		printf("After conf_init, devices_static_ht is null\n");
+		
+	}
+    
+    return 0;
+}
+void _hashtable_foreach_func(gpointer key, gpointer value, gpointer user_data){
+    xmlNodePtr doc_rootnode = (xmlNodePtr)user_data;
+    _conf_device_static_t* value_ptr = (_conf_device_static_t*)value;
+    xmlNodePtr devicenode = xmlNewChild(doc_rootnode, NULL, "device", "");
+    xmlNewProp(devicenode, "name", value_ptr->device_name);
+    char buf[1024] = {0};
+    snprintf(buf,1024,"0x%.2x",value_ptr->device_code);
+    xmlNewProp(devicenode, "code", buf);
+    
+    memset(buf, 0, 1024);
+    snprintf(buf,1024,"%d",value_ptr->is_registed);
+    xmlNewProp(devicenode,"regist", buf);
+}
+int 
+conf_end_writeToDisk(GHashTable* devices_static_ht){
+    if(devices_static_ht == NULL) return -1;
+    xmlDocPtr doc;
+    xmlNodePtr doc_rootnode;
+    
+    doc = xmlNewDoc("1.0");
+    doc_rootnode = xmlNewNode(NULL, "object");
+    xmlNewProp(doc_rootnode,"name", _upstream_object_name);
+    xmlDocSetRootElement(doc,doc_rootnode);
+    
+    g_hash_table_foreach(devices_static_ht,_hashtable_foreach_func,doc_rootnode);
+    
+    char filename[1024]={0};
+    snprintf(filename,1024,"%s/devices.%s.xml", WORK_ROOT_DIR, _upstream_dbus_name);
+    printf("intropect xml filename: %s\n", filename);
+    if(xmlSaveFormatFileEnc(filename, doc, "UTF-8", 1) >=0){
+	printf("Save intropectdoc xml file successful\n");
+    }else{
+	printf("Save intropectdoc xml file failed\n");
+    }
+    xmlFreeDoc(doc);
+    xmlCleanupParser();
+    
+    // free sharelibHandle_ht
+    g_hash_table_destroy(_sharelibHandle_ht);
+    _sharelibHandle_ht = NULL;  
+    return 0;
+}
+
+int 
+conf_enable_driver(const char* device_name,
+    GHashTable* devices_methods_ht,
+    GHashTable* devices_soft_ht,
+    GHashTable* devices_static_ht){
+    char filename[DESC_BUF_LEN] = {0};
+    
+    snprintf(filename, DESC_BUF_LEN,"%s.%s.xml",_upstream_dbus_name,device_name);
+    return _parse_device_conf_xml(&devices_static_ht,&devices_soft_ht,&devices_methods_ht,(const char*)filename);
+}
+
+gboolean _dm_hashTable_HRFunc(gpointer key, gpointer value,gpointer user_data){
+    char* key_ptr = (char*)key;
+    char* codevalue_ptr = (char*)user_data;
+    if(strncmp(key_ptr,codevalue_ptr,strlen(codevalue_ptr)) == 0)
+	return TRUE;
+    else
+	return FALSE;
+}
+int 
+conf_disable_driver(GHashTable* devices_methods_ht,int device_code){
+    if(_sharelibHandle_ht == NULL)
+	return 0;
+    char codevalue[10] = {0};
+    snprintf(codevalue, sizeof(codevalue),"0x%.2x",device_code);
+    
+    return g_hash_table_foreach_remove(devices_methods_ht,_dm_hashTable_HRFunc,codevalue) && g_hash_table_remove(_sharelibHandle_ht,codevalue);
+}
 
=== added file 'src/managerlayer/_configure.h'
--- src/managerlayer/_configure.h	1970-01-01 00:00:00 +0000
+++ src/managerlayer/_configure.h	2017-10-10 00:58:46 +0000
@@ -0,0 +1,51 @@
+#ifndef ___CONFIGURE_H__
+#define ___CONFIGURE_H__
+
+#include <glib.h>
+#include "manager.h"
+
+#define CONF_CBTYPE_DRIVER_CHANGED	0
+#define CONF_CBTYPE_DRIVER_ADDED 	1
+#define CONF_CBTYPE_DRIVER_REMOVED 	2
+
+#define CONF_METHOD_TYPE_HASINPUT   1
+#define CONF_METHOD_TYPE_HASBLOCK   2
+
+
+
+typedef struct{
+    void * address;
+    int type;    
+}conf_device_method_t; // This is the value of hashtable device_method_ht, key is 
+
+typedef void (*NO_INPUT_NO_BLOCK_FUNC)(void* return_ptr);
+typedef void (*NO_INPUT_BLOCK_FUNC)(void* return_ptr, int time);
+typedef void (*HAS_INPUT_NO_BLOCK_FUNC)(const char* input, void* return_ptr);
+typedef void (*HAS_INPUT_BLOCK_FUNC)(const char* input, void* return_ptr,int time);
+
+
+/**
+ * @param callback_type 0: _CONF_DRIVER_CHANGED, 1: _CONF_DRIVER_ADDED, 2: _CONF_DRIVER_REMOVED 
+ */
+typedef void (*CONF_CALLBACK_FUNC)(int callback_type, char* device_code, char* device_name);
+
+
+/**
+ * Load the configure files, then init all data structures.
+ */
+int conf_init(const char* dbus_name, const char* object_name,
+	GHashTable** devices_method_ht, 
+	GHashTable** devices_soft_ht, 
+	GHashTable** devices_static_ht, 
+	CONF_CALLBACK_FUNC);
+
+int conf_end_writeToDisk(GHashTable* devices_static_ht);
+
+int conf_enable_driver(const char* device_name,
+	GHashTable* devices_methods_ht,
+	GHashTable* devices_soft_ht,
+	GHashTable* devices_static_ht);
+
+int conf_disable_driver(GHashTable* devices_methods_ht, int device_code);
+
+#endif // ___CONFIGURE_H__
 
=== added file 'src/managerlayer/manager.c'
--- src/managerlayer/manager.c	1970-01-01 00:00:00 +0000
+++ src/managerlayer/manager.c	2017-10-10 00:58:46 +0000
@@ -0,0 +1,235 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <dlfcn.h>
+#include <dirent.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <glib.h>
+
+#include "manager.h"
+#include "_configure.h"
+
+#define DEVICE_BLOCK_METHOD_TIMEOUT    10 // seconds
+#define EXCEPTION_CODE_NO_DEVICE       	0x01
+#define EXCEPTION_CODE_NO_DEVICE_METHOD	0x02
+#define EXCEPTION_CODE_INVAILD_OP       0x04
+
+static MANAGER_CALLBACK_FUNC _upstream_cb = NULL;
+static GHashTable* _devices_static_ht = NULL;
+static GHashTable* _devices_soft_ht = NULL;
+static GHashTable* _devices_methods_ht = NULL;
+
+static void
+_deal_conf_callback(int callback_type, char* device_code, char* device_name){
+    switch(callback_type){
+    case CONF_CBTYPE_DRIVER_ADDED:{
+	manager_device_static_t* value_ptr = (manager_device_static_t*)malloc(sizeof(manager_device_static_t));
+	value_ptr->device_code = strtol(device_code,NULL,16);
+	snprintf(value_ptr->device_name,sizeof(value_ptr->device_name),"%s",device_name);
+	value_ptr->is_registed = 0;
+	char* key_ptr = (char*)malloc(strlen(device_code)+1);
+	snprintf(key_ptr,sizeof(key_ptr),"%s",device_code);
+	g_hash_table_insert(_devices_static_ht,key_ptr,value_ptr);
+	printf("finded new device: 0x%.2x,%s, %d\n",value_ptr->device_code,value_ptr->device_name,value_ptr->is_registed);
+    	break;
+	}
+    case CONF_CBTYPE_DRIVER_CHANGED:
+	break;
+    case CONF_CBTYPE_DRIVER_REMOVED:
+	break;
+    default:
+	break;
+    }
+}
+
+/************************** Interfaces ***********************************/
+int 
+manager_init(const char* dbus_name, const char* object_name, MANAGER_CALLBACK_FUNC upstream_cb){
+	if(upstream_cb == NULL){
+		fprintf(stderr, "callback_func is null!\n");
+		return -1;
+	}
+	if(dbus_name == NULL || object_name == NULL){
+		fprintf(stderr, "dbus_name or object_name is null!\n");
+		return -1;
+	}
+
+	_upstream_cb = upstream_cb;
+	printf("manager_init here\n");
+	conf_init(dbus_name, object_name,&_devices_methods_ht,&_devices_soft_ht,&_devices_static_ht,(CONF_CALLBACK_FUNC)_deal_conf_callback);
+	if(_devices_static_ht == NULL){
+		printf("After conf_init, _devices_static_ht is null\n");
+		
+	}
+	return 0;
+}
+
+int
+manager_call_device_method(int device_code, int method_code, const char* param, dbus_return_t* rt){
+    if(_devices_soft_ht == NULL || _devices_methods_ht == NULL){
+	rt->state_code = WORK_STATE_UNKNOW;
+	rt->exception_code = 0x20000;
+	snprintf(rt->desc, DESC_BUF_LEN, "The hashtable is null!");
+	return -1;
+    }
+    char codevalue[10]={0};
+    snprintf(codevalue,sizeof(codevalue),"0x%.2x",device_code);
+
+    manager_device_soft_t* soft_value_ptr = g_hash_table_lookup(_devices_soft_ht,codevalue);
+    if(soft_value_ptr == NULL){
+	rt->state_code = WORK_STATE_UNKNOW;
+	rt->exception_code = 0x20000 | EXCEPTION_CODE_NO_DEVICE;
+	snprintf(rt->desc, DESC_BUF_LEN, "The device of 0x%.2x hasn't registed.", device_code);
+	//fprintf(stderr,"The soft_value_ptr of %d not exist!\n",device_code);
+	return -1;
+    }
+    if(soft_value_ptr->workstate == WORK_STATE_PROCESSING){
+	rt->state_code = WORK_STATE_PROCESSING;
+	rt->exception_code = 0x20000| EXCEPTION_CODE_INVAILD_OP;
+	snprintf(rt->desc,DESC_BUF_LEN,"This device is processing a job,please wait!\n");
+	return -1;
+    }
+    char key[20] = {0};
+    snprintf(key,sizeof(key),"%s0x%.3x",codevalue, method_code);
+    printf("call_key: %s ,len=%lu\n", key, strlen(key));
+    
+    conf_device_method_t* method_ptr = g_hash_table_lookup(_devices_methods_ht,key);
+    if(method_ptr == NULL){
+	rt->state_code = WORK_STATE_UNKNOW;
+	rt->exception_code = 0x20000 | EXCEPTION_CODE_NO_DEVICE_METHOD;
+	snprintf(rt->desc,DESC_BUF_LEN,"The method 0x%.3x don't exist!", method_code);
+	return -1;
+    } 
+
+    if(method_ptr->type == CONF_METHOD_TYPE_HASINPUT)
+	((HAS_INPUT_NO_BLOCK_FUNC)(method_ptr->address))(param,rt);
+    else if(method_ptr->type == CONF_METHOD_TYPE_HASBLOCK)
+	((NO_INPUT_BLOCK_FUNC)(method_ptr->address))(rt,_upstream_cb);// !!!
+    else if(method_ptr->type == (CONF_METHOD_TYPE_HASBLOCK | CONF_METHOD_TYPE_HASINPUT))
+	((HAS_INPUT_BLOCK_FUNC)(method_ptr->address))(param,rt,_upstream_cb);
+    else // 0
+	((NO_INPUT_NO_BLOCK_FUNC)(method_ptr->address))(rt);
+    rt->exception_code = rt->exception_code | 0x10000;
+    rt->exception_code = rt->exception_code | (device_code<<8);
+    soft_value_ptr->workstate = rt->state_code;
+    soft_value_ptr->exception_code = rt->exception_code;
+    memset(soft_value_ptr->desc,0,DESC_BUF_LEN);
+    snprintf(soft_value_ptr->desc, DESC_BUF_LEN, "%s",rt->desc);
+
+    return 0;
+}
+const manager_device_soft_t* manager_get_device_soft_t(int device_code){
+    if(_devices_soft_ht == NULL){
+	fprintf(stderr, "This devices_soft_ht is null!!\n");
+	return NULL;
+    }
+    char codevalue[10] = {0};
+    snprintf(codevalue, sizeof(codevalue),"0x%.2x",device_code);
+    return (const manager_device_soft_t*)g_hash_table_lookup(_devices_soft_ht, codevalue);
+}
+const GList* manager_get_all_device_soft_t(){
+    if(_devices_soft_ht == NULL){
+	fprintf(stderr, "This devices_soft_ht is null!!\n");
+	return NULL;
+    }
+    return (const GList*)g_hash_table_get_values(_devices_soft_ht);
+}
+
+const manager_device_static_t* manager_get_device_static_t(int device_code){
+    if(_devices_static_ht == NULL){
+	fprintf(stderr, "This devices_static_ht is null!!\n");
+	return NULL;
+    }
+    char codevalue[10] = {0};
+    snprintf(codevalue, sizeof(codevalue),"0x%.2x",device_code);
+    return (const manager_device_static_t*)g_hash_table_lookup(_devices_static_ht, codevalue);
+}
+const GList* manager_get_all_device_static_t(){
+    if(_devices_static_ht == NULL){
+	fprintf(stderr, "This devices_static_ht is null!!\n");
+	return NULL;
+    }
+    return (GList*)g_hash_table_get_values(_devices_static_ht);
+}
+int
+manager_regist_device(int device_code, dbus_return_t* rt){
+	
+    char codevalue[10] = {0};
+    snprintf(codevalue, sizeof(codevalue),"0x%.2x",device_code);
+    manager_device_static_t* ds = g_hash_table_lookup(_devices_static_ht,codevalue);
+    if(ds == NULL){
+	rt->state_code = WORK_STATE_UNKNOW;
+        rt->exception_code = 0x20000 | EXCEPTION_CODE_NO_DEVICE;
+	snprintf(rt->desc, DESC_BUF_LEN, "The device's driver of 0x%.2x not exist!.", device_code);
+	return -1; 
+    }
+    if(ds->is_registed == 1){// had registed
+	rt->state_code = WORK_STATE_UNKNOW;
+        rt->exception_code = 0x20000 | EXCEPTION_CODE_INVAILD_OP;
+	snprintf(rt->desc, DESC_BUF_LEN, "The device of 0x%.2x had registed!.", device_code);
+	return -1; 
+    }
+    ds->is_registed = 1; 
+    if(conf_enable_driver(ds->device_name,_devices_methods_ht,_devices_soft_ht,_devices_static_ht) < 0){
+	rt->state_code = WORK_STATE_UNKNOW;
+	rt->exception_code = 0x20000 | 0x05;
+	snprintf(rt->desc, DESC_BUF_LEN, "conf_enable_driver failed!");
+    }else{
+	printf("conf_enable_driver successfully\n");
+	manager_device_soft_t * dsoft = g_hash_table_lookup(_devices_soft_ht,codevalue);
+        if(dsoft == NULL){
+		printf("dsoft is null\n");
+		rt->state_code = WORK_STATE_UNKNOW;
+		rt->exception_code = 0x20000 | EXCEPTION_CODE_NO_DEVICE;
+	}else{
+		rt->state_code = dsoft->workstate;
+		rt->exception_code = dsoft->exception_code | 0x10000;
+		rt->exception_code |= (device_code<<8);
+		snprintf(rt->desc, DESC_BUF_LEN,"%s",dsoft->desc);
+	}
+    }
+        
+    return 0;
+}
+void manager_logout_device(int device_code,dbus_return_t * rt){
+    char codevalue[10] = {0};
+    snprintf(codevalue, sizeof(codevalue),"0x%.2x",device_code);
+    manager_device_static_t* ds = g_hash_table_lookup(_devices_static_ht,codevalue);
+    if(ds == NULL){
+	rt->state_code = WORK_STATE_UNKNOW;
+        rt->exception_code = 0x20000 | EXCEPTION_CODE_NO_DEVICE;
+	snprintf(rt->desc, DESC_BUF_LEN, "The device's driver of 0x%.2x not exist!.", device_code);
+	return -1; 
+    }
+    if(ds->is_registed == 0){// had logouted
+	rt->state_code = WORK_STATE_UNKNOW;
+        rt->exception_code = 0x20000 | EXCEPTION_CODE_INVAILD_OP;
+	snprintf(rt->desc, DESC_BUF_LEN, "The device of 0x%.2x had logouted!.", device_code);
+	return -1; 
+    }
+    if(conf_disable_driver(_devices_methods_ht,device_code) < 0){
+	rt->state_code = WORK_STATE_UNKNOW;
+        rt->exception_code = 0x20000 | 0x05;
+	snprintf(rt->desc, DESC_BUF_LEN, "conf_disable_driver failed!");
+	return;
+    }else{
+	rt->state_code = WORK_STATE_UNKNOW;
+        rt->exception_code = 0x00000;
+    }
+    g_hash_table_remove(_devices_soft_ht,codevalue);
+    ds->is_registed = 0;
+
+}
+int
+manager_get_device_interfaces_info(int device_code, char* ret_desc){
+   // 
+}
+int manager_exit(){
+	g_hash_table_destroy(_devices_soft_ht);
+	g_hash_table_destroy(_devices_methods_ht);
+	conf_end_writeToDisk(_devices_static_ht);
+	return 0;
+}
 
=== added file 'src/managerlayer/manager.h'
--- src/managerlayer/manager.h	1970-01-01 00:00:00 +0000
+++ src/managerlayer/manager.h	2017-10-10 00:58:46 +0000
@@ -0,0 +1,91 @@
+#ifndef __MANAGER_H__
+#define __MANAGER_H__
+
+#define DESC_BUF_LEN	1024
+
+#define WORK_STATE_CLOSED	0
+#define WORK_STATE_IDLE		1
+#define WORK_STATE_PROCESSING	2
+#define WORK_STATE_EXCEPTION	3
+#define WORK_STATE_UNKNOW	4
+
+#define RETURN_ERRNO_OK		0
+#define RETURN_ERRNO_WARNING	1
+#define RETURN_ERRNO_EXCEPTION	2
+#define RETURN_ERRNO_UNKNOW	4
+
+
+typedef struct{
+	int device_code;		// Example : 0x02
+	int is_online;			// true or false
+	int workstate;			// every device has a state machine 0: closed 1: idle 2: Processing 3: Exception
+	int exception_code;		// if state=Exception, exception_code is the specific exception code.
+	char desc[DESC_BUF_LEN];// the decription of exception;
+
+}manager_device_soft_t; // There infomations will be updated by software at most case.
+
+typedef struct{
+	int device_code;
+	char device_name[5] ;	// The simple name. Example: idr, br, prt
+	//char manufactire[100]; 
+	//char serial[100];
+	int is_registed;		// true or false
+}manager_device_static_t; // There infomation is static at most case.
+
+typedef struct{
+	int state_code;
+	int exception_code;
+	char desc[DESC_BUF_LEN];
+}dbus_return_t;
+
+typedef dbus_return_t hw_return_t;
+
+typedef struct{
+	int error_no;
+	int device_code;
+	int method_code;
+	char* info;
+}manager_callback_return_t;
+
+typedef void (*MANAGER_CALLBACK_FUNC)(manager_callback_return_t*);
+/**
+ * Load all device's configure file, then build the
+ * main data structures: device_method hashtable, 
+ * device_state struct array.
+ * @param dbus_name the name of dbus, Example : com.jd.test
+ * @param object_name the one object of dbus_name
+ * @param CALLBACK_FUNC initiative feedback infomations to upstearm caller.
+ * @return 0 successful, 1 failed.
+ */
+int manager_init(const char* dbus_name, const char* object_name, MANAGER_CALLBACK_FUNC);
+
+/**
+  * Call the device method by devicecode and methodcode point.
+  * @param If this device method need a param
+  * @error_no the device method invoke return statuscode
+  * @count
+  * @desc The describtion about the error_no
+  * @return 0 successful ; 1 failed
+ */
+int manager_call_device_method(int devicecode, int methodcode,const char* param, dbus_return_t*);
+
+/**
+ * Get the current device's info struct. 
+ */
+const manager_device_soft_t* manager_get_device_soft_t(int device_code);
+const GList* manager_get_all_device_soft_t();
+
+const manager_device_static_t* manager_get_device_static_t(int device_code);
+const GList* manager_get_all_device_static_t();
+
+int manager_regist_device(int device_code,dbus_return_t*);
+void manager_logout_device(int device_code,dbus_return_t*);
+/**
+ * Get the device's interfaces info.
+ * @param device_code, the code of device
+ * @param ret_desc, the infomation storage location.
+ * @return 0 successful;  -1 failed
+ */
+int manager_get_device_interfaces_info(int device_code, char* ret_desc);
+int manager_exit();
+#endif // __MANAGER_H__