Fix coding rule

Change-Id: I51fb2cce9587fd0de4793866a42885d4ecf59400
Signed-off-by: Jusung Son <jusung07.son@samsung.com>

diff --git a/src/event.c b/src/event.c
index bcb660fa519e6f0fc4959459f136451330d594aa..b4a2a08e430182c7c428599b0235c9ec0111ed18 100644 (file)
--- a/src/event.c
+++ b/src/event.c
@@ -48,14 +48,14 @@ typedef struct event_handler {
        void *user_data;
 } event_handler_s;
 
-static event_cb earlier_callback;
-static void *earlier_user_data;
-static pthread_mutex_t register_sync_lock = PTHREAD_MUTEX_INITIALIZER;
-static GHashTable *event_table;
+static event_cb __earlier_callback;
+static void *__earlier_user_data;
+static pthread_mutex_t __register_sync_lock = PTHREAD_MUTEX_INITIALIZER;
+static GHashTable *__event_table;
 
 #define KEY_ALIAS_APP_ID "http://tizen.org/metadata/app-event/alias-appid-mode"
 
-int check_alias_appid_mode(const char *real_appid)
+static int __check_alias_appid_mode(const char *real_appid)
 {
        pkgmgrinfo_appinfo_h handle;
        int ret;
@@ -78,7 +78,7 @@ int check_alias_appid_mode(const char *real_appid)
        return alias_mode;
 }
 
-int get_publication_alias_appid_mode(void)
+static int __get_publication_alias_appid_mode(void)
 {
        static int alias_appid_mode = ALIAS_APPID_MODE_UNKNOWN;
        int ret;
@@ -93,11 +93,11 @@ int get_publication_alias_appid_mode(void)
                return alias_appid_mode;
        }
 
-       alias_appid_mode = check_alias_appid_mode(buffer);
+       alias_appid_mode = __check_alias_appid_mode(buffer);
        return alias_appid_mode;
 }
 
-bool get_real_event_name(const char *event_name,
+static bool __get_real_event_name(const char *event_name,
        char **real_event_name, bool publish)
 {
        char *prefix, *user_defined_name;
@@ -135,7 +135,8 @@ bool get_real_event_name(const char *event_name,
        if (ret < 0)
                return false;
 
-       if (publish == false && check_alias_appid_mode(real_appid) != ALIAS_APPID_MODE_ON)
+       if (publish == false
+                       && __check_alias_appid_mode(real_appid) != ALIAS_APPID_MODE_ON)
                return false;
 
        len = 6 /* event. */ + strlen(real_appid)
@@ -156,13 +157,13 @@ bool get_real_event_name(const char *event_name,
 
 }
 
-static int set_real_event_info(
+static int __set_real_event_info(
        const char *real_event, const char *event)
 {
        char *key = NULL, *value = NULL;
        int ret = ES_R_OK;
 
-       if (g_hash_table_lookup(event_table, real_event) != NULL)
+       if (g_hash_table_lookup(__event_table, real_event) != NULL)
                return ES_R_OK;
 
        key = strdup(real_event);
@@ -179,7 +180,7 @@ static int set_real_event_info(
 
 out:
        if (ret == ES_R_OK) {
-               g_hash_table_insert(event_table, key, value);
+               g_hash_table_insert(__event_table, key, value);
        } else {
                if (key)
                        free(key);
@@ -190,7 +191,7 @@ out:
 }
 
 /* LCOV_EXCL_START */
-static const char *event_error_to_string(event_error_e error)
+static const char *__event_error_to_string(event_error_e error)
 {
        switch (error) {
        case EVENT_ERROR_NONE:
@@ -211,37 +212,38 @@ static const char *event_error_to_string(event_error_e error)
 }
 /* LCOV_EXCL_STOP */
 
-int event_error(event_error_e error, const char *function, const char *description)
+static int __event_error(event_error_e error,
+               const char *function, const char *description)
 {
        if (description) {
-               LOGE("[%s] %s(0x%08x) : %s", function, event_error_to_string(error),
+               LOGE("[%s] %s(0x%08x) : %s", function, __event_error_to_string(error),
                        error, description);
        } else {
-               LOGE("[%s] %s(0x%08x)", function, event_error_to_string(error), error);
+               LOGE("[%s] %s(0x%08x)", function, __event_error_to_string(error), error);
        }
 
        return error;
 }
 
-static void event_eventsystem_callback(const char *real_event_name,
+static void __event_eventsystem_callback(const char *real_event_name,
        bundle_raw *event_data, int len, void *user_data)
 {
        event_handler_h handler = (event_handler_h)user_data;
        bundle *b;
        const char *registered_event_name;
 
-       registered_event_name = g_hash_table_lookup(event_table, real_event_name);
+       registered_event_name = g_hash_table_lookup(__event_table, real_event_name);
        LOGD("real_event_name(%s , %s)", real_event_name, registered_event_name);
        if (registered_event_name == NULL)
                registered_event_name = real_event_name;
 
-       if (earlier_callback != NULL) {
+       if (__earlier_callback != NULL) {
                b = bundle_decode(event_data, len);
                if (b == NULL) {
                        LOGE("bundle_decode failed");
                        return;
                }
-               earlier_callback(registered_event_name, b, earlier_user_data);
+               __earlier_callback(registered_event_name, b, __earlier_user_data);
                bundle_free(b);
                return;
        }
@@ -268,22 +270,22 @@ int event_add_event_handler(const char *event_name, event_cb callback,
        char *real_event_name;
 
        if (event_handler == NULL || event_name == NULL || callback == NULL) {
-               return event_error(EVENT_ERROR_INVALID_PARAMETER
+               return __event_error(EVENT_ERROR_INVALID_PARAMETER
                                , __FUNCTION__, NULL);
        }
 
-       if (event_table == NULL)
-               event_table = g_hash_table_new_full(g_str_hash, g_str_equal, free, free);
+       if (__event_table == NULL)
+               __event_table = g_hash_table_new_full(g_str_hash, g_str_equal, free, free);
 
        handler = calloc(1, sizeof(event_handler_s));
        if (handler == NULL) {
-               return event_error(EVENT_ERROR_OUT_OF_MEMORY,
+               return __event_error(EVENT_ERROR_OUT_OF_MEMORY,
                                __FUNCTION__, NULL);
        }
 
-       if (get_real_event_name(event_name, &real_event_name, false)) {
+       if (__get_real_event_name(event_name, &real_event_name, false)) {
                handler->event_name = real_event_name;
-               ret = set_real_event_info(real_event_name, event_name);
+               ret = __set_real_event_info(real_event_name, event_name);
                if (ret != ES_R_OK)
                        goto error;
        } else {
@@ -295,15 +297,15 @@ int event_add_event_handler(const char *event_name, event_cb callback,
                goto error;
        }
 
-       pthread_mutex_lock(&register_sync_lock);
-       earlier_callback = callback;
-       earlier_user_data = user_data;
+       pthread_mutex_lock(&__register_sync_lock);
+       __earlier_callback = callback;
+       __earlier_user_data = user_data;
        ret = eventsystem_register_application_event(handler->event_name, &reg_id,
-                       &event_type, (eventsystem_cb)event_eventsystem_callback,
+                       &event_type, (eventsystem_cb)__event_eventsystem_callback,
                        handler);
-       earlier_callback = NULL;
-       earlier_user_data = NULL;
-       pthread_mutex_unlock(&register_sync_lock);
+       __earlier_callback = NULL;
+       __earlier_user_data = NULL;
+       pthread_mutex_unlock(&__register_sync_lock);
 
        if (ret < 0)
                goto error;
@@ -325,14 +327,14 @@ error:
        }
 
        if (ret == ES_R_ENOTPERMITTED) {
-               return event_error(EVENT_ERROR_PERMISSION_DENIED,
+               return __event_error(EVENT_ERROR_PERMISSION_DENIED,
                                __FUNCTION__, NULL);
 
        } else if (ret == ES_R_ENOMEM) {
-               return event_error(EVENT_ERROR_OUT_OF_MEMORY,
+               return __event_error(EVENT_ERROR_OUT_OF_MEMORY,
                                __FUNCTION__, NULL);
        } else {
-               return event_error(EVENT_ERROR_IO_ERROR,
+               return __event_error(EVENT_ERROR_IO_ERROR,
                                __FUNCTION__, NULL);
        }
 
@@ -343,13 +345,13 @@ int event_remove_event_handler(event_handler_h event_handler)
        int ret;
 
        if (event_handler == NULL) {
-               return event_error(EVENT_ERROR_INVALID_PARAMETER,
+               return __event_error(EVENT_ERROR_INVALID_PARAMETER,
                                __FUNCTION__, NULL);
        }
 
        ret = eventsystem_unregister_application_event(event_handler->reg_id);
        if (ret < 0)
-               return event_error(EVENT_ERROR_IO_ERROR, __FUNCTION__, NULL);
+               return __event_error(EVENT_ERROR_IO_ERROR, __FUNCTION__, NULL);
 
        free(event_handler->event_name);
        free(event_handler);
@@ -363,12 +365,12 @@ int event_publish_app_event(const char *event_name, bundle *event_data)
        int ret;
 
        if (event_data == NULL || event_name == NULL)
-               return event_error(EVENT_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
+               return __event_error(EVENT_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 
-       ret = get_publication_alias_appid_mode();
+       ret = __get_publication_alias_appid_mode();
 
        if (ret == ALIAS_APPID_MODE_ON
-                       && get_real_event_name(event_name, &real_event_name, true)) {
+                       && __get_real_event_name(event_name, &real_event_name, true)) {
                ret = eventsystem_send_user_event(real_event_name, event_data, false);
                free(real_event_name);
        } else {
@@ -376,7 +378,7 @@ int event_publish_app_event(const char *event_name, bundle *event_data)
        }
 
        if (ret < 0)
-               return event_error(EVENT_ERROR_IO_ERROR, __FUNCTION__, NULL);
+               return __event_error(EVENT_ERROR_IO_ERROR, __FUNCTION__, NULL);
 
        return EVENT_ERROR_NONE;
 }
@@ -387,12 +389,12 @@ int event_publish_trusted_app_event(const char *event_name, bundle *event_data)
        int ret;
 
        if (event_data == NULL || event_name == NULL)
-               return event_error(EVENT_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
+               return __event_error(EVENT_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 
-       ret = get_publication_alias_appid_mode();
+       ret = __get_publication_alias_appid_mode();
 
        if (ret == ALIAS_APPID_MODE_ON
-                       && get_real_event_name(event_name, &real_event_name, true)) {
+                       && __get_real_event_name(event_name, &real_event_name, true)) {
                ret = eventsystem_send_user_event(real_event_name, event_data, true);
                free(real_event_name);
        } else {
@@ -400,7 +402,7 @@ int event_publish_trusted_app_event(const char *event_name, bundle *event_data)
        }
 
        if (ret < 0)
-               return event_error(EVENT_ERROR_IO_ERROR, __FUNCTION__, NULL);
+               return __event_error(EVENT_ERROR_IO_ERROR, __FUNCTION__, NULL);
 
        return EVENT_ERROR_NONE;
 }
@@ -411,10 +413,10 @@ int event_keep_last_event_data(const char *event_name)
        char *real_event_name = NULL;
 
        if (event_name == NULL)
-               return event_error(EVENT_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
+               return __event_error(EVENT_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 
-       if (get_real_event_name(event_name, &real_event_name, false)) {
-               ret = set_real_event_info(real_event_name, event_name);
+       if (__get_real_event_name(event_name, &real_event_name, false)) {
+               ret = __set_real_event_info(real_event_name, event_name);
                if (ret != ES_R_OK)
                        goto out;
                ret = eventsystem_keep_last_event_data(real_event_name);
@@ -429,9 +431,9 @@ out:
 
        if (ret < 0) {
                if (ret == ES_R_ENOMEM)
-                       return event_error(EVENT_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
+                       return __event_error(EVENT_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
                else
-                       return event_error(EVENT_ERROR_IO_ERROR, __FUNCTION__, NULL);
+                       return __event_error(EVENT_ERROR_IO_ERROR, __FUNCTION__, NULL);
        }
 
        return EVENT_ERROR_NONE;