Fix to follow coding convention

[platform/core/connectivity/zigbee-manager.git] / zigbee-daemon / zigbee-lib / src / zblib_driver.c

diff --git a/zigbee-daemon/zigbee-lib/src/zblib_driver.c b/zigbee-daemon/zigbee-lib/src/zblib_driver.c
index 4d2bb78..e1d36cd 100644 (file)
--- a/zigbee-daemon/zigbee-lib/src/zblib_driver.c
+++ b/zigbee-daemon/zigbee-lib/src/zblib_driver.c
@@ -18,11 +18,18 @@
 
 #include <zblib.h>
 #include <zblib_driver.h>
+#include <zblib_plugin.h>
+#include <zblib_service.h>
+#include <zblib_request.h>
 
 /**< ZigBee driver object */
 struct zblib_driver_type {
-       gint object_type; /**< ZigBee driver object type */
-       gchar *object_name; /**< ZigBee driver object name */
+       ZblibDriverType_e driver_type; /**< ZigBee driver type */
+       gchar *driver_name; /**< ZigBee driver name */
+       gpointer priv_object; /**< ZigBee driver private data */
+
+       ZblibDriverDispatcher_t dispatcher_fn; /**< Driver operations dispatcher function */
+       ZblibDriverFreeHook_t free_hook_fn; /**< Driver free hook function */
 
        ZigBeePlugin *plugin; /**< ZigBee Plug-in */
 
@@ -30,8 +37,8 @@ struct zblib_driver_type {
 };
 
 ZigBeeDriver *zblib_driver_new(ZigBeePlugin *plugin,
-       const gchar *object_name,
-       gint object_type)
+       const gchar *driver_name,
+       ZblibDriverType_e driver_type)
 {
        ZigBeeDriver *driver = NULL;
 
@@ -39,21 +46,158 @@ ZigBeeDriver *zblib_driver_new(ZigBeePlugin *plugin,
        driver = g_malloc0(sizeof(ZigBeeDriver));
 
        /* Update fields */
-       driver->object_type = object_type;
-       driver->object_name = g_strdup(object_name);
+       driver->driver_type = driver_type;
+       driver->driver_name = g_strdup(driver_name);
        driver->plugin = plugin;
 
-       Z_LOGI("Driver created - Name [%s]", driver->object_name);
+       Z_LOGI("Driver created - Name [%s]", driver->driver_name);
 
        return driver;
 }
 
 void zblib_driver_free(ZigBeeDriver *driver)
 {
-       if (driver == NULL) {
-               Z_LOGE("driver is NULL");
-               return;
-       }
+       zblib_check_null_ret("driver", driver);
+
+       /* Invoke free hook */
+       if (driver->free_hook_fn)
+               driver->free_hook_fn(driver);
+
+       Z_LOGI("Freeing Driver[%p] - Name [%s]", driver, driver->driver_name);
+
+       /* Free driver memory */
+       g_free(driver->driver_name);
+       g_free(driver);
+}
+
+ZigBeeService *zblib_driver_ref_service(ZigBeeDriver *driver)
+{
+       zblib_check_null_ret_error("driver", driver, NULL);
+
+       return driver->service;
+}
+
+gboolean zblib_driver_link_service(ZigBeeDriver *driver,
+       ZigBeeService *service)
+{
+       zblib_check_null_ret_error("driver", driver, FALSE);
+       zblib_check_null_ret_error("service", service, FALSE);
+
+       driver->service = service;
+
+       return TRUE;
+}
+
+ZigBeePlugin *zblib_driver_ref_plugin(ZigBeeDriver *driver)
+{
+       zblib_check_null_ret_error("driver", driver, NULL);
+
+       return driver->plugin;
+}
+
+gboolean zblib_driver_link_object(ZigBeeDriver *driver,
+       gpointer object)
+{
+       zblib_check_null_ret_error("driver", driver, FALSE);
+
+       driver->priv_object = object;
+
+       return TRUE;
+}
+
+gpointer zblib_driver_ref_object(ZigBeeDriver *driver)
+{
+       zblib_check_null_ret_error("driver", driver, NULL);
+
+       return driver->priv_object;
+}
+
+gboolean zblib_driver_set_dispatcher(ZigBeeDriver *driver,
+       ZblibDriverDispatcher_t dispatcher_fn)
+{
+       zblib_check_null_ret_error("driver", driver, FALSE);
+
+       driver->dispatcher_fn = dispatcher_fn;
+
+       return TRUE;
+}
+
+gboolean zblib_driver_set_free_hook(ZigBeeDriver *driver,
+       ZblibDriverFreeHook_t free_hook_fn)
+{
+       zblib_check_null_ret_error("driver", driver, FALSE);
+
+       driver->free_hook_fn = free_hook_fn;
+
+       return TRUE;
+}
+
+ZblibDriverType_e zblib_driver_ref_driver_type(ZigBeeDriver *driver)
+{
+       if (NULL == driver)
+               return ZBLIB_DRIVER_TYPE_NONE;
+
+       return driver->driver_type;
+}
+
+gpointer zblib_driver_ref_request_data(ZigBeeDriver *driver,
+       guint request_id)
+{
+       ZigBeeService *service = NULL;
+
+       zblib_check_null_ret_error("driver", driver, NULL);
+
+       service = driver->service;
+       zblib_check_null_ret_error("service", service, NULL);
+
+       /* Fetch request data */
+       return zblib_request_ref_request_data_by_id(service,
+               request_id);
+}
+
+gboolean zblib_driver_dispatch_request(ZigBeeDriver *driver,
+       guint request_id)
+{
+       zblib_check_null_ret_error("driver", driver, FALSE);
+       zblib_check_null_ret_error("driver->dispatcher_fn",
+               driver->dispatcher_fn, FALSE);
+
+       /* Dispatch request to driver dispatcher function */
+       return driver->dispatcher_fn(driver, request_id);
+}
+
+void zblib_driver_send_response(ZigBeeDriver *driver,
+       guint request_id, gpointer resp_data, guint resp_data_len)
+{
+       ZigBeePlugin *plugin = NULL;
+
+       zblib_check_null_ret("driver", driver);
+
+       plugin = driver->plugin;
+       zblib_check_null_ret("plugin", plugin);
+
+       /* Send response to plugin */
+       zblib_plugin_send_response(plugin,
+               request_id, resp_data, resp_data_len);
+}
+
+void zblib_driver_send_notification(ZigBeeDriver *driver,
+       guint noti_id, gpointer noti_data, guint noti_data_len)
+{
+       guint driver_noti_id;
+       ZigBeePlugin *plugin = NULL;
+       ZblibDriverType_e driver_type;
+
+       zblib_check_null_ret("driver", driver);
+
+       driver_type = driver->driver_type;
+
+       plugin = driver->plugin;
+       zblib_check_null_ret("plugin", plugin);
+
+       driver_noti_id = (driver_type << 24) | noti_id;
 
-       Z_LOGI("Freeing Driver - Name [%p]", driver->object_name);
+       /* Send notification to plugin */
+       zblib_plugin_send_notification(plugin,
+               driver_noti_id, noti_data, noti_data_len);
 }