Fix coding rule

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

1 files changed, 53 insertions, 51 deletions

diff --git a/src/event.c b/src/event.c
index bcb660f..b4a2a08 100644
--- 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;