Care the PD Created/Destroyed EVENT again.

Change-Id: I2323ac675568cb90ae1d27b69a0ac5cce652c7b4

diff --git a/include/livebox.h b/include/livebox.h
index b44bdda..b9c384c 100644 (file)
--- a/include/livebox.h
+++ b/include/livebox.h
@@ -76,6 +76,9 @@ enum livebox_event_type { /*!< livebox_event_handler_set Event list */
        LB_EVENT_PINUP_CHANGED, /*!< PINUP status is changed */
        LB_EVENT_PERIOD_CHANGED, /*!< Update period is changed */
 
+       LB_EVENT_PD_CREATED, /*!< If a PD is created even if you didn't call the livebox_create_pd API */
+       LB_EVENT_PD_DESTROYED, /*!< If a PD is destroyed even if you didn't call the livebox_destroy_pd API */
+
        LB_EVENT_IGNORED, /*!< Request is ignored */
 };
 

diff --git a/include/livebox_internal.h b/include/livebox_internal.h
index e6d87dc..a463426 100644 (file)
--- a/include/livebox_internal.h
+++ b/include/livebox_internal.h
@@ -116,6 +116,12 @@ struct livebox {
 
        ret_cb_t period_changed_cb;
        void *period_cbdata;
+
+       ret_cb_t pd_created_cb;
+       void *pd_created_cbdata;
+
+       ret_cb_t pd_destroyed_cb;
+       void *pd_destroyed_cbdata;
 };
 
 /* End of a file */

diff --git a/src/client.c b/src/client.c
index 499d75c..d41af0a 100644 (file)
--- a/src/client.c
+++ b/src/client.c
@@ -59,7 +59,8 @@ static struct packet *master_pinup(pid_t pid, int handle, const struct packet *p
        int ret;
        int pinup;
 
-       if (packet_get(packet, "iisss", &ret, &pinup, &pkgname, &id, &content) != 5) {
+       ret = packet_get(packet, "iisss", &ret, &pinup, &pkgname, &id, &content);
+       if (ret != 5) {
                ErrPrint("Invalid argument\n");
                ret = -EINVAL;
                goto out;
@@ -247,6 +248,108 @@ out:
        return NULL;
 }
 
+static struct packet *master_pd_created(pid_t pid, int handle, const struct packet *packet)
+{
+       struct livebox *handler;
+       const char *pkgname;
+       const char *id;
+       const char *buf_id;
+       int width;
+       int height;
+       int ret;
+       int status;
+
+       ret = packet_get(packet, "sssiii", &pkgname, &id, &buf_id, &width, &height, &status);
+       if (ret != 6) {
+               ErrPrint("Invalid argument\n");
+               goto out;
+       }
+
+       handler = lb_find_livebox(pkgname, id);
+       if (!handler) {
+               ret = -ENOENT;
+               goto out;
+       }
+
+       if (handler->state != CREATE) {
+               ret = -EPERM;
+               goto out;
+       }
+
+       lb_set_pdsize(handler, width, height);
+       if (lb_text_pd(handler)) {
+               DbgPrint("Text TYPE does not need to handle this\n");
+       } else {
+               (void)lb_set_pd_fb(handler, buf_id);
+               ret = fb_sync(lb_get_pd_fb(handler));
+               if (ret < 0) {
+                       ErrPrint("Failed to do sync FB (%s - %s)\n",
+                                       pkgname,
+                                       util_basename(util_uri_to_path(id)));
+               }
+       }
+
+       handler->is_pd_created = (status == 0);
+
+       if (handler->pd_created_cb) {
+               DbgPrint("pd_created_cb (%s) - %d\n", buf_id, status);
+               handler->pd_created_cb(handler, status, handler->pd_created_cbdata);
+
+               handler->pd_created_cb = NULL;
+               handler->pd_created_cbdata = NULL;
+       } else if (status == 0) {
+               DbgPrint("LB_EVENT_PD_CREATED (%s) - %d\n", buf_id, status);
+               lb_invoke_event_handler(handler, LB_EVENT_PD_CREATED);
+       }
+
+       ret = 0;
+out:
+       return NULL;
+}
+
+static struct packet *master_pd_destroyed(pid_t pid, int handle, const struct packet *packet)
+{
+       struct livebox *handler;
+       const char *pkgname;
+       const char *id;
+       int ret;
+       int status;
+
+       ret = packet_get(packet, "ssi", &pkgname, &id, &status);
+       if (ret != 3) {
+               ErrPrint("Invalid argument\n");
+               goto out;
+       }
+
+       handler = lb_find_livebox(pkgname, id);
+       if (!handler) {
+               ret = -ENOENT;
+               goto out;
+       }
+
+       if (handler->state != CREATE) {
+               ret = -EPERM;
+               goto out;
+       }
+
+       handler->is_pd_created = 0;
+
+       if (handler->pd_destroyed_cb) {
+               DbgPrint("Invoke the PD Destroyed CB\n");
+               handler->pd_destroyed_cb(handler, status, handler->pd_destroyed_cbdata);
+
+               handler->pd_destroyed_cb = NULL;
+               handler->pd_destroyed_cbdata = NULL;
+       } else if (status == 0) {
+               DbgPrint("Invoke the LB_EVENT_PD_DESTROYED event\n");
+               lb_invoke_event_handler(handler, LB_EVENT_PD_DESTROYED);
+       }
+
+       ret = 0;
+out:
+       return NULL;
+}
+
 static struct packet *master_pd_updated(pid_t pid, int handle, const struct packet *packet)
 {
        const char *pkgname;
@@ -288,14 +391,15 @@ static struct packet *master_pd_updated(pid_t pid, int handle, const struct pack
        lb_set_pdsize(handler, pd_w, pd_h);
 
        if (lb_text_pd(handler)) {
-               ret = parse_desc(handler, util_uri_to_path(id), 1);
+               ret = parse_desc(handler, descfile, 1);
        } else {
                (void)lb_set_pd_fb(handler, fbfile);
 
                ret = fb_sync(lb_get_pd_fb(handler));
                if (ret < 0) {
                        ErrPrint("Failed to do sync FB (%s - %s)\n",
-                                       pkgname, util_basename(util_uri_to_path(id)));
+                                       pkgname,
+                                       util_basename(util_uri_to_path(id)));
                        goto out;
                }
 
@@ -614,6 +718,14 @@ static struct method s_table[] = {
                .handler = master_pd_updated,
        },
        {
+               .cmd = "pd_created",
+               .handler = master_pd_created,
+       },
+       {
+               .cmd = "pd_destroyed",
+               .handler = master_pd_destroyed,
+       },
+       {
                .cmd = "fault_package", /* pkgname, id, function, ret */
                .handler = master_fault_package,
        },

diff --git a/src/livebox.c b/src/livebox.c
index c1d510d..14b7405 100644 (file)
--- a/src/livebox.c
+++ b/src/livebox.c
@@ -34,7 +34,7 @@ static struct info {
        .livebox_list = NULL,
        .event_list = NULL,
        .fault_list = NULL,
-       .event_interval = 0.5f,
+       .event_interval = 0.01f,
 };
 
 struct cb_info {
@@ -77,6 +77,16 @@ static inline void default_period_changed_cb(struct livebox *handler, int ret, v
        DbgPrint("Default period changed event handler: %d\n", ret);
 }
 
+static inline void default_pd_created_cb(struct livebox *handler, int ret, void *data)
+{
+       DbgPrint("Default PD created event handler: %d\n", ret);
+}
+
+static inline void default_pd_destroyed_cb(struct livebox *handler, int ret, void *data)
+{
+       DbgPrint("Default PD destroyed event handler: %d\n", ret);
+}
+
 static inline struct cb_info *create_cb_info(ret_cb_t cb, void *data)
 {
        struct cb_info *info;
@@ -279,41 +289,35 @@ static void new_ret_cb(struct livebox *handler, const struct packet *result, voi
        destroy_cb_info(info);
 
        if (!result) {
-               if (cb)
-                       cb(handler, -EFAULT, cbdata);
-
-               lb_unref(handler);
-               return;
-       }
-
-       if (packet_get(result, "i", &ret) != 1) {
-               if (cb)
-                       cb(handler, -EINVAL, cbdata);
-
-               lb_unref(handler);
-               return;
+               ret = -EFAULT;
+       } else if (packet_get(result, "i", &ret) != 1) {
+               ret = -EINVAL;
        }
 
        if (ret >= 0) {
                DbgPrint("new request is sent, just waiting the created event\n");
                handler->created_cb = cb;
                handler->created_cbdata = cbdata;
-               return;
-       }
 
-       /*!
-        * \note
-        * It means the current instance is not created,
-        * so user has to know about this.
-        * notice it to user using "deleted" event.
-        */
-       if (cb)
+               /*!
+                * \note
+                * Don't go anymore ;)
+                */
+               return;
+       } else if (cb) {
+               /*!
+                * \note
+                * It means the current instance is not created,
+                * so user has to know about this.
+                * notice it to user using "deleted" event.
+                */
                cb(handler, ret, cbdata);
+       }
 
        lb_unref(handler);
 }
 
-static void pd_created_cb(struct livebox *handler, const struct packet *result, void *data)
+static void pd_create_cb(struct livebox *handler, const struct packet *result, void *data)
 {
        struct cb_info *info = data;
        void *cbdata;
@@ -325,35 +329,19 @@ static void pd_created_cb(struct livebox *handler, const struct packet *result,
        destroy_cb_info(data);
 
        if (!result) {
-               if (cb)
-                       cb(handler, -EFAULT, cbdata);
-               return;
-       }
-
-       if (packet_get(result, "i", &ret) != 1) {
-               if (cb)
-                       cb(handler, -EINVAL, cbdata);
-               return;
-       }
-
-       if (ret < 0) {
-               DbgPrint("Livebox returns %d\n", ret);
-               if (cb)
-                       cb(handler, ret, cbdata);
-               return;
-       }
-
-       if (!handler->pd.data.fb) {
-               DbgPrint("Failed to create a PD (FB is not valid)\n");
-               if (cb)
-                       cb(handler, -EFAULT, cbdata);
-               return;
+               ret = -EFAULT;
+       } else if (packet_get(result, "i", &ret) != 1) {
+               ret = -EINVAL;
        }
 
-       handler->is_pd_created = 1;
-
-       if (cb)
+       if (ret == 0) {
+               DbgPrint("PD Created event handler prepared\n");
+               handler->pd_created_cb = cb;
+               handler->pd_created_cbdata = cbdata;
+       } else if (cb) {
+               DbgPrint("Failed to create a PD\n");
                cb(handler, ret, cbdata);
+       }
 }
 
 static void activated_cb(struct livebox *handler, const struct packet *result, void *data)
@@ -369,15 +357,9 @@ static void activated_cb(struct livebox *handler, const struct packet *result, v
        destroy_cb_info(info);
 
        if (!result) {
-               if (cb)
-                       cb(handler, -EFAULT, cbdata);
-               return;
-       }
-
-       if (packet_get(result, "is", &ret, &pkgname) != 2) {
-               if (cb)
-                       cb(handler, -EINVAL, cbdata);
-               return;
+               ret = -EFAULT;
+       } else if (packet_get(result, "is", &ret, &pkgname) != 2) {
+               ret = -EINVAL;
        }
 
        if (cb)
@@ -396,21 +378,22 @@ static void pd_destroy_cb(struct livebox *handler, const struct packet *result,
        destroy_cb_info(info);
 
        if (!result) {
-               if (cb)
-                       cb(handler, -EFAULT, cbdata);
-               return;
-       }
-
-       if (packet_get(result, "i", &ret) != 1) {
-               if (cb)
-                       cb(handler, -EINVAL, cbdata);
-               return;
+               DbgPrint("Result is NIL (may connection lost)\n");
+               ret = -EFAULT;
+       } else if (packet_get(result, "i", &ret) != 1) {
+               DbgPrint("Invalid parameter\n");
+               ret = -EINVAL;
        }
 
-       handler->is_pd_created = 0;
-
-       if (cb)
+       if (ret == 0) {
+               DbgPrint("PD Destroyed callback prepared\n");
+               handler->pd_destroyed_cb = cb;
+               handler->pd_destroyed_cbdata = cbdata;
+       } else if (cb) {
+               DbgPrint("PD is not desroyed (forcely reset, pd flag)\n");
+               handler->is_pd_created = 0;
                cb(handler, ret, cbdata);
+       }
 }
 
 static void delete_cluster_cb(struct livebox *handler, const struct packet *result, void *data)
@@ -426,9 +409,8 @@ static void delete_cluster_cb(struct livebox *handler, const struct packet *resu
 
        if (!result) {
                ret = -EFAULT;
-       } else {
-               if (packet_get(result, "i", &ret) != 1)
-                       ret = -EINVAL;
+       } else if (packet_get(result, "i", &ret) != 1) {
+               ret = -EINVAL;
        }
 
        DbgPrint("Delete category returns: %d\n", ret);
@@ -909,7 +891,10 @@ EAPI int livebox_create_pd(struct livebox *handler, ret_cb_t cb, void *data)
                return -EFAULT;
        }
 
-       return master_rpc_async_request(handler, packet, 0, pd_created_cb, create_cb_info(cb, data));
+       if (!cb)
+               handler->pd_created_cb = default_pd_created_cb;
+
+       return master_rpc_async_request(handler, packet, 0, pd_create_cb, create_cb_info(cb, data));
 }
 
 EAPI int livebox_activate(const char *pkgname, ret_cb_t cb, void *data)
@@ -953,6 +938,9 @@ EAPI int livebox_destroy_pd(struct livebox *handler, ret_cb_t cb, void *data)
                return -EFAULT;
        }
 
+       if (!cb)
+               cb = default_pd_destroyed_cb;
+
        return master_rpc_async_request(handler, packet, 0, pd_destroy_cb, create_cb_info(cb, data));
 }
 
@@ -1250,6 +1238,11 @@ EAPI int livebox_get_supported_sizes(struct livebox *handler, int *cnt, int *w,
        register int i;
        register int j;
 
+       /*!
+        * \TODO:
+        * Replace this with DB Manipulate function
+        */
+
        if (!handler) {
                ErrPrint("Handler is NIL\n");
                return -EINVAL;
@@ -2080,7 +2073,11 @@ static inline char *get_file_kept_in_safe(const char *id)
         * \TODO: REMOVE ME
         */
        if (getenv("DISABLE_PREVENT_OVERWRITE")) {
-               return strdup(path);
+               new_path = strdup(path);
+               if (!new_path)
+                       ErrPrint("Heap: %s\n", strerror(errno));
+
+               return new_path;
        }
 
        len = strlen(path);