X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fclient.c;h=25d039527081465c64621998afe1d49ff2f9b9d9;hb=377fe7dfdc182299183fc08bbd31a2c14f5d7a42;hp=e4322bcd1ab28c14668e2ee10722ef7db1cf9241;hpb=326017e6f984ffcf30a5ee86f6d9e27f506b1bce;p=platform%2Fframework%2Fweb%2Flivebox-viewer.git diff --git a/src/client.c b/src/client.c index e4322bc..25d0395 100644 --- a/src/client.c +++ b/src/client.c @@ -1,7 +1,7 @@ /* * Copyright 2013 Samsung Electronics Co., Ltd * - * Licensed under the Flora License, Version 1.0 (the "License"); + * Licensed under the Flora License, Version 1.1 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * @@ -19,6 +19,7 @@ #include #include #include +#include #include #include @@ -30,6 +31,8 @@ #include #include #include +#include +#include #include "debug.h" #include "client.h" @@ -40,12 +43,19 @@ #include "util.h" #include "master_rpc.h" #include "conf.h" -#include "critical_log.h" +#include "file_service.h" +#include "dlist.h" + +int errno; static struct info { int fd; + guint timer_id; + char *client_addr; } s_info = { .fd = -1, + .timer_id = 0, + .client_addr = NULL, }; static struct packet *master_fault_package(pid_t pid, int handle, const struct packet *packet) @@ -59,19 +69,21 @@ static struct packet *master_fault_package(pid_t pid, int handle, const struct p return NULL; } + DbgPrint("[%s]\n", pkgname); master_rpc_clear_fault_package(pkgname); lb_invoke_fault_handler(LB_FAULT_DEACTIVATED, pkgname, id, function); - DbgPrint("%s(%s) is deactivated\n", pkgname, id); return NULL; } static struct packet *master_hold_scroll(pid_t pid, int handle, const struct packet *packet) { - struct livebox *handler; + struct livebox_common *common; + struct livebox *livebox; const char *pkgname; const char *id; int seize; int ret; + struct dlist *l; ret = packet_get(packet, "ssi", &pkgname, &id, &seize); if (ret != 3) { @@ -79,14 +91,17 @@ static struct packet *master_hold_scroll(pid_t pid, int handle, const struct pac goto out; } - handler = lb_find_livebox(pkgname, id); - if (!handler) { + common = lb_find_common_handle(pkgname, id); + if (!common) { ErrPrint("Instance(%s) is not exists\n", id); goto out; } - DbgPrint("[HOLD] %s %d\n", id, seize); - lb_invoke_event_handler(handler, seize ? LB_EVENT_HOLD_SCROLL : LB_EVENT_RELEASE_SCROLL); + DbgPrint("HOLD: [%s] seize(%d)\n", id, seize); + seize = seize ? LB_EVENT_HOLD_SCROLL : LB_EVENT_RELEASE_SCROLL; + dlist_foreach(common->livebox_list, l, livebox) { + lb_invoke_event_handler(livebox, seize); + } out: return NULL; @@ -98,6 +113,9 @@ static struct packet *master_pinup(pid_t pid, int handle, const struct packet *p const char *id; const char *content; struct livebox *handler; + struct dlist *l; + struct dlist *n; + struct livebox_common *common; char *new_content; int ret; int status; @@ -109,38 +127,42 @@ static struct packet *master_pinup(pid_t pid, int handle, const struct packet *p goto out; } - handler = lb_find_livebox(pkgname, id); - if (!handler) { + common = lb_find_common_handle(pkgname, id); + if (!common) { ErrPrint("Instance (%s) is not exists\n", id); goto out; } - if (status == 0) { + if (status == LB_STATUS_SUCCESS) { new_content = strdup(content); if (new_content) { - free(handler->content); - handler->content = new_content; - handler->is_pinned_up = pinup; + free(common->content); + common->content = new_content; + common->is_pinned_up = pinup; } else { ErrPrint("Heap: %s\n", strerror(errno)); status = LB_STATUS_ERROR_MEMORY; } } - if (handler->pinup_cb) { - ret_cb_t cb; - void *cbdata; + common->request.pinup = 0; - /* Make sure that user can call pinup API in its result callback */ - cb = handler->pinup_cb; - cbdata = handler->pinup_cbdata; + dlist_foreach_safe(common->livebox_list, l, n, handler) { + if (handler->cbs.pinup.cb) { + ret_cb_t cb; + void *cbdata; - handler->pinup_cb = NULL; - handler->pinup_cbdata = NULL; + /* Make sure that user can call pinup API in its result callback */ + cb = handler->cbs.pinup.cb; + cbdata = handler->cbs.pinup.data; - cb(handler, status, cbdata); - } else if (status == 0) { - lb_invoke_event_handler(handler, LB_EVENT_PINUP_CHANGED); + handler->cbs.pinup.cb = NULL; + handler->cbs.pinup.data = NULL; + + cb(handler, status, cbdata); + } else if (status == LB_STATUS_SUCCESS) { + lb_invoke_event_handler(handler, LB_EVENT_PINUP_CHANGED); + } } out: @@ -153,14 +175,19 @@ static struct packet *master_deleted(pid_t pid, int handle, const struct packet const char *id; double timestamp; struct livebox *handler; + struct livebox_common *common; + struct dlist *l; + struct dlist *n; + int reason; - if (packet_get(packet, "ssd", &pkgname, &id, ×tamp) != 3) { + if (packet_get(packet, "ssdi", &pkgname, &id, ×tamp, &reason) != 4) { ErrPrint("Invalid arguemnt\n"); goto out; } - handler = lb_find_livebox_by_timestamp(timestamp); - if (!handler) { + DbgPrint("[%s]\n", pkgname); + common = lb_find_common_handle_by_timestamp(timestamp); + if (!common) { /*! * \note * This can be happens only if the user delete a livebox @@ -170,71 +197,83 @@ static struct packet *master_deleted(pid_t pid, int handle, const struct packet } /*!< Check validity of this "handler" */ - if (handler->state != CREATE) { - if (handler->state != DELETE) { + if (common->state != CREATE) { + if (common->state != DELETE) { /*! * \note * This is not possible */ - CRITICAL_LOG("Already deleted handler (%s - %s)\n", pkgname, id); + ErrPrint("Already deleted handler (%s - %s)\n", pkgname, id); return NULL; } } - if (handler->created_cb) { - ret_cb_t cb; - void *cbdata; - /*! - * \note - * - * "if (handler->id == NULL)" - * - * The instance is not created yet. - * But the master forcely destroy it and send destroyed event to this - * without the created event. - * - * It could be destroyed when a slave has critical error(fault) - * before creating an instance successfully. - */ - if (handler->created_cb == handler->deleted_cb) { - if (handler->created_cbdata != handler->deleted_cbdata) - DbgPrint("cb is same but cbdata is different (%s - %s)\n", pkgname, id); + common->request.deleted = 0; + /*! + * We should change the state of "common handler' before handling the callbacks. + * Because if user tries to create a new handle in the callbacks, + * find_sharable_common_handle will returns destroying object. + * Then we will get panic. + * To prevent it, we should change its state first. + */ + common->state = DELETE; - handler->deleted_cb = NULL; - handler->deleted_cbdata = NULL; - } + dlist_foreach_safe(common->livebox_list, l, n, handler) { + if (handler->cbs.created.cb) { + ret_cb_t cb; + void *cbdata; + /*! + * \note + * + * "if (handler->id == NULL) {" + * + * The instance is not created yet. + * But the master forcely destroy it and send destroyed event to this + * without the created event. + * + * It could be destroyed when a slave has critical error(fault) + * before creating an instance successfully. + */ + if (handler->cbs.created.cb == handler->cbs.deleted.cb) { + if (handler->cbs.created.data != handler->cbs.deleted.data) { + DbgPrint("cb is same but cbdata is different (%s - %s)\n", pkgname, id); + } - DbgPrint("Call the created cb with LB_STATUS_ERROR_CANCEL\n"); - cb = handler->created_cb; - cbdata = handler->created_cbdata; + handler->cbs.deleted.cb = NULL; + handler->cbs.deleted.data = NULL; + } - handler->created_cb = NULL; - handler->created_cbdata = NULL; + cb = handler->cbs.created.cb; + cbdata = handler->cbs.created.data; - cb(handler, LB_STATUS_ERROR_CANCEL, cbdata); - } else if (handler->id) { - if (handler->deleted_cb) { - ret_cb_t cb; - void *cbdata; + handler->cbs.created.cb = NULL; + handler->cbs.created.data = NULL; - cb = handler->deleted_cb; - cbdata = handler->deleted_cbdata; + if (reason == LB_STATUS_SUCCESS) { + reason = LB_STATUS_ERROR_CANCEL; + } - handler->deleted_cb = NULL; - handler->deleted_cbdata = NULL; + cb(handler, reason, cbdata); + } else if (common->id) { + if (handler->cbs.deleted.cb) { + ret_cb_t cb; + void *cbdata; - DbgPrint("Call the deleted cb\n"); - cb(handler, LB_STATUS_SUCCESS, cbdata); - } else { - DbgPrint("Call the lb,deleted\n"); - lb_invoke_event_handler(handler, LB_EVENT_DELETED); - } - } + cb = handler->cbs.deleted.cb; + cbdata = handler->cbs.deleted.data; - DbgPrint("[%p] %s(%s) is deleted\n", handler, pkgname, id); + handler->cbs.deleted.cb = NULL; + handler->cbs.deleted.data = NULL; + + cb(handler, reason, cbdata); + } else { + lb_invoke_event_handler(handler, LB_EVENT_DELETED); + } + } - /* Just try to delete it, if a user didn't remove it from the live box list */ - lb_unref(handler); + /* Just try to delete it, if a user didn't remove it from the live box list */ + lb_unref(handler, 1); + } out: return NULL; @@ -243,6 +282,7 @@ out: static struct packet *master_lb_update_begin(pid_t pid, int handle, const struct packet *packet) { struct livebox *handler; + struct livebox_common *common; const char *pkgname; const char *id; const char *content; @@ -257,20 +297,20 @@ static struct packet *master_lb_update_begin(pid_t pid, int handle, const struct goto out; } - handler = lb_find_livebox(pkgname, id); - if (!handler) { + common = lb_find_common_handle(pkgname, id); + if (!common) { ErrPrint("Instance[%s] is not exists\n", id); goto out; } - if (handler->state != CREATE) { - DbgPrint("(%s) is not created\n", id); + if (common->state != CREATE) { + ErrPrint("(%s) is not created\n", id); goto out; } - lb_set_priority(handler, priority); - lb_set_content(handler, content); - lb_set_title(handler, title); + lb_set_priority(common, priority); + lb_set_content(common, content); + lb_set_title(common, title); /*! * \NOTE @@ -279,14 +319,19 @@ static struct packet *master_lb_update_begin(pid_t pid, int handle, const struct * And if the size is changed, the provider should finish the updating first. * And then begin updating again after change its size. */ - if (lb_get_lb_fb(handler)) { - lb_set_lb_fb(handler, fbfile); + if (lb_get_lb_fb(common)) { + (void)lb_set_lb_fb(common, fbfile); + + ret = lb_sync_lb_fb(common); - ret = fb_sync(lb_get_lb_fb(handler)); - if (ret != LB_STATUS_SUCCESS) + if (ret != LB_STATUS_SUCCESS) { ErrPrint("Failed to do sync FB (%s - %s) (%d)\n", pkgname, fbfile, ret); - else - lb_invoke_event_handler(handler, LB_EVENT_LB_UPDATE_BEGIN); + } else { + struct dlist *l; + dlist_foreach(common->livebox_list, l, handler) { + lb_invoke_event_handler(handler, LB_EVENT_LB_UPDATE_BEGIN); + } + } } else { ErrPrint("Invalid request[%s], %s\n", id, fbfile); } @@ -298,6 +343,7 @@ out: static struct packet *master_pd_update_begin(pid_t pid, int handle, const struct packet *packet) { struct livebox *handler; + struct livebox_common *common; const char *pkgname; const char *id; const char *fbfile; @@ -309,25 +355,29 @@ static struct packet *master_pd_update_begin(pid_t pid, int handle, const struct goto out; } - handler = lb_find_livebox(pkgname, id); - if (!handler) { + common = lb_find_common_handle(pkgname, id); + if (!common) { ErrPrint("Instance[%s] is not exists\n", id); goto out; } - if (handler->state != CREATE) { - DbgPrint("[%s] is not created\n", id); + if (common->state != CREATE) { + ErrPrint("[%s] is not created\n", id); goto out; } - if (lb_get_pd_fb(handler)) { - lb_set_lb_fb(handler, fbfile); + if (lb_get_pd_fb(common)) { + (void)lb_set_pd_fb(common, fbfile); - ret = fb_sync(lb_get_lb_fb(handler)); - if (ret != LB_STATUS_SUCCESS) + ret = lb_sync_pd_fb(common); + if (ret != LB_STATUS_SUCCESS) { ErrPrint("Failed to do sync FB (%s - %s) (%d)\n", pkgname, fbfile, ret); - else - lb_invoke_event_handler(handler, LB_EVENT_PD_UPDATE_BEGIN); + } else { + struct dlist *l; + dlist_foreach(common->livebox_list, l, handler) { + lb_invoke_event_handler(handler, LB_EVENT_PD_UPDATE_BEGIN); + } + } } else { ErrPrint("Invalid request[%s], %s\n", id, fbfile); } @@ -339,6 +389,7 @@ out: static struct packet *master_lb_update_end(pid_t pid, int handle, const struct packet *packet) { struct livebox *handler; + struct livebox_common *common; const char *pkgname; const char *id; int ret; @@ -349,19 +400,22 @@ static struct packet *master_lb_update_end(pid_t pid, int handle, const struct p goto out; } - handler = lb_find_livebox(pkgname, id); - if (!handler) { + common = lb_find_common_handle(pkgname, id); + if (!common) { ErrPrint("Instance[%s] is not exists\n", id); goto out; } - if (handler->state != CREATE) { - DbgPrint("[%s] is not created\n", id); + if (common->state != CREATE) { + ErrPrint("[%s] is not created\n", id); goto out; } - if (lb_get_lb_fb(handler)) { - lb_invoke_event_handler(handler, LB_EVENT_LB_UPDATE_END); + if (lb_get_lb_fb(common)) { + struct dlist *l; + dlist_foreach(common->livebox_list, l, handler) { + lb_invoke_event_handler(handler, LB_EVENT_LB_UPDATE_END); + } } else { ErrPrint("Invalid request[%s]\n", id); } @@ -370,9 +424,11 @@ out: return NULL; } -static struct packet *master_access_status(pid_t pid, int handle, const struct packet *packet) +static struct packet *master_key_status(pid_t pid, int handle, const struct packet *packet) { struct livebox *handler; + struct livebox_common *common; + struct dlist *l; const char *pkgname; const char *id; int ret; @@ -384,32 +440,121 @@ static struct packet *master_access_status(pid_t pid, int handle, const struct p goto out; } - handler = lb_find_livebox(pkgname, id); - if (!handler) { + common = lb_find_common_handle(pkgname, id); + if (!common) { ErrPrint("Instance[%s] is not exists\n", id); goto out; } - if (handler->state != CREATE) { - DbgPrint("[%s] is not created\n", id); + if (common->state != CREATE) { + ErrPrint("[%s] is not created\n", id); goto out; } - DbgPrint("Access status: %d\n", status); + common->request.key_event = 0; + dlist_foreach(common->livebox_list, l, handler) { + if (handler->cbs.key_event.cb) { + ret_cb_t cb; + void *cbdata; - if (handler->access_event_cb) { - ret_cb_t cb; - void *cbdata; + cb = handler->cbs.key_event.cb; + cbdata = handler->cbs.key_event.data; - cb = handler->access_event_cb; - cbdata = handler->access_event_cbdata; + handler->cbs.key_event.cb = NULL; + handler->cbs.key_event.data = NULL; - handler->access_event_cb = NULL; - handler->access_event_cbdata = NULL; + cb(handler, status, cbdata); + } else { + ErrPrint("Invalid event[%s]\n", id); + } + } - cb(handler, status, cbdata); - } else { - ErrPrint("Invalid event[%s]\n", id); +out: + return NULL; +} + +static struct packet *master_request_close_pd(pid_t pid, int handle, const struct packet *packet) +{ + struct livebox *handler; + struct livebox_common *common; + struct dlist *l; + const char *pkgname; + const char *id; + int ret; + int reason; + + ret = packet_get(packet, "ssi", &pkgname, &id, &reason); + if (ret != 3) { + ErrPrint("Invalid argument\n"); + goto out; + } + + common = lb_find_common_handle(pkgname, id); + if (!common) { + ErrPrint("Instance[%s] is not exists\n", id); + goto out; + } + + if (common->state != CREATE) { + ErrPrint("[%s] is not created\n", id); + goto out; + } + + if (!common->is_pd_created) { + DbgPrint("PD is not created, closing what?(%s)\n", id); + goto out; + } + + DbgPrint("Reason: %d\n", reason); + + dlist_foreach(common->livebox_list, l, handler) { + lb_invoke_event_handler(handler, LB_EVENT_REQUEST_CLOSE_PD); + } +out: + return NULL; +} + +static struct packet *master_access_status(pid_t pid, int handle, const struct packet *packet) +{ + struct livebox *handler; + struct livebox_common *common; + struct dlist *l; + 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; + } + + common = lb_find_common_handle(pkgname, id); + if (!common) { + ErrPrint("Instance[%s] is not exists\n", id); + goto out; + } + + if (common->state != CREATE) { + ErrPrint("[%s] is not created\n", id); + goto out; + } + + common->request.access_event = 0; + dlist_foreach(common->livebox_list, l, handler) { + if (handler->cbs.access_event.cb) { + ret_cb_t cb; + void *cbdata; + + cb = handler->cbs.access_event.cb; + cbdata = handler->cbs.access_event.data; + + handler->cbs.access_event.cb = NULL; + handler->cbs.access_event.data = NULL; + + cb(handler, status, cbdata); + } } out: return NULL; @@ -418,6 +563,7 @@ out: static struct packet *master_pd_update_end(pid_t pid, int handle, const struct packet *packet) { struct livebox *handler; + struct livebox_common *common; const char *pkgname; const char *id; int ret; @@ -428,19 +574,23 @@ static struct packet *master_pd_update_end(pid_t pid, int handle, const struct p goto out; } - handler = lb_find_livebox(pkgname, id); - if (!handler) { + common = lb_find_common_handle(pkgname, id); + if (!common) { ErrPrint("Instance[%s] is not exists\n", id); goto out; } - if (handler->state != CREATE) { - DbgPrint("[%s] is not created\n", id); + if (common->state != CREATE) { + ErrPrint("[%s] is not created\n", id); goto out; } - if (lb_get_lb_fb(handler)) { - lb_invoke_event_handler(handler, LB_EVENT_PD_UPDATE_END); + if (lb_get_lb_fb(common)) { + struct dlist *l; + + dlist_foreach(common->livebox_list, l, handler) { + lb_invoke_event_handler(handler, LB_EVENT_PD_UPDATE_END); + } } else { ErrPrint("Invalid request[%s]", id); } @@ -456,62 +606,94 @@ static struct packet *master_lb_updated(pid_t pid, int handle, const struct pack const char *fbfile; const char *content; const char *title; + const char *safe_file; + const char *icon; + const char *name; struct livebox *handler; + struct livebox_common *common; int lb_w; int lb_h; double priority; int ret; - ret = packet_get(packet, "sssiidss", + ret = packet_get(packet, "sssiidsssss", &pkgname, &id, &fbfile, &lb_w, &lb_h, - &priority, &content, &title); - if (ret != 8) { + &priority, &content, &title, + &safe_file, &icon, &name); + if (ret != 11) { ErrPrint("Invalid argument\n"); goto out; } - handler = lb_find_livebox(pkgname, id); - if (!handler) { + common = lb_find_common_handle(pkgname, id); + if (!common) { ErrPrint("instance(%s) is not exists\n", id); goto out; } - if (handler->state != CREATE) { + if (common->state != CREATE) { /*! * \note * Already deleted by the user. * Don't try to notice anything with this, Just ignore all events * Beacuse the user doesn't wants know about this anymore */ - DbgPrint("(%s) is not exists, but updated\n", id); + ErrPrint("(%s) is not exists, but updated\n", id); goto out; } - lb_set_priority(handler, priority); - lb_set_content(handler, content); - lb_set_title(handler, title); - lb_set_size(handler, lb_w, lb_h); + lb_set_priority(common, priority); + lb_set_content(common, content); + lb_set_title(common, title); + lb_set_size(common, lb_w, lb_h); + lb_set_filename(common, safe_file); + + if (lb_text_lb(common)) { + const char *common_filename; - if (lb_text_lb(handler)) { - (void)parse_desc(handler, livebox_filename(handler), 0); + common_filename = common->filename ? common->filename : util_uri_to_path(common->id); + + (void)parse_desc(common, common_filename, 0); /*! * \note * DESC parser will call the "text event callback". * Don't need to call global event callback in this case. */ goto out; - } else if (lb_get_lb_fb(handler)) { - lb_set_lb_fb(handler, fbfile); - ret = fb_sync(lb_get_lb_fb(handler)); - if (ret != LB_STATUS_SUCCESS) - ErrPrint("Failed to do sync FB (%s - %s) (%d)\n", pkgname, util_basename(util_uri_to_path(id)), ret); + } else if (lb_get_lb_fb(common)) { + /*! + * \todo + * replace this with "flag" instead of "callback address" + */ + if (conf_frame_drop_for_resizing() && common->request.size_changed) { + /* Just for skipping the update event callback call, After request to resize buffer, update event will be discarded */ + DbgPrint("Discards obsoloted update event\n"); + ret = LB_STATUS_ERROR_BUSY; + } else { + (void)lb_set_lb_fb(common, fbfile); + + if (!conf_manual_sync()) { + ret = lb_sync_lb_fb(common); + if (ret != LB_STATUS_SUCCESS) { + ErrPrint("Failed to do sync FB (%s - %s) (%d)\n", pkgname, util_basename(util_uri_to_path(id)), ret); + } + } else { + ret = LB_STATUS_SUCCESS; + } + } } else { ret = LB_STATUS_SUCCESS; } - if (ret == LB_STATUS_SUCCESS) - lb_invoke_event_handler(handler, LB_EVENT_LB_UPDATED); + if (ret == LB_STATUS_SUCCESS) { + struct dlist *l; + struct dlist *n; + + dlist_foreach_safe(common->livebox_list, l, n, handler) { + lb_invoke_event_handler(handler, LB_EVENT_LB_UPDATED); + } + } out: return NULL; @@ -520,9 +702,12 @@ out: static struct packet *master_pd_created(pid_t pid, int handle, const struct packet *packet) { struct livebox *handler; + struct livebox_common *common; const char *pkgname; const char *id; const char *buf_id; + struct dlist *l; + struct dlist *n; int width; int height; int ret; @@ -534,44 +719,80 @@ static struct packet *master_pd_created(pid_t pid, int handle, const struct pack goto out; } - handler = lb_find_livebox(pkgname, id); - if (!handler) { + DbgPrint("[%s]\n", pkgname); + common = lb_find_common_handle(pkgname, id); + if (!common) { ErrPrint("Instance(%s) is not exists\n", id); goto out; } - if (handler->state != CREATE) { + if (common->state != CREATE) { ErrPrint("Instance(%s) is not created\n", id); 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))); + if (!common->request.pd_created) { + ErrPrint("PD create request is canceled\n"); + goto out; } - handler->is_pd_created = (status == 0); + common->is_pd_created = (status == LB_STATUS_SUCCESS); + common->request.pd_created = 0; - if (handler->pd_created_cb) { - ret_cb_t cb; - void *cbdata; + if (common->is_pd_created) { + lb_set_pdsize(common, width, height); + if (lb_text_pd(common)) { + DbgPrint("Text TYPE does not need to handle this\n"); + } else { + (void)lb_set_pd_fb(common, buf_id); + + switch (common->pd.type) { + case _PD_TYPE_SCRIPT: + case _PD_TYPE_BUFFER: + switch (fb_type(lb_get_pd_fb(common))) { + case BUFFER_TYPE_FILE: + case BUFFER_TYPE_SHM: + lb_create_lock_file(common, 1); + break; + case BUFFER_TYPE_PIXMAP: + case BUFFER_TYPE_ERROR: + default: + break; + } + break; + case _PD_TYPE_TEXT: + default: + break; + } - cb = handler->pd_created_cb; - cbdata = handler->pd_created_cbdata; + ret = lb_sync_pd_fb(common); + if (ret < 0) { + ErrPrint("Failed to do sync FB (%s - %s)\n", pkgname, util_basename(util_uri_to_path(id))); + } + } + } + + DbgPrint("PERF_DBOX\n"); + dlist_foreach_safe(common->livebox_list, l, n, handler) { + if (handler->cbs.pd_created.cb) { + ret_cb_t cb; + void *cbdata; + + cb = handler->cbs.pd_created.cb; + cbdata = handler->cbs.pd_created.data; - handler->pd_created_cb = NULL; - handler->pd_created_cbdata = NULL; + handler->cbs.pd_created.cb = NULL; + handler->cbs.pd_created.data = NULL; - DbgPrint("pd_created_cb (%s) - %d\n", buf_id, status); - cb(handler, status, cbdata); - } else if (status == 0) { - DbgPrint("LB_EVENT_PD_CREATED (%s) - %d\n", buf_id, status); - lb_invoke_event_handler(handler, LB_EVENT_PD_CREATED); + /*! + * Before call the Callback function, + * pd_create_cb must be reset. + * Because, in the create callback, user can call create_pd function again. + */ + cb(handler, status, cbdata); + } else if (status == LB_STATUS_SUCCESS) { + lb_invoke_event_handler(handler, LB_EVENT_PD_CREATED); + } } out: @@ -581,6 +802,8 @@ out: static struct packet *master_pd_destroyed(pid_t pid, int handle, const struct packet *packet) { struct livebox *handler; + struct dlist *l; + struct livebox_common *common; const char *pkgname; const char *id; int ret; @@ -592,34 +815,69 @@ static struct packet *master_pd_destroyed(pid_t pid, int handle, const struct pa goto out; } - handler = lb_find_livebox(pkgname, id); - if (!handler) { + DbgPrint("[%s]\n", pkgname); + common = lb_find_common_handle(pkgname, id); + if (!common) { ErrPrint("Instance(%s) is not exists\n", id); goto out; } - if (handler->state != CREATE) { + if (common->state != CREATE) { ErrPrint("Instance(%s) is not created\n", id); goto out; } - handler->is_pd_created = 0; + if (common->is_pd_created == 0) { + ErrPrint("PD is not created, event is ignored\n"); + goto out; + } + + common->is_pd_created = 0; + common->request.pd_destroyed = 0; - if (handler->pd_destroyed_cb) { - ret_cb_t cb; - void *cbdata; + dlist_foreach(common->livebox_list, l, handler) { + if (handler->cbs.pd_destroyed.cb) { + ret_cb_t cb; + void *cbdata; - cb = handler->pd_destroyed_cb; - cbdata = handler->pd_destroyed_cbdata; + cb = handler->cbs.pd_destroyed.cb; + cbdata = handler->cbs.pd_destroyed.data; - handler->pd_destroyed_cb = NULL; - handler->pd_destroyed_cbdata = NULL; + handler->cbs.pd_destroyed.cb = NULL; + handler->cbs.pd_destroyed.data = NULL; - DbgPrint("Invoke the PD Destroyed CB\n"); - cb(handler, status, cbdata); - } else if (status == 0) { - DbgPrint("Invoke the LB_EVENT_PD_DESTROYED event\n"); - lb_invoke_event_handler(handler, LB_EVENT_PD_DESTROYED); + /*! + * Before call the Callback function, + * pd_destroyed_cb must be reset. + * Because, in the create callback, user can call destroy_pd function again. + */ + cb(handler, status, cbdata); + } else if (status == LB_STATUS_SUCCESS) { + lb_invoke_event_handler(handler, LB_EVENT_PD_DESTROYED); + } + } + + /*! + * \note + * Lock file should be deleted after all callbacks are processed. + */ + switch (common->pd.type) { + case _PD_TYPE_SCRIPT: + case _PD_TYPE_BUFFER: + switch (fb_type(lb_get_pd_fb(common))) { + case BUFFER_TYPE_FILE: + case BUFFER_TYPE_SHM: + lb_destroy_lock_file(common, 1); + break; + case BUFFER_TYPE_PIXMAP: + case BUFFER_TYPE_ERROR: + default: + break; + } + break; + case _PD_TYPE_TEXT: + default: + break; } out: @@ -634,6 +892,8 @@ static struct packet *master_pd_updated(pid_t pid, int handle, const struct pack const char *fbfile; int ret; struct livebox *handler; + struct livebox_common *common; + struct dlist *l; int pd_w; int pd_h; @@ -646,13 +906,14 @@ static struct packet *master_pd_updated(pid_t pid, int handle, const struct pack goto out; } - handler = lb_find_livebox(pkgname, id); - if (!handler) { + DbgPrint("[%s]\n", pkgname); + common = lb_find_common_handle(pkgname, id); + if (!common) { ErrPrint("Instance(%s) is not exists\n", id); goto out; } - if (handler->state != CREATE) { + if (common->state != CREATE) { /*! * \note * This handler is already deleted by the user. @@ -663,18 +924,32 @@ static struct packet *master_pd_updated(pid_t pid, int handle, const struct pack goto out; } - lb_set_pdsize(handler, pd_w, pd_h); + lb_set_pdsize(common, pd_w, pd_h); - if (lb_text_pd(handler)) { - (void)parse_desc(handler, descfile, 1); + if (lb_text_pd(common)) { + (void)parse_desc(common, 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))); - else - lb_invoke_event_handler(handler, LB_EVENT_PD_UPDATED); + if (conf_frame_drop_for_resizing() && common->request.size_changed) { + /* Just for skipping the update event callback call, After request to resize buffer, update event will be discarded */ + DbgPrint("Discards obsoloted update event\n"); + } else { + (void)lb_set_pd_fb(common, fbfile); + + if (!conf_manual_sync()) { + ret = lb_sync_pd_fb(common); + if (ret < 0) { + ErrPrint("Failed to do sync FB (%s - %s), %d\n", pkgname, util_basename(util_uri_to_path(id)), ret); + } else { + dlist_foreach(common->livebox_list, l, handler) { + lb_invoke_event_handler(handler, LB_EVENT_PD_UPDATED); + } + } + } else { + dlist_foreach(common->livebox_list, l, handler) { + lb_invoke_event_handler(handler, LB_EVENT_PD_UPDATED); + } + } + } } out: @@ -684,6 +959,9 @@ out: static struct packet *master_update_mode(pid_t pid, int handle, const struct packet *packet) { struct livebox *handler; + struct livebox_common *common; + struct dlist *l; + struct dlist *n; const char *pkgname; const char *id; int active_mode; @@ -701,35 +979,37 @@ static struct packet *master_update_mode(pid_t pid, int handle, const struct pac goto out; } - DbgPrint("Update mode is changed: %d, %d, %s\n", status, active_mode, id); - - handler = lb_find_livebox(pkgname, id); - if (!handler) { + common = lb_find_common_handle(pkgname, id); + if (!common) { ErrPrint("Livebox(%s) is not found\n", id); goto out; } - if (handler->state != CREATE) { + if (common->state != CREATE) { ErrPrint("Livebox(%s) is not created yet\n", id); goto out; } - if (status == LB_STATUS_SUCCESS) - lb_set_update_mode(handler, active_mode); + if (status == LB_STATUS_SUCCESS) { + lb_set_update_mode(common, active_mode); + } - if (handler->update_mode_cb) { - ret_cb_t cb; - void *cbdata; + common->request.update_mode = 0; + dlist_foreach_safe(common->livebox_list, l, n, handler) { + if (handler->cbs.update_mode.cb) { + ret_cb_t cb; + void *cbdata; - cb = handler->update_mode_cb; - cbdata = handler->update_mode_cbdata; + cb = handler->cbs.update_mode.cb; + cbdata = handler->cbs.update_mode.data; - handler->update_mode_cb = NULL; - handler->update_mode_cbdata = NULL; + handler->cbs.update_mode.cb = NULL; + handler->cbs.update_mode.data = NULL; - cb(handler, status, cbdata); - } else { - lb_invoke_event_handler(handler, LB_EVENT_UPDATE_MODE_CHANGED); + cb(handler, status, cbdata); + } else if (status == LB_STATUS_SUCCESS) { + lb_invoke_event_handler(handler, LB_EVENT_UPDATE_MODE_CHANGED); + } } out: @@ -739,6 +1019,7 @@ out: static struct packet *master_size_changed(pid_t pid, int handle, const struct packet *packet) { struct livebox *handler; + struct livebox_common *common; const char *pkgname; const char *id; const char *fbfile; @@ -759,21 +1040,19 @@ static struct packet *master_size_changed(pid_t pid, int handle, const struct pa goto out; } - DbgPrint("Size is changed: %dx%d (%s), fb: [%s]\n", w, h, id, fbfile); - - handler = lb_find_livebox(pkgname, id); - if (!handler) { + common = lb_find_common_handle(pkgname, id); + if (!common) { ErrPrint("Livebox(%s) is not found\n", id); goto out; } - if (handler->state != CREATE) { + if (common->state != CREATE) { ErrPrint("Livebox(%s) is not created yet\n", id); goto out; } + common->request.size_changed = 0; if (is_pd) { - DbgPrint("PD is resized\n"); /*! * \NOTE * PD is not able to resized by the client. @@ -781,65 +1060,60 @@ static struct packet *master_size_changed(pid_t pid, int handle, const struct pa * So the PD has no private resized event handler. * Notify it via global event handler only. */ - if (status == 0) { - lb_set_pdsize(handler, w, h); - lb_invoke_event_handler(handler, LB_EVENT_PD_SIZE_CHANGED); + if (status == LB_STATUS_SUCCESS) { + struct dlist *l; + + lb_set_pdsize(common, w, h); + dlist_foreach(common->livebox_list, l, handler) { + lb_invoke_event_handler(handler, LB_EVENT_PD_SIZE_CHANGED); + } } else { ErrPrint("This is not possible. PD Size is changed but the return value is not ZERO (%d)\n", status); } } else { - if (status == 0) { - DbgPrint("LB is successfully resized (%dx%d)\n", w, h); - lb_set_size(handler, w, h); + struct dlist *l; + struct dlist *n; + + if (status == LB_STATUS_SUCCESS) { + lb_set_size(common, w, h); /*! * \NOTE * If there is a created LB FB, * Update it too. */ - if (lb_get_lb_fb(handler)) { - lb_set_lb_fb(handler, fbfile); + if (lb_get_lb_fb(common)) { + (void)lb_set_lb_fb(common, fbfile); - ret = fb_sync(lb_get_lb_fb(handler)); - if (ret < 0) + ret = lb_sync_lb_fb(common); + if (ret < 0) { ErrPrint("Failed to do sync FB (%s - %s)\n", pkgname, util_basename(util_uri_to_path(id))); + } /* Just update the size info only. */ } + } - /*! - * \NOTE - * I cannot believe client. - * So I added some log before & after call the user callback. - */ - if (handler->size_changed_cb) { + /*! + * \NOTE + * I cannot believe client. + * So I added some log before & after call the user callback. + */ + dlist_foreach_safe(common->livebox_list, l, n, handler) { + if (handler->cbs.size_changed.cb) { ret_cb_t cb; void *cbdata; - cb = handler->size_changed_cb; - cbdata = handler->size_cbdata; + cb = handler->cbs.size_changed.cb; + cbdata = handler->cbs.size_changed.data; - handler->size_changed_cb = NULL; - handler->size_cbdata = NULL; + handler->cbs.size_changed.cb = NULL; + handler->cbs.size_changed.data = NULL; cb(handler, status, cbdata); - } else { + } else if (status == LB_STATUS_SUCCESS) { lb_invoke_event_handler(handler, LB_EVENT_LB_SIZE_CHANGED); } - } else { - DbgPrint("LB is not resized: %dx%d (%d)\n", w, h, status); - if (handler->size_changed_cb) { - ret_cb_t cb; - void *cbdata; - - cb = handler->size_changed_cb; - cbdata = handler->size_cbdata; - - handler->size_changed_cb = NULL; - handler->size_cbdata = NULL; - - cb(handler, status, cbdata); - } } } @@ -850,6 +1124,9 @@ out: static struct packet *master_period_changed(pid_t pid, int handle, const struct packet *packet) { struct livebox *handler; + struct livebox_common *common; + struct dlist *l; + struct dlist *n; const char *pkgname; const char *id; int ret; @@ -862,34 +1139,38 @@ static struct packet *master_period_changed(pid_t pid, int handle, const struct goto out; } - handler = lb_find_livebox(pkgname, id); - if (!handler) { + common = lb_find_common_handle(pkgname, id); + if (!common) { ErrPrint("Livebox(%s) is not found\n", id); goto out; } - if (handler->state != CREATE) { + if (common->state != CREATE) { ErrPrint("Livebox(%s) is not created\n", id); goto out; } - DbgPrint("Update period is changed? %lf (%d)\n", period, status); - if (status == 0) - lb_set_period(handler, period); + if (status == LB_STATUS_SUCCESS) { + lb_set_period(common, period); + } - if (handler->period_changed_cb) { - ret_cb_t cb; - void *cbdata; + common->request.period_changed = 0; - cb = handler->period_changed_cb; - cbdata = handler->period_cbdata; + dlist_foreach_safe(common->livebox_list, l, n, handler) { + if (handler->cbs.period_changed.cb) { + ret_cb_t cb; + void *cbdata; - handler->period_changed_cb = NULL; - handler->period_cbdata = NULL; + cb = handler->cbs.period_changed.cb; + cbdata = handler->cbs.period_changed.data; - cb(handler, status, cbdata); - } else if (status == 0) { - lb_invoke_event_handler(handler, LB_EVENT_PERIOD_CHANGED); + handler->cbs.period_changed.cb = NULL; + handler->cbs.period_changed.data = NULL; + + cb(handler, status, cbdata); + } else if (status == LB_STATUS_SUCCESS) { + lb_invoke_event_handler(handler, LB_EVENT_PERIOD_CHANGED); + } } out: @@ -899,6 +1180,9 @@ out: static struct packet *master_group_changed(pid_t pid, int handle, const struct packet *packet) { struct livebox *handler; + struct livebox_common *common; + struct dlist *l; + struct dlist *n; const char *pkgname; const char *id; int ret; @@ -912,13 +1196,13 @@ static struct packet *master_group_changed(pid_t pid, int handle, const struct p goto out; } - handler = lb_find_livebox(pkgname, id); - if (!handler) { + common = lb_find_common_handle(pkgname, id); + if (!common) { ErrPrint("Livebox(%s) is not exists\n", id); goto out; } - if (handler->state != CREATE) { + if (common->state != CREATE) { /*! * \note * Do no access this handler, @@ -928,23 +1212,27 @@ static struct packet *master_group_changed(pid_t pid, int handle, const struct p goto out; } - DbgPrint("Group is changed? [%s] / [%s] (%d)\n", cluster, category, status); - if (status == 0) - (void)lb_set_group(handler, cluster, category); + if (status == LB_STATUS_SUCCESS) { + (void)lb_set_group(common, cluster, category); + } - if (handler->group_changed_cb) { - ret_cb_t cb; - void *cbdata; + common->request.group_changed = 0; - cb = handler->group_changed_cb; - cbdata = handler->group_cbdata; + dlist_foreach_safe(common->livebox_list, l, n, handler) { + if (handler->cbs.group_changed.cb) { + ret_cb_t cb; + void *cbdata; + + cb = handler->cbs.group_changed.cb; + cbdata = handler->cbs.group_changed.data; - handler->group_changed_cb = NULL; - handler->group_cbdata = NULL; + handler->cbs.group_changed.cb = NULL; + handler->cbs.group_changed.data = NULL; - cb(handler, status, cbdata); - } else if (status == 0) { - lb_invoke_event_handler(handler, LB_EVENT_GROUP_CHANGED); + cb(handler, status, cbdata); + } else if (status == LB_STATUS_SUCCESS) { + lb_invoke_event_handler(handler, LB_EVENT_GROUP_CHANGED); + } } out: @@ -954,6 +1242,8 @@ out: static struct packet *master_created(pid_t pid, int handle, const struct packet *packet) { struct livebox *handler; + struct livebox_common *common; + struct dlist *l; int lb_w; int lb_h; @@ -1008,19 +1298,19 @@ static struct packet *master_created(pid_t pid, int handle, const struct packet auto_launch, priority, size_list, user, pinup_supported, lb_type, pd_type, period, title, is_pinned_up); - handler = lb_find_livebox_by_timestamp(timestamp); - if (!handler) { - handler = lb_new_livebox(pkgname, id, timestamp); + common = lb_find_common_handle_by_timestamp(timestamp); + if (!common) { + handler = lb_new_livebox(pkgname, id, timestamp, cluster, category); if (!handler) { ErrPrint("Failed to create a new livebox\n"); ret = LB_STATUS_ERROR_FAULT; goto out; } - - old_state = handler->state; + common = handler->common; + old_state = common->state; } else { - if (handler->state != CREATE) { - if (handler->state != DELETE) { + if (common->state != CREATE) { + if (common->state != DELETE) { /*! * \note * This is not possible!!! @@ -1037,9 +1327,9 @@ static struct packet *master_created(pid_t pid, int handle, const struct packet */ } - old_state = handler->state; + old_state = common->state; - if (handler->id) { + if (common->id) { ErrPrint("Already created: timestamp[%lf] " "pkgname[%s], id[%s] content[%s] " "cluster[%s] category[%s] lb_fname[%s] pd_fname[%s]\n", @@ -1051,104 +1341,155 @@ static struct packet *master_created(pid_t pid, int handle, const struct packet goto out; } - lb_set_id(handler, id); + lb_set_id(common, id); } - lb_set_size(handler, lb_w, lb_h); - handler->lb.type = lb_type; - handler->is_pinned_up = is_pinned_up; + common->request.created = 0; + lb_set_size(common, lb_w, lb_h); + common->lb.type = lb_type; + common->is_pinned_up = is_pinned_up; switch (lb_type) { case _LB_TYPE_FILE: break; case _LB_TYPE_SCRIPT: case _LB_TYPE_BUFFER: - if (!strlen(lb_fname)) + if (!strlen(lb_fname)) { + break; + } + (void)lb_set_lb_fb(common, lb_fname); + + /*! + * \note + * Livebox should create the lock file from here. + * Even if the old_state == DELETE, + * the lock file will be deleted from deleted event callback. + */ + switch (fb_type(lb_get_lb_fb(common))) { + case BUFFER_TYPE_FILE: + case BUFFER_TYPE_SHM: + lb_create_lock_file(common, 0); + break; + case BUFFER_TYPE_PIXMAP: + case BUFFER_TYPE_ERROR: + default: break; - lb_set_lb_fb(handler, lb_fname); - ret = fb_sync(lb_get_lb_fb(handler)); - if (ret < 0) + } + + ret = lb_sync_lb_fb(common); + if (ret < 0) { ErrPrint("Failed to do sync FB (%s - %s)\n", pkgname, util_basename(util_uri_to_path(id))); + } break; case _LB_TYPE_TEXT: - lb_set_text_lb(handler); + lb_set_text_lb(common); break; default: break; } - handler->pd.type = pd_type; - lb_set_pdsize(handler, pd_w, pd_h); - lb_set_default_pdsize(handler, pd_w, pd_h); + common->pd.type = pd_type; + lb_set_pdsize(common, pd_w, pd_h); + lb_set_default_pdsize(common, pd_w, pd_h); switch (pd_type) { case _PD_TYPE_SCRIPT: case _PD_TYPE_BUFFER: - if (!strlen(pd_fname)) + if (!strlen(pd_fname)) { break; + } - lb_set_pd_fb(handler, pd_fname); - ret = fb_sync(lb_get_pd_fb(handler)); - if (ret < 0) + lb_set_pd_fb(common, pd_fname); + + ret = lb_sync_pd_fb(common); + if (ret < 0) { ErrPrint("Failed to do sync FB (%s - %s)\n", pkgname, util_basename(util_uri_to_path(id))); + } + + /*! + * \brief + * PD doesn't need to create the lock file from here. + * Just create it from PD_CREATED event. + */ + break; case _PD_TYPE_TEXT: - lb_set_text_pd(handler); + lb_set_text_pd(common); break; default: break; } - lb_set_priority(handler, priority); + lb_set_priority(common, priority); - lb_set_size_list(handler, size_list); - lb_set_group(handler, cluster, category); + lb_set_size_list(common, size_list); + lb_set_group(common, cluster, category); - lb_set_content(handler, content); - lb_set_title(handler, title); + lb_set_content(common, content); + lb_set_title(common, title); - lb_set_user(handler, user); + lb_set_user(common, user); - lb_set_auto_launch(handler, auto_launch); - lb_set_pinup(handler, pinup_supported); + lb_set_auto_launch(common, auto_launch); + lb_set_pinup(common, pinup_supported); - lb_set_period(handler, period); + lb_set_period(common, period); ret = 0; - if (handler->state == CREATE) { - /*! - * \note - * These callback can change the handler->state. - * So we have to use the "old_state" which stored state before call these callbacks - */ + if (common->state == CREATE) { + dlist_foreach(common->livebox_list, l, handler) { + /*! + * \note + * These callback can change the handler->state. + * So we have to use the "old_state" which stored state before call these callbacks + */ - if (handler->created_cb) { - ret_cb_t cb; - void *cbdata; + if (handler->cbs.created.cb) { + ret_cb_t cb; + void *cbdata; - cb = handler->created_cb; - cbdata = handler->created_cbdata; + cb = handler->cbs.created.cb; + cbdata = handler->cbs.created.data; - handler->created_cb = NULL; - handler->created_cbdata = NULL; + handler->cbs.created.cb = NULL; + handler->cbs.created.data = NULL; - DbgPrint("Invoke the created_cb\n"); - cb(handler, ret, cbdata); - } else { - DbgPrint("Invoke the lb,created\n"); - lb_invoke_event_handler(handler, LB_EVENT_CREATED); + cb(handler, ret, cbdata); + } else { + lb_invoke_event_handler(handler, LB_EVENT_CREATED); + } } } out: if (ret == 0 && old_state == DELETE) { - DbgPrint("Send the delete request\n"); - lb_send_delete(handler, handler->created_cb, handler->created_cbdata); + struct dlist *n; + + DbgPrint("Take place an unexpected case [%d]\n", common->refcnt); + dlist_foreach_safe(common->livebox_list, l, n, handler) { + if (handler->cbs.created.cb) { + if (!handler->common->request.deleted) { + if (lb_send_delete(handler, common->delete_type, handler->cbs.created.cb, handler->cbs.created.data) < 0) { + /*! + * \note + * Already sent or something else happens. + * Callback will be called in any cases + */ + } + } else if (handler->state != DELETE) { + handler->cbs.created.cb(handler, LB_STATUS_ERROR_CANCEL, handler->cbs.created.data); + lb_unref(handler, 1); + } + } else { + lb_invoke_event_handler(handler, LB_EVENT_DELETED); + lb_unref(handler, 1); + } + } /*! * \note - * handler->created_cb = NULL; - * handler->created_cbdata = NULL; + * handler->cbs.created.cb = NULL; + * handler->cbs.created.data = NULL; * * Do not clear this to use this from the deleted event callback. * if this value is not cleared when the deleted event callback check it, @@ -1237,6 +1578,14 @@ static struct method s_table[] = { .cmd = "access_status", .handler = master_access_status, }, + { + .cmd = "key_status", + .handler = master_key_status, + }, + { + .cmd = "close_pd", + .handler = master_request_close_pd, + }, { .cmd = NULL, @@ -1251,10 +1600,11 @@ static void acquire_cb(struct livebox *handler, const struct packet *result, voi } else { int ret; - if (packet_get(result, "i", &ret) != 1) + if (packet_get(result, "i", &ret) != 1) { ErrPrint("Invalid argument\n"); - else + } else { DbgPrint("Acquire returns: %d\n", ret); + } } return; @@ -1267,7 +1617,7 @@ static inline int make_connection(void) DbgPrint("Let's making connection!\n"); - s_info.fd = com_core_packet_client_init(CLIENT_SOCKET, 0, s_table); + s_info.fd = com_core_packet_client_init(client_addr(), 0, s_table); if (s_info.fd < 0) { ErrPrint("Try this again later\n"); return LB_STATUS_ERROR_IO; @@ -1301,8 +1651,9 @@ static void master_started_cb(keynode_t *node, void *data) { int state = 0; - if (vconf_get_bool(VCONFKEY_MASTER_STARTED, &state) < 0) + if (vconf_get_bool(VCONFKEY_MASTER_STARTED, &state) < 0) { ErrPrint("Unable to get [%s]\n", VCONFKEY_MASTER_STARTED); + } DbgPrint("Master state: %d\n", state); if (state == 1 && make_connection() == LB_STATUS_SUCCESS) { @@ -1312,6 +1663,20 @@ static void master_started_cb(keynode_t *node, void *data) } } +static gboolean timeout_cb(gpointer data) +{ + if (vconf_notify_key_changed(VCONFKEY_MASTER_STARTED, master_started_cb, NULL) < 0) { + ErrPrint("Failed to add vconf for monitoring service state\n"); + } else { + DbgPrint("vconf event callback is registered\n"); + } + + master_started_cb(NULL, NULL); + + s_info.timer_id = 0; + return FALSE; +} + static int disconnected_cb(int handle, void *data) { if (s_info.fd != handle) { @@ -1326,23 +1691,45 @@ static int disconnected_cb(int handle, void *data) lb_delete_all(); - if (vconf_notify_key_changed(VCONFKEY_MASTER_STARTED, master_started_cb, NULL) < 0) - ErrPrint("Failed to add vconf for monitoring service state\n"); - else - DbgPrint("vconf event callback is registered\n"); + /* Try to reconnect after 1 sec later */ + if (!s_info.timer_id) { + DbgPrint("Reconnecting timer is added\n"); + s_info.timer_id = g_timeout_add(1000, timeout_cb, NULL); + if (s_info.timer_id == 0) { + ErrPrint("Unable to add reconnecting timer\n"); + return 0; + } + } else { + ErrPrint("Reconnecting timer is already exists\n"); + } - master_started_cb(NULL, NULL); return 0; } -int client_init(void) +int client_init(int use_thread) { + com_core_packet_use_thread(use_thread); + + s_info.client_addr = vconf_get_str(VCONFKEY_MASTER_CLIENT_ADDR); + if (!s_info.client_addr) { + s_info.client_addr = strdup(CLIENT_SOCKET); + if (!s_info.client_addr) { + ErrPrint("Heap: %s\n", strerror(errno)); + return -ENOMEM; + } + } + + (void)file_service_init(); + + DbgPrint("Server Address: %s\n", s_info.client_addr); + com_core_add_event_callback(CONNECTOR_DISCONNECTED, disconnected_cb, NULL); com_core_add_event_callback(CONNECTOR_CONNECTED, connected_cb, NULL); - if (vconf_notify_key_changed(VCONFKEY_MASTER_STARTED, master_started_cb, NULL) < 0) + if (vconf_notify_key_changed(VCONFKEY_MASTER_STARTED, master_started_cb, NULL) < 0) { ErrPrint("Failed to add vconf for service state\n"); - else + } else { DbgPrint("vconf event callback is registered\n"); + } master_started_cb(NULL, NULL); return 0; @@ -1355,19 +1742,26 @@ int client_fd(void) const char *client_addr(void) { - return CLIENT_SOCKET; + return s_info.client_addr; } int client_fini(void) { int ret; + + (void)file_service_fini(); + ret = vconf_ignore_key_changed(VCONFKEY_MASTER_STARTED, master_started_cb); - if (ret < 0) + if (ret < 0) { DbgPrint("Ignore vconf key: %d\n", ret); - com_core_packet_client_fini(s_info.fd); + } + com_core_del_event_callback(CONNECTOR_DISCONNECTED, disconnected_cb, NULL); com_core_del_event_callback(CONNECTOR_CONNECTED, connected_cb, NULL); + com_core_packet_client_fini(s_info.fd); s_info.fd = -1; + free(s_info.client_addr); + s_info.client_addr = NULL; return LB_STATUS_SUCCESS; }