usb: add DeviceBlocked signal callback

Change-Id: Iff966d5659abb89334effac3154ae36c75b908d8
Signed-off-by: Jehun Lim <jehun.lim@samsung.com>

diff --git a/include/util/usb.h b/include/util/usb.h
index cc19546..0166495 100644 (file)
--- a/include/util/usb.h
+++ b/include/util/usb.h
@@ -17,12 +17,21 @@
 #ifndef __AIR_MEDIAHUB_USB_H__
 #define __AIR_MEDIAHUB_USB_H__
 
+#define USB_ADDED 1
+#define USB_REMOVED 0
+
 struct usb;
 
+enum usb_signal {
+       E_DEVICE_BLOCKED,
+       E_DEVICE_CHANGED,
+       E_SIGNAL_MAX
+};
+
 struct usb *usb_create(void);
 void usb_destroy(struct usb *m);
 
-int usb_set_callback(struct usb *m, void (*func)(void *, int),
-                       void *data);
+void usb_set_callback(struct usb *m, int sig,
+                       void (*func)(void *, int), void *data);
 
 #endif /* __AIR_MEDIAHUB_USB_H__ */

diff --git a/src/util/usb.c b/src/util/usb.c
index 001b72d..90fafb1 100644 (file)
--- a/src/util/usb.c
+++ b/src/util/usb.c
@@ -19,32 +19,61 @@
 #include <app_debug.h>
 #include <gio/gio.h>
 
-#define DEVICED_BUS_NAME "org.tizen.system.deviced"
+#include "util/usb.h"
+
 #define DEVICED_INTERFACE_BLOCK "org.tizen.system.deviced.Block"
 
+#define SIGNAL_DEVICE_BLOCKED "DeviceBlocked"
 #define SIGNAL_DEVICE_CHANGED "DeviceChanged"
 
-struct _changed_cb {
+typedef void (*sig_cb_func)(GDBusConnection *connection,
+                       const gchar *sender_name, const gchar *object_path,
+                       const gchar *interface_name, const gchar *signal_name,
+                       GVariant *parameters, gpointer user_data);
+
+static void _device_blocked_cb(GDBusConnection *, const gchar *, const gchar *,
+                       const gchar *, const gchar *, GVariant *, gpointer);
+static void _device_changed_cb(GDBusConnection *, const gchar *, const gchar *,
+                       const gchar *, const gchar *, GVariant *, gpointer);
+
+struct _signal_info {
+       const char *interface;
+       const char *sig_name;
+       sig_cb_func sig_cb;
+};
+
+static struct _signal_info g_signal_info[E_SIGNAL_MAX] = {
+       [E_DEVICE_BLOCKED] = {
+               DEVICED_INTERFACE_BLOCK,
+               SIGNAL_DEVICE_BLOCKED,
+               _device_blocked_cb
+       },
+       [E_DEVICE_CHANGED] = {
+               DEVICED_INTERFACE_BLOCK,
+               SIGNAL_DEVICE_CHANGED,
+               _device_changed_cb
+       }
+};
+
+struct _cb_data {
        void (*func)(void *data, int state);
        void *data;
 };
 
 struct usb {
        GDBusConnection *conn;
-       guint id;
-       struct _changed_cb cb;
+       int sub_id[E_SIGNAL_MAX];
+       struct _cb_data cb[E_SIGNAL_MAX];
 };
 
-static void _device_changed_cb(GDBusConnection *connection,
+static void _device_blocked_cb(GDBusConnection *connection,
                        const gchar *sender_name, const gchar *object_path,
                        const gchar *interface_name, const gchar *signal_name,
                        GVariant *parameters, gpointer user_data)
 {
-       const gchar *devNode, *sysPath, *fsUsage, *fsType, *fsVer, *fsUuid;
-       const gchar *mountPoint;
-       gint32 blockType, readOnly, state;
-       gboolean primary;
+       const gchar *uuid, *mount_point;
        struct usb *m;
+       int sig;
 
        if (!parameters || !user_data) {
                _ERR("invalid argument");
@@ -53,35 +82,69 @@ static void _device_changed_cb(GDBusConnection *connection,
 
        m = user_data;
 
-       g_variant_get(parameters, "(issssssisib)", &blockType, &devNode,
-                               &sysPath, &fsUsage, &fsType, &fsVer, &fsUuid,
-                               &readOnly, &mountPoint, &state, &primary);
+       g_variant_get(parameters, "(ss)", &uuid, &mount_point);
+
+       sig = E_DEVICE_BLOCKED;
 
-       if (m->cb.func)
-               m->cb.func(m->cb.data, state);
+       if (m->cb[sig].func)
+               m->cb[sig].func(m->cb[sig].data, USB_REMOVED);
 }
 
-void usb_set_callback(void *handle, void (*func)(void *, int), void *data)
+static void _device_changed_cb(GDBusConnection *connection,
+                       const gchar *sender_name, const gchar *object_path,
+                       const gchar *interface_name, const gchar *signal_name,
+                       GVariant *parameters, gpointer user_data)
 {
+       const gchar *dev_node, *sys_path;
+       const gchar *fs_usage, *fs_type, *fs_ver, *fs_uuid;
+       const gchar *mount_point;
+       gint32 block_type, read_only, state;
+       gboolean primary;
        struct usb *m;
+       int sig;
 
-       if (!handle) {
+       if (!parameters || !user_data) {
+               _ERR("invalid argument");
+               return;
+       }
+
+       m = user_data;
+
+       g_variant_get(parameters, "(issssssisib)", &block_type, &dev_node,
+                               &sys_path, &fs_usage, &fs_type, &fs_ver,
+                               &fs_uuid, &read_only, &mount_point,
+                               &state, &primary);
+
+       sig = E_DEVICE_CHANGED;
+
+       if (m->cb[sig].func)
+               m->cb[sig].func(m->cb[sig].data, state);
+}
+
+void usb_set_callback(struct usb *m, int sig,
+                       void (*func)(void *, int), void *data)
+{
+       if (!m) {
                _ERR("failed to get usb handle");
                return;
        }
 
-       m = handle;
+       if (sig < 0 || sig >= E_SIGNAL_MAX) {
+               _ERR("invalid argument");
+               return;
+       }
 
-       m->cb.func = func;
-       m->cb.data = data;
+       m->cb[sig].func = func;
+       m->cb[sig].data = data;
 }
 
 struct usb *usb_create(void)
 {
        GDBusConnection *conn;
        GError *error;
-       guint id;
        struct usb *m;
+       struct _signal_info si;
+       int i;
 
        m = calloc(1, sizeof(*m));
        if (!m) {
@@ -100,25 +163,31 @@ struct usb *usb_create(void)
                return NULL;
        }
 
-       id = g_dbus_connection_signal_subscribe(conn, NULL,
-                               DEVICED_INTERFACE_BLOCK, SIGNAL_DEVICE_CHANGED,
-                               NULL, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
-                               _device_changed_cb, m, NULL);
+       for (i = 0; i < E_SIGNAL_MAX; i++) {
+               si = g_signal_info[i];
+
+               m->sub_id[i] = g_dbus_connection_signal_subscribe(conn, NULL,
+                                       si.interface, si.sig_name, NULL, NULL,
+                                       G_DBUS_SIGNAL_FLAGS_NONE,
+                                       si.sig_cb, m, NULL);
+       }
 
        m->conn = conn;
-       m->id = id;
 
        return m;
 }
 
 void usb_destroy(struct usb *m)
 {
+       int i;
+
        if (!m) {
                _ERR("failed to get usb handle");
                return;
        }
 
-       g_dbus_connection_signal_unsubscribe(m->conn, m->id);
+       for (i = 0; i < E_SIGNAL_MAX; i++)
+               g_dbus_connection_signal_unsubscribe(m->conn, m->sub_id[i]);
 
        free(m);
 }

diff --git a/src/view/base.c b/src/view/base.c
index b44b498..abb826a 100644 (file)
--- a/src/view/base.c
+++ b/src/view/base.c
@@ -41,9 +41,6 @@
 #define TEXT_USB_ADDED "USB Connected"
 #define TEXT_USB_REMOVED "USB Disconnected"
 
-#define USB_ADDED 1
-#define USB_REMOVED 0
-
 #define BOX_PADDING_SIZE 80
 
 #define TIME_TOAST 5.0
@@ -832,10 +829,21 @@ static void _media_db_updated_cb(media_content_error_e error,
        _hide_toast(priv);
 }
 
+static void _show_base_view(void)
+{
+       struct view_update_data vdata;
+
+       vdata.status = E_PLAYER_STOP;
+       viewmgr_update_view(VIEW_MPLAYER, UPDATE_PLAYER, &vdata);
+
+       /* to show base view */
+       while (viewmgr_active_view_count() > 1)
+               viewmgr_pop_view();
+}
+
 static void _usb_changed_cb(void *data, int state)
 {
        media_content_noti_h noti_h;
-       struct view_update_data vdata;
        struct _priv *priv;
        int r;
 
@@ -851,16 +859,17 @@ static void _usb_changed_cb(void *data, int state)
 
        priv->noti_h = noti_h;
 
-       vdata.status = E_PLAYER_STOP;
-       viewmgr_update_view(VIEW_MPLAYER, UPDATE_PLAYER, &vdata);
-
-       /* to show base view */
-       while (viewmgr_active_view_count() > 1)
-               viewmgr_pop_view();
+       if (state == USB_ADDED)
+               _show_base_view();
 
        _show_toast_usb(priv, state);
 }
 
+static void _usb_blocked_cb(void *data, int state)
+{
+       _show_base_view();
+}
+
 static Evas_Object *_create(Evas_Object *win, void *data)
 {
        struct usb *usb_h;
@@ -904,7 +913,8 @@ static Evas_Object *_create(Evas_Object *win, void *data)
                return NULL;
        }
 
-       usb_set_callback(usb_h, _usb_changed_cb, priv);
+       usb_set_callback(usb_h, E_DEVICE_BLOCKED, _usb_blocked_cb, priv);
+       usb_set_callback(usb_h, E_DEVICE_CHANGED, _usb_changed_cb, priv);
 
        priv->usb_h = usb_h;