Replace livebox with dynamicbox

[model] Redwood,Kiran,B3(Wearable)
[binary_type] AP
[customer] Docomo/Orange/ATT/Open
[issue#] N/A
[problem]
[cause]
[solution]
[team] HomeTF
[request]
[horizontal_expansion]

Change-Id: I967677a1ea4a52e760ac4dc51c6c5f1fd09ec291

diff --git a/CMakeLists.txt b/CMakeLists.txt
index a4a8fbf..fffb1f7 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -16,7 +16,7 @@ INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include)
 INCLUDE(FindPkgConfig)
 pkg_check_modules(pkgs REQUIRED
        dlog
-       livebox-service
+       dynamicbox_service
        provider
        evas
        ecore

diff --git a/packaging/libdynamicbox.spec b/packaging/libdynamicbox.spec
index 87229c0..5855f3f 100644 (file)
--- a/packaging/libdynamicbox.spec
+++ b/packaging/libdynamicbox.spec
@@ -70,17 +70,17 @@ rm -rf %{buildroot}
 mkdir -p %{buildroot}/%{_datarootdir}/license
 
 %post -n %{name} -p /sbin/ldconfig
-%postun -n ${name} -p /sbin/ldconfig
+%postun -n %{name} -p /sbin/ldconfig
 
 %files -n %{name}
-%manifest %{name}.manifest
 %defattr(-,root,root,-)
+%manifest %{name}.manifest
 %{_libdir}/*.so*
 %{_datarootdir}/license/*
 
 %files devel
-%manifest %{name}.manifest
 %defattr(-,root,root,-)
+%manifest %{name}.manifest
 %{_includedir}/dynamicbox/dynamicbox.h
 %{_libdir}/pkgconfig/*.pc
 

diff --git a/src/dynamicbox.c b/src/dynamicbox.c
index 5d01178..431dd8a 100644 (file)
--- a/src/dynamicbox.c
+++ b/src/dynamicbox.c
@@ -32,7 +32,7 @@
 #include <dynamicbox_errno.h>
 */
 
-#include <livebox-service.h>
+#include <dynamicbox_service.h>
 
 #include "debug.h"
 #include "dlist.h"

diff --git a/src/livebox.c b/src/livebox.c
index bfe4567..ef01781 100644 (file)
--- a/src/livebox.c
+++ b/src/livebox.c
@@ -24,10 +24,10 @@
 #include <dlfcn.h>
 
 #include <dlog.h>
-#include <livebox-service.h>
 #include <provider.h>
 #include <provider_buffer.h>
-#include <livebox-errno.h>
+#include <dynamicbox_service.h>
+#include <dynamicbox_errno.h>
 
 #include "debug.h"
 #include "livebox.h"
@@ -264,7 +264,7 @@ PUBLIC int livebox_desc_close(struct livebox_desc *handle)
        struct block *block;
 
        if (!handle) {
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        dlist_foreach_safe(handle->block_list, l, n, block) {
@@ -309,7 +309,7 @@ PUBLIC int livebox_desc_close(struct livebox_desc *handle)
                ErrPrint("fclose: %s\n", strerror(errno));
        }
        free(handle);
-       return LB_STATUS_SUCCESS;
+       return DBOX_STATUS_ERROR_NONE;
 }
 
 PUBLIC int livebox_desc_set_category(struct livebox_desc *handle, const char *id, const char *category)
@@ -317,25 +317,25 @@ PUBLIC int livebox_desc_set_category(struct livebox_desc *handle, const char *id
        struct block *block;
 
        if (!handle || !category) {
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        block = calloc(1, sizeof(*block));
        if (!block) {
-               return LB_STATUS_ERROR_MEMORY;
+               return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
        }
 
        block->type = strdup(LB_DESC_TYPE_INFO);
        if (!block->type) {
                free(block);
-               return LB_STATUS_ERROR_MEMORY;
+               return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
        }
 
        block->part = strdup("category");
        if (!block->part) {
                free(block->type);
                free(block);
-               return LB_STATUS_ERROR_MEMORY;
+               return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
        }
 
        block->data = strdup(category);
@@ -343,7 +343,7 @@ PUBLIC int livebox_desc_set_category(struct livebox_desc *handle, const char *id
                free(block->type);
                free(block->part);
                free(block);
-               return LB_STATUS_ERROR_MEMORY;
+               return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
        }
 
        if (id) {
@@ -353,7 +353,7 @@ PUBLIC int livebox_desc_set_category(struct livebox_desc *handle, const char *id
                        free(block->type);
                        free(block->part);
                        free(block);
-                       return LB_STATUS_ERROR_MEMORY;
+                       return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
                }
        }
 
@@ -368,25 +368,25 @@ PUBLIC int livebox_desc_set_size(struct livebox_desc *handle, const char *id, in
        char buffer[BUFSIZ];
 
        if (!handle) {
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        block = calloc(1, sizeof(*block));
        if (!block) {
-               return LB_STATUS_ERROR_MEMORY;
+               return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
        }
 
        block->type = strdup(LB_DESC_TYPE_INFO);
        if (!block->type) {
                free(block);
-               return LB_STATUS_ERROR_MEMORY;
+               return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
        }
 
        block->part = strdup("size");
        if (!block->part) {
                free(block->type);
                free(block);
-               return LB_STATUS_ERROR_MEMORY;
+               return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
        }
 
        if (id) {
@@ -395,7 +395,7 @@ PUBLIC int livebox_desc_set_size(struct livebox_desc *handle, const char *id, in
                        free(block->part);
                        free(block->type);
                        free(block);
-                       return LB_STATUS_ERROR_MEMORY;
+                       return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
                }
        }
 
@@ -405,7 +405,7 @@ PUBLIC int livebox_desc_set_size(struct livebox_desc *handle, const char *id, in
                free(block->part);
                free(block->type);
                free(block);
-               return LB_STATUS_ERROR_MEMORY;
+               return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
        }
 
        block->idx = handle->last_idx++;
@@ -479,27 +479,27 @@ PUBLIC int livebox_desc_set_id(struct livebox_desc *handle, int idx, const char
                if (block->idx == idx) {
                        if (strcasecmp(block->type, LB_DESC_TYPE_SCRIPT)) {
                                ErrPrint("Invalid block is used\n");
-                               return LB_STATUS_ERROR_INVALID;
+                               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
                        }
 
                        free(block->target_id);
                        block->target_id = NULL;
 
                        if (!id || !strlen(id)) {
-                               return LB_STATUS_SUCCESS;
+                               return DBOX_STATUS_ERROR_NONE;
                        }
 
                        block->target_id = strdup(id);
                        if (!block->target_id) {
                                ErrPrint("Heap: %s\n", strerror(errno));
-                               return LB_STATUS_ERROR_MEMORY;
+                               return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
                        }
 
-                       return LB_STATUS_SUCCESS;
+                       return DBOX_STATUS_ERROR_NONE;
                }
        }
 
-       return LB_STATUS_ERROR_NOT_EXIST;
+       return DBOX_STATUS_ERROR_NOT_EXIST;
 }
 
 /*!
@@ -510,7 +510,7 @@ PUBLIC int livebox_desc_add_block(struct livebox_desc *handle, const char *id, c
        struct block *block;
 
        if (!handle || !type) {
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        if (!part) {
@@ -524,14 +524,14 @@ PUBLIC int livebox_desc_add_block(struct livebox_desc *handle, const char *id, c
        block = calloc(1, sizeof(*block));
        if (!block) {
                ErrPrint("Heap: %s\n", strerror(errno));
-               return LB_STATUS_ERROR_MEMORY;
+               return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
        }
 
        block->type = strdup(type);
        if (!block->type) {
                ErrPrint("Heap: %s\n", strerror(errno));
                free(block);
-               return LB_STATUS_ERROR_MEMORY;
+               return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
        }
 
        block->part = strdup(part);
@@ -539,7 +539,7 @@ PUBLIC int livebox_desc_add_block(struct livebox_desc *handle, const char *id, c
                ErrPrint("Heap: %s\n", strerror(errno));
                free(block->type);
                free(block);
-               return LB_STATUS_ERROR_MEMORY;
+               return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
        }
 
        block->data = strdup(data);
@@ -548,7 +548,7 @@ PUBLIC int livebox_desc_add_block(struct livebox_desc *handle, const char *id, c
                free(block->type);
                free(block->part);
                free(block);
-               return LB_STATUS_ERROR_MEMORY;
+               return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
        }
 
        if (option) {
@@ -559,7 +559,7 @@ PUBLIC int livebox_desc_add_block(struct livebox_desc *handle, const char *id, c
                        free(block->type);
                        free(block->part);
                        free(block);
-                       return LB_STATUS_ERROR_MEMORY;
+                       return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
                }
        }
 
@@ -572,7 +572,7 @@ PUBLIC int livebox_desc_add_block(struct livebox_desc *handle, const char *id, c
                        free(block->type);
                        free(block->part);
                        free(block);
-                       return LB_STATUS_ERROR_MEMORY;
+                       return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
                }
        }
 
@@ -587,7 +587,7 @@ PUBLIC int livebox_desc_del_block(struct livebox_desc *handle, int idx)
        struct block *block;
 
        if (!handle || idx < 0) {
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        dlist_foreach(handle->block_list, l, block) {
@@ -600,11 +600,11 @@ PUBLIC int livebox_desc_del_block(struct livebox_desc *handle, int idx)
                        free(block->id);
                        free(block->target_id);
                        free(block);
-                       return LB_STATUS_SUCCESS;
+                       return DBOX_STATUS_ERROR_NONE;
                }
        }
 
-       return LB_STATUS_ERROR_NOT_EXIST;
+       return DBOX_STATUS_ERROR_NOT_EXIST;
 }
 
 static inline int event_handler_wrapper(struct livebox_buffer *buffer, struct buffer_event_data *event_info, void *data)
@@ -617,19 +617,19 @@ static inline int event_handler_wrapper(struct livebox_buffer *buffer, struct bu
        pkgname = provider_buffer_pkgname(buffer);
        if (!pkgname) {
                ErrPrint("pkgname is not valid\n");
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        id = provider_buffer_id(buffer);
        if (!id) {
                ErrPrint("id is not valid[%s]\n", pkgname);
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        if (cbdata->handler) {
                ret = cbdata->handler(buffer, event_info, cbdata->cbdata);
        } else {
-               ret = LB_STATUS_ERROR_FAULT;
+               ret = DBOX_STATUS_ERROR_FAULT;
        }
 
        switch (event_info->type) {
@@ -652,7 +652,7 @@ static inline int event_handler_wrapper(struct livebox_buffer *buffer, struct bu
        case BUFFER_EVENT_DISABLE:
                DbgPrint("Accessibility event: %d\n", event_info->type);
                if (ret < 0) {
-                       (void)provider_send_access_status(pkgname, id, LB_ACCESS_STATUS_ERROR);
+                       (void)provider_send_access_status(pkgname, id, DBOX_ACCESS_STATUS_ERROR);
                } else {
                        (void)provider_send_access_status(pkgname, id, ret);
                }
@@ -663,7 +663,7 @@ static inline int event_handler_wrapper(struct livebox_buffer *buffer, struct bu
        case BUFFER_EVENT_KEY_FOCUS_OUT:
                DbgPrint("Key event: %d\n", event_info->type);
                if (ret < 0) {
-                       (void)provider_send_key_status(pkgname, id, LB_KEY_STATUS_ERROR);
+                       (void)provider_send_key_status(pkgname, id, DBOX_KEY_STATUS_ERROR);
                } else {
                        (void)provider_send_key_status(pkgname, id, ret);
                }
@@ -752,13 +752,13 @@ PUBLIC int livebox_request_update(const char *filename)
 
        if (!filename) {
                ErrPrint("Invalid argument\n");
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        uri = id_to_uri(filename);
        if (!uri) {
                ErrPrint("Heap: %s\n", strerror(errno));
-               return LB_STATUS_ERROR_MEMORY;
+               return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
        }
 
        if (!s_info.request_update_by_id) {
@@ -766,7 +766,7 @@ PUBLIC int livebox_request_update(const char *filename)
                if (!s_info.request_update_by_id) {
                        ErrPrint("\"livebox_request_update_by_id\" is not exists\n");
                        free(uri);
-                       return LB_STATUS_ERROR_FAULT;
+                       return DBOX_STATUS_ERROR_FAULT;
                }
        }
        ret = s_info.request_update_by_id(uri);
@@ -828,7 +828,7 @@ PUBLIC int livebox_release_buffer(struct livebox_buffer *handle)
        struct livebox_buffer_data *user_data;
 
        if (!handle) {
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        user_data = provider_buffer_user_data(handle);
@@ -884,7 +884,7 @@ PUBLIC void *livebox_ref_buffer(struct livebox_buffer *handle)
 PUBLIC int livebox_unref_buffer(void *buffer)
 {
        if (!buffer) {
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        DbgPrint("Unref buffer\n");
@@ -898,30 +898,30 @@ PUBLIC int livebox_sync_buffer(struct livebox_buffer *handle)
        const char *id;
 
        if (!handle) {
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        user_data = provider_buffer_user_data(handle);
        if (!user_data) {
                ErrPrint("Invalid buffer\n");
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        if (user_data->accelerated) {
                DbgPrint("H/W Buffer allocated. skip the sync buffer\n");
-               return LB_STATUS_SUCCESS;
+               return DBOX_STATUS_ERROR_NONE;
        }
 
        pkgname = provider_buffer_pkgname(handle);
        if (!pkgname) {
                ErrPrint("Invalid buffer handler\n");
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        id = provider_buffer_id(handle);
        if (!id) {
                ErrPrint("Invalid buffer handler\n");
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        (void)provider_buffer_sync(handle);
@@ -944,13 +944,13 @@ PUBLIC int livebox_sync_buffer(struct livebox_buffer *handle)
                }
        }
 
-       return LB_STATUS_SUCCESS;
+       return DBOX_STATUS_ERROR_NONE;
 }
 
 PUBLIC int livebox_support_hw_buffer(struct livebox_buffer *handle)
 {
        if (!handle) {
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        return provider_buffer_pixmap_is_support_hw(handle);
@@ -962,16 +962,16 @@ PUBLIC int livebox_create_hw_buffer(struct livebox_buffer *handle)
        int ret;
 
        if (!handle) {
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        user_data = provider_buffer_user_data(handle);
        if (!user_data) {
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        if (user_data->accelerated) {
-               return LB_STATUS_ERROR_ALREADY;
+               return DBOX_STATUS_ERROR_ALREADY;
        }
 
        ret = provider_buffer_pixmap_create_hw(handle);
@@ -985,13 +985,13 @@ PUBLIC int livebox_destroy_hw_buffer(struct livebox_buffer *handle)
 
        if (!handle) {
                LOGD("handle is NULL\n");
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        user_data = provider_buffer_user_data(handle);
        if (!user_data || !user_data->accelerated) {
                LOGD("user_data is NULL\n");
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        user_data->accelerated = 0;
@@ -1020,16 +1020,16 @@ PUBLIC int livebox_buffer_pre_render(struct livebox_buffer *handle)
        struct livebox_buffer_data *user_data;
 
        if (!handle) {
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        user_data = provider_buffer_user_data(handle);
        if (!user_data) {
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        if (!user_data->accelerated) {
-               return LB_STATUS_SUCCESS;
+               return DBOX_STATUS_ERROR_NONE;
        }
 
        /*!
@@ -1047,28 +1047,28 @@ PUBLIC int livebox_buffer_post_render(struct livebox_buffer *handle)
        struct livebox_buffer_data *user_data;
 
        if (!handle) {
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        user_data = provider_buffer_user_data(handle);
        if (!user_data) {
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        if (!user_data->accelerated) {
-               return LB_STATUS_SUCCESS;
+               return DBOX_STATUS_ERROR_NONE;
        }
 
        pkgname = provider_buffer_pkgname(handle);
        if (!pkgname) {
                ErrPrint("Invalid buffer handle\n");
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        id = provider_buffer_id(handle);
        if (!id) {
                ErrPrint("Invalid buffer handler\n");
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        ret = provider_buffer_post_render(handle);
@@ -1095,13 +1095,13 @@ PUBLIC int livebox_buffer_post_render(struct livebox_buffer *handle)
                }
        }
 
-       return LB_STATUS_SUCCESS;
+       return DBOX_STATUS_ERROR_NONE;
 }
 
 PUBLIC int livebox_buffer_stride(struct livebox_buffer *handle)
 {
        if (!handle) {
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        return provider_buffer_stride(handle);
@@ -1113,7 +1113,7 @@ PUBLIC int livebox_content_is_updated(const char *filename, int is_pd)
                s_info.trigger_update_monitor = dlsym(RTLD_DEFAULT, "livebox_trigger_update_monitor");
                if (!s_info.trigger_update_monitor) {
                        ErrPrint("Trigger update monitor function is not exists\n");
-                       return LB_STATUS_ERROR_FAULT;
+                       return DBOX_STATUS_ERROR_FAULT;
                }
        }
 
@@ -1128,20 +1128,20 @@ PUBLIC int livebox_request_close_pd(const char *pkgname, const char *id, int rea
 
        if (!pkgname || !id) {
                ErrPrint("Invalid parameters (%s) (%s)\n", pkgname, id);
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        if (strncmp(id, FILE_SCHEMA, schema_len)) {
                uri = id_to_uri(id);
                if (!uri) {
                        ErrPrint("Heap: %s\n", strerror(errno));
-                       return LB_STATUS_ERROR_MEMORY;
+                       return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
                }
        } else {
                uri = strdup(id);
                if (!uri) {
                        ErrPrint("Heap: %s\n", strerror(errno));
-                       return LB_STATUS_ERROR_MEMORY;
+                       return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
                }
        }
 
@@ -1158,7 +1158,7 @@ PUBLIC int livebox_freeze_scroller(const char *pkgname, const char *id)
        uri = id_to_uri(id);
        if (!uri) {
                ErrPrint("Heap: %s\n", strerror(errno));
-               return LB_STATUS_ERROR_MEMORY;
+               return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
        }
 
        ret = provider_send_hold_scroll(pkgname, uri, 1);
@@ -1174,7 +1174,7 @@ PUBLIC int livebox_release_scroller(const char *pkgname, const char *id)
        uri = id_to_uri(id);
        if (!uri) {
                ErrPrint("Heap: %s\n", strerror(errno));
-               return LB_STATUS_ERROR_MEMORY;
+               return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
        }
 
        ret = provider_send_hold_scroll(pkgname, uri, 0);
@@ -1191,14 +1191,14 @@ PUBLIC int livebox_set_extra_info(const char *id, const char *content, const cha
        uri = id_to_uri(id);
        if (!uri) {
                ErrPrint("Heap: %s\n", strerror(errno));
-               return LB_STATUS_ERROR_MEMORY;
+               return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
        }
 
        pkgname = s_info.find_pkgname(uri);
        if (!pkgname) {
                ErrPrint("Failed to find a package (%s)\n", uri);
                free(uri);
-               return LB_STATUS_ERROR_INVALID;
+               return DBOX_STATUS_ERROR_INVALID_PARAMETER;
        }
 
        handle = provider_buffer_find_buffer(TYPE_LB, pkgname, uri);
@@ -1209,7 +1209,7 @@ PUBLIC int livebox_set_extra_info(const char *id, const char *content, const cha
                if (!user_data) {
                        ErrPrint("User data is not available\n");
                        free(uri);
-                       return LB_STATUS_ERROR_FAULT;
+                       return DBOX_STATUS_ERROR_FAULT;
                }
 
                if (content && strlen(content)) {
@@ -1277,7 +1277,7 @@ PUBLIC int livebox_set_extra_info(const char *id, const char *content, const cha
                }
 
                free(uri);
-               return LB_STATUS_SUCCESS;
+               return DBOX_STATUS_ERROR_NONE;
        }
        free(uri);
 
@@ -1285,7 +1285,7 @@ PUBLIC int livebox_set_extra_info(const char *id, const char *content, const cha
                s_info.update_extra_info = dlsym(RTLD_DEFAULT, "livebox_update_extra_info");
                if (!s_info.update_extra_info) {
                        ErrPrint("Failed to find a \"livebox_update_extra_info\"\n");
-                       return LB_STATUS_ERROR_INVALID;
+                       return DBOX_STATUS_ERROR_INVALID_PARAMETER;
                }
        }
 

diff --git a/src/virtual_window.c b/src/virtual_window.c
index d9a1d3d..fe6f669 100644 (file)
--- a/src/virtual_window.c
+++ b/src/virtual_window.c
@@ -26,8 +26,8 @@
 #include <X11/Xlib.h>
 
 #include <dlog.h>
-#include <livebox-errno.h>
-#include <livebox-service.h>
+#include <dynamicbox_errno.h>
+#include <dynamicbox_service.h>
 
 #include "livebox.h"
 #include "livebox_product.h"
@@ -149,7 +149,7 @@ static int event_handler_cb(struct livebox_buffer *handler, struct buffer_event_
        case BUFFER_EVENT_HIGHLIGHT:
                parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
                if (!parent_elm) {
-                       ret = LB_ACCESS_STATUS_ERROR;
+                       ret = DBOX_ACCESS_STATUS_ERROR;
                        break;
                }
                memset(&action_info, 0, sizeof(action_info));
@@ -164,77 +164,77 @@ static int event_handler_cb(struct livebox_buffer *handler, struct buffer_event_
                if (ret == EINA_TRUE) {
                        if (!get_highlighted_object(parent_elm)) {
                                LOGE("Highlighted object is not found\n");
-                               ret = LB_ACCESS_STATUS_ERROR;
+                               ret = DBOX_ACCESS_STATUS_ERROR;
                        } else {
                                LOGD("Highlighted object is found\n");
-                               ret = LB_ACCESS_STATUS_DONE;
+                               ret = DBOX_ACCESS_STATUS_DONE;
                        }
                } else {
                        LOGE("Action error\n");
-                       ret = LB_ACCESS_STATUS_ERROR;
+                       ret = DBOX_ACCESS_STATUS_ERROR;
                }
                break;
        case BUFFER_EVENT_HIGHLIGHT_NEXT:
                parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
                if (!parent_elm) {
-                       ret = LB_ACCESS_STATUS_ERROR;
+                       ret = DBOX_ACCESS_STATUS_ERROR;
                        break;
                }
                memset(&action_info, 0, sizeof(action_info));
                action_type = ELM_ACCESS_ACTION_HIGHLIGHT_NEXT;
                action_info.highlight_cycle = EINA_FALSE;
                ret = elm_access_action(parent_elm, action_type, &action_info);
-               ret = (ret == EINA_FALSE) ? LB_ACCESS_STATUS_LAST : LB_ACCESS_STATUS_DONE;
+               ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_LAST : DBOX_ACCESS_STATUS_DONE;
                break;
        case BUFFER_EVENT_HIGHLIGHT_PREV:
                parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
                if (!parent_elm) {
-                       ret = LB_ACCESS_STATUS_ERROR;
+                       ret = DBOX_ACCESS_STATUS_ERROR;
                        break;
                }
                memset(&action_info, 0, sizeof(action_info));
                action_type = ELM_ACCESS_ACTION_HIGHLIGHT_PREV;
                action_info.highlight_cycle = EINA_FALSE;
                ret = elm_access_action(parent_elm, action_type, &action_info);
-               ret = (ret == EINA_FALSE) ? LB_ACCESS_STATUS_FIRST : LB_ACCESS_STATUS_DONE;
+               ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_FIRST : DBOX_ACCESS_STATUS_DONE;
                break;
        case BUFFER_EVENT_ACTIVATE:
                parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
                if (!parent_elm) {
-                       ret = LB_ACCESS_STATUS_ERROR;
+                       ret = DBOX_ACCESS_STATUS_ERROR;
                        break;
                }
                memset(&action_info, 0, sizeof(action_info));
                action_type = ELM_ACCESS_ACTION_ACTIVATE;
                ret = elm_access_action(parent_elm, action_type, &action_info);
-               ret = (ret == EINA_FALSE) ? LB_ACCESS_STATUS_ERROR : LB_ACCESS_STATUS_DONE;
+               ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
                break;
        case BUFFER_EVENT_ACTION_UP:
                parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
                if (!parent_elm) {
-                       ret = LB_ACCESS_STATUS_ERROR;
+                       ret = DBOX_ACCESS_STATUS_ERROR;
                        break;
                }
                memset(&action_info, 0, sizeof(action_info));
                action_type = ELM_ACCESS_ACTION_UP;
                ret = elm_access_action(parent_elm, action_type, &action_info);
-               ret = (ret == EINA_FALSE) ? LB_ACCESS_STATUS_ERROR : LB_ACCESS_STATUS_DONE;
+               ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
                break;
        case BUFFER_EVENT_ACTION_DOWN:
                parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
                if (!parent_elm) {
-                       ret = LB_ACCESS_STATUS_ERROR;
+                       ret = DBOX_ACCESS_STATUS_ERROR;
                        break;
                }
                memset(&action_info, 0, sizeof(action_info));
                action_type = ELM_ACCESS_ACTION_DOWN;
                ret = elm_access_action(parent_elm, action_type, &action_info);
-               ret = (ret == EINA_FALSE) ? LB_ACCESS_STATUS_ERROR : LB_ACCESS_STATUS_DONE;
+               ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
                break;
        case BUFFER_EVENT_SCROLL_UP:
                parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
                if (!parent_elm) {
-                       ret = LB_ACCESS_STATUS_ERROR;
+                       ret = DBOX_ACCESS_STATUS_ERROR;
                        break;
                }
                memset(&action_info, 0, sizeof(action_info));
@@ -243,12 +243,12 @@ static int event_handler_cb(struct livebox_buffer *handler, struct buffer_event_
                action_info.y = event_info->info.access.y;
                action_info.mouse_type = event_info->info.access.mouse_type;
                ret = elm_access_action(parent_elm, action_type, &action_info);
-               ret = (ret == EINA_FALSE) ? LB_ACCESS_STATUS_ERROR : LB_ACCESS_STATUS_DONE;
+               ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
                break;
        case BUFFER_EVENT_SCROLL_MOVE:
                parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
                if (!parent_elm) {
-                       ret = LB_ACCESS_STATUS_ERROR;
+                       ret = DBOX_ACCESS_STATUS_ERROR;
                        break;
                }
                memset(&action_info, 0, sizeof(action_info));
@@ -257,12 +257,12 @@ static int event_handler_cb(struct livebox_buffer *handler, struct buffer_event_
                action_info.y = event_info->info.access.y;
                action_info.mouse_type = event_info->info.access.mouse_type;
                ret = elm_access_action(parent_elm, action_type, &action_info);
-               ret = (ret == EINA_FALSE) ? LB_ACCESS_STATUS_ERROR : LB_ACCESS_STATUS_DONE;
+               ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
                break;
        case BUFFER_EVENT_SCROLL_DOWN:
                parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
                if (!parent_elm) {
-                       ret = LB_ACCESS_STATUS_ERROR;
+                       ret = DBOX_ACCESS_STATUS_ERROR;
                        break;
                }
                memset(&action_info, 0, sizeof(action_info));
@@ -271,23 +271,23 @@ static int event_handler_cb(struct livebox_buffer *handler, struct buffer_event_
                action_info.y = event_info->info.access.y;
                action_info.mouse_type = event_info->info.access.mouse_type;
                ret = elm_access_action(parent_elm, action_type, &action_info);
-               ret = (ret == EINA_FALSE) ? LB_ACCESS_STATUS_ERROR : LB_ACCESS_STATUS_DONE;
+               ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
                break;
        case BUFFER_EVENT_UNHIGHLIGHT:
                parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
                if (!parent_elm) {
-                       ret = LB_ACCESS_STATUS_ERROR;
+                       ret = DBOX_ACCESS_STATUS_ERROR;
                        break;
                }
                memset(&action_info, 0, sizeof(action_info));
                action_type = ELM_ACCESS_ACTION_UNHIGHLIGHT;
                ret = elm_access_action(parent_elm, action_type, &action_info);
-               ret = (ret == EINA_FALSE) ? LB_ACCESS_STATUS_ERROR : LB_ACCESS_STATUS_DONE;
+               ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
                break;
        case BUFFER_EVENT_VALUE_CHANGE:
                parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
                if (!parent_elm) {
-                       ret = LB_ACCESS_STATUS_ERROR;
+                       ret = DBOX_ACCESS_STATUS_ERROR;
                        break;
                }
                memset(&action_info, 0, sizeof(action_info));
@@ -296,12 +296,12 @@ static int event_handler_cb(struct livebox_buffer *handler, struct buffer_event_
                action_info.y = event_info->info.access.y;
                action_info.mouse_type = event_info->info.access.mouse_type;
                ret = elm_access_action(parent_elm, action_type, &action_info);
-               ret = (ret == EINA_FALSE) ? LB_ACCESS_STATUS_ERROR : LB_ACCESS_STATUS_DONE;
+               ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
                break;
        case BUFFER_EVENT_MOUSE:
                parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
                if (!parent_elm) {
-                       ret = LB_ACCESS_STATUS_ERROR;
+                       ret = DBOX_ACCESS_STATUS_ERROR;
                        break;
                }
                memset(&action_info, 0, sizeof(action_info));
@@ -310,12 +310,12 @@ static int event_handler_cb(struct livebox_buffer *handler, struct buffer_event_
                action_info.y = event_info->info.access.y;
                action_info.mouse_type = event_info->info.access.mouse_type;
                ret = elm_access_action(parent_elm, action_type, &action_info);
-               ret = (ret == EINA_FALSE) ? LB_ACCESS_STATUS_ERROR : LB_ACCESS_STATUS_DONE;
+               ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
                break;
        case BUFFER_EVENT_BACK:
                parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
                if (!parent_elm) {
-                       ret = LB_ACCESS_STATUS_ERROR;
+                       ret = DBOX_ACCESS_STATUS_ERROR;
                        break;
                }
                memset(&action_info, 0, sizeof(action_info));
@@ -324,12 +324,12 @@ static int event_handler_cb(struct livebox_buffer *handler, struct buffer_event_
                action_info.y = event_info->info.access.y;
                action_info.mouse_type = event_info->info.access.mouse_type;
                ret = elm_access_action(parent_elm, action_type, &action_info);
-               ret = (ret == EINA_FALSE) ? LB_ACCESS_STATUS_ERROR : LB_ACCESS_STATUS_DONE;
+               ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
                break;
        case BUFFER_EVENT_OVER:
                parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
                if (!parent_elm) {
-                       ret = LB_ACCESS_STATUS_ERROR;
+                       ret = DBOX_ACCESS_STATUS_ERROR;
                        break;
                }
                memset(&action_info, 0, sizeof(action_info));
@@ -338,12 +338,12 @@ static int event_handler_cb(struct livebox_buffer *handler, struct buffer_event_
                action_info.y = event_info->info.access.y;
                action_info.mouse_type = event_info->info.access.mouse_type;
                ret = elm_access_action(parent_elm, action_type, &action_info);
-               ret = (ret == EINA_FALSE) ? LB_ACCESS_STATUS_ERROR : LB_ACCESS_STATUS_DONE;
+               ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
                break;
        case BUFFER_EVENT_READ:
                parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
                if (!parent_elm) {
-                       ret = LB_ACCESS_STATUS_ERROR;
+                       ret = DBOX_ACCESS_STATUS_ERROR;
                        break;
                }
                memset(&action_info, 0, sizeof(action_info));
@@ -352,12 +352,12 @@ static int event_handler_cb(struct livebox_buffer *handler, struct buffer_event_
                action_info.y = event_info->info.access.y;
                action_info.mouse_type = event_info->info.access.mouse_type;
                ret = elm_access_action(parent_elm, action_type, &action_info);
-               ret = (ret == EINA_FALSE) ? LB_ACCESS_STATUS_ERROR : LB_ACCESS_STATUS_DONE;
+               ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
                break;
        case BUFFER_EVENT_ENABLE:
                parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
                if (!parent_elm) {
-                       ret = LB_ACCESS_STATUS_ERROR;
+                       ret = DBOX_ACCESS_STATUS_ERROR;
                        break;
                }
                memset(&action_info, 0, sizeof(action_info));
@@ -366,12 +366,12 @@ static int event_handler_cb(struct livebox_buffer *handler, struct buffer_event_
                action_info.y = event_info->info.access.y;
                action_info.mouse_type = event_info->info.access.mouse_type;
                ret = elm_access_action(parent_elm, action_type, &action_info);
-               ret = (ret == EINA_FALSE) ? LB_ACCESS_STATUS_ERROR : LB_ACCESS_STATUS_DONE;
+               ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
                break;
        case BUFFER_EVENT_DISABLE:
                parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
                if (!parent_elm) {
-                       ret = LB_ACCESS_STATUS_ERROR;
+                       ret = DBOX_ACCESS_STATUS_ERROR;
                        break;
                }
                memset(&action_info, 0, sizeof(action_info));
@@ -380,12 +380,12 @@ static int event_handler_cb(struct livebox_buffer *handler, struct buffer_event_
                action_info.y = event_info->info.access.y;
                action_info.mouse_type = event_info->info.access.mouse_type;
                ret = elm_access_action(parent_elm, action_type, &action_info);
-               ret = (ret == EINA_FALSE) ? LB_ACCESS_STATUS_ERROR : LB_ACCESS_STATUS_DONE;
+               ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
                break;
        case BUFFER_EVENT_KEY_DOWN:
                parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
                if (!parent_elm) {
-                       ret = LB_ACCESS_STATUS_ERROR;
+                       ret = DBOX_ACCESS_STATUS_ERROR;
                        break;
                }
 
@@ -401,12 +401,12 @@ static int event_handler_cb(struct livebox_buffer *handler, struct buffer_event_
                        XFree(key_name);
                        XFree(key_string);
                }
-               ret = LB_KEY_STATUS_ERROR;
+               ret = DBOX_KEY_STATUS_ERROR;
                break;
        case BUFFER_EVENT_KEY_UP:
                parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
                if (!parent_elm) {
-                       ret = LB_ACCESS_STATUS_ERROR;
+                       ret = DBOX_ACCESS_STATUS_ERROR;
                        break;
                }
 
@@ -422,12 +422,12 @@ static int event_handler_cb(struct livebox_buffer *handler, struct buffer_event_
                        XFree(key_name);
                        XFree(key_string);
                }
-               ret = LB_KEY_STATUS_ERROR;
+               ret = DBOX_KEY_STATUS_ERROR;
                break;
        case BUFFER_EVENT_KEY_FOCUS_IN:
                parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
                if (!parent_elm) {
-                       ret = LB_ACCESS_STATUS_ERROR;
+                       ret = DBOX_ACCESS_STATUS_ERROR;
                        break;
                }
 
@@ -443,12 +443,12 @@ static int event_handler_cb(struct livebox_buffer *handler, struct buffer_event_
                        XFree(key_name);
                        XFree(key_string);
                }
-               ret = LB_KEY_STATUS_ERROR;
+               ret = DBOX_KEY_STATUS_ERROR;
                break;
        case BUFFER_EVENT_KEY_FOCUS_OUT:
                parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
                if (!parent_elm) {
-                       ret = LB_ACCESS_STATUS_ERROR;
+                       ret = DBOX_ACCESS_STATUS_ERROR;
                        break;
                }
 
@@ -464,7 +464,7 @@ static int event_handler_cb(struct livebox_buffer *handler, struct buffer_event_
                        XFree(key_name);
                        XFree(key_string);
                }
-               ret = LB_KEY_STATUS_ERROR;
+               ret = DBOX_KEY_STATUS_ERROR;
                break;
        default:
                LOGD("Unhandled buffer event (%d)\n", event_info->type);