Support alias appid for use event

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

diff --git a/packaging/capi-appfw-event.spec b/packaging/capi-appfw-event.spec
index d9617c7..aa44ba9 100644 (file)
--- a/packaging/capi-appfw-event.spec
+++ b/packaging/capi-appfw-event.spec
@@ -11,6 +11,7 @@ BuildRequires:  pkgconfig(dlog)
 BuildRequires:  pkgconfig(bundle)
 BuildRequires:  pkgconfig(eventsystem)
 BuildRequires:  pkgconfig(capi-base-common)
+BuildRequires:  pkgconfig(aul)
 
 %description
 An Application event library in Tizen C API

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 2c64151..ccd245c 100644 (file)
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -9,7 +9,7 @@ SET(PREFIX ${CMAKE_INSTALL_PREFIX})
 SET(INC_DIR ${CMAKE_SOURCE_DIR}/include)
 INCLUDE_DIRECTORIES(${INC_DIR})
 
-SET(requires "glib-2.0 dlog bundle eventsystem capi-base-common")
+SET(requires "glib-2.0 dlog bundle eventsystem capi-base-common aul")
 SET(pc_requires "capi-base-common")
 
 INCLUDE(FindPkgConfig)

diff --git a/src/event.c b/src/event.c
index ef7fd03..c0d3cbe 100644 (file)
--- a/src/event.c
+++ b/src/event.c
@@ -16,17 +16,20 @@
 
 #define _GNU_SOURCE
 #include <stdlib.h>
+#include <stdio.h>
 #include <glib.h>
 #include <tizen.h>
 #include <dlog.h>
 #include <app_event.h>
 #include <eventsystem.h>
+#include <aul_svc.h>
 
 #ifdef LOG_TAG
 #undef LOG_TAG
 #endif
 
 #define LOG_TAG "CAPI_APPFW_EVENT"
+#define MAX_SIZE 100
 
 typedef struct event_handler {
        char *event_name;
@@ -36,10 +39,98 @@ typedef struct event_handler {
        void *user_data;
 } event_handler_s;
 
-static int _initialized;
 static event_cb earlier_callback;
 static void *earlier_user_data;
 static pthread_mutex_t register_sync_lock = PTHREAD_MUTEX_INITIALIZER;
+static GHashTable *event_table;
+
+bool get_real_event_name(const char *event_name,
+       char **real_event_name)
+{
+       char *prefix, *user_defined_name;
+       char *real_appid, *alias_appid, *real_event;
+       int ret, len;
+
+       /* event.{sender's appid}.{user-defined name} */
+       prefix = strchr(event_name, '.');
+       if (prefix == NULL)
+               return false;
+
+       user_defined_name = strrchr(event_name, '.');
+       if (user_defined_name == NULL)
+               return false;
+
+       if (prefix == user_defined_name)
+               return false;
+
+       len = strlen(user_defined_name);
+       if (len <= 1 || len > 128)
+               return false;
+
+       len = user_defined_name - prefix;
+       alias_appid = malloc(sizeof(char) * len + 1);
+       if (alias_appid == NULL) {
+               LOGE("out of memory");
+               return false;
+       }
+
+       prefix += 1;
+       snprintf(alias_appid, len, "%s", prefix);
+       ret = aul_svc_get_appid_by_alias_appid(alias_appid, &real_appid);
+       free(alias_appid);
+       if (ret < 0)
+               return false;
+
+       len = 6 /* event. */ + strlen(real_appid)
+               + 1 /* . */ + strlen(user_defined_name);
+       real_event = malloc(sizeof(char) * len + 1);
+       if (real_event == NULL) {
+               LOGE("out of memory");
+               free(real_appid);
+               return false;
+       }
+
+       snprintf(real_event, len, "event.%s%s", real_appid, user_defined_name);
+       free(real_appid);
+       *real_event_name = real_event;
+       LOGI("real_event (%s)->(%s)", event_name, real_event);
+
+       return true;
+
+}
+
+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)
+               return ES_R_OK;
+
+       key = strdup(real_event);
+       if (key == NULL) {
+               ret = ES_R_ENOMEM;
+               goto out;
+       }
+
+       value = strdup(event);
+       if (value == NULL) {
+               ret = ES_R_ENOMEM;
+               goto out;
+       }
+
+out:
+       if (ret == ES_R_OK) {
+               g_hash_table_insert(event_table, key, value);
+       } else {
+               if (key)
+                       free(key);
+               if (value)
+                       free(value);
+       }
+       return ret;
+}
 
 /* LCOV_EXCL_START */
 static const char *event_error_to_string(event_error_e error)
@@ -75,13 +166,17 @@ int event_error(event_error_e error, const char *function, const char *descripti
        return error;
 }
 
-static void event_eventsystem_callback(const char *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;
 
-       LOGD("event_name(%s)", 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) {
                b = bundle_decode(event_data, len);
@@ -89,7 +184,7 @@ static void event_eventsystem_callback(const char *event_name,
                        LOGE("bundle_decode failed");
                        return;
                }
-               earlier_callback(event_name, b, earlier_user_data);
+               earlier_callback(registered_event_name, b, earlier_user_data);
                bundle_free(b);
                return;
        }
@@ -101,7 +196,7 @@ static void event_eventsystem_callback(const char *event_name,
                        return;
                }
 
-               handler->cb(event_name, b, handler->user_data);
+               handler->cb(registered_event_name, b, handler->user_data);
                bundle_free(b);
        }
 }
@@ -113,46 +208,48 @@ int event_add_event_handler(const char *event_name, event_cb callback,
        int event_type = 0;
        unsigned int reg_id = 0;
        event_handler_h handler = NULL;
+       char *real_event_name;
 
        if (event_handler == NULL || event_name == NULL || callback == NULL) {
                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);
+
        handler = calloc(1, sizeof(event_handler_s));
        if (handler == NULL) {
                return event_error(EVENT_ERROR_OUT_OF_MEMORY,
                                __FUNCTION__, NULL);
        }
 
-       handler->event_name = strdup(event_name);
+       if (get_real_event_name(event_name, &real_event_name)) {
+               handler->event_name = real_event_name;
+               ret = set_real_event_info(real_event_name, event_name);
+               if (ret != ES_R_OK)
+                       goto error;
+       } else {
+               handler->event_name = strdup(event_name);
+       }
+
        if (handler->event_name == NULL) {
-               free(handler);
-               return event_error(EVENT_ERROR_OUT_OF_MEMORY,
-                               __FUNCTION__, NULL);
+               ret = ES_R_ENOMEM;
+               goto error;
        }
 
        pthread_mutex_lock(&register_sync_lock);
        earlier_callback = callback;
        earlier_user_data = user_data;
-       ret = eventsystem_register_application_event(event_name, &reg_id,
+       ret = eventsystem_register_application_event(handler->event_name, &reg_id,
                        &event_type, (eventsystem_cb)event_eventsystem_callback,
                        handler);
        earlier_callback = NULL;
        earlier_user_data = NULL;
        pthread_mutex_unlock(&register_sync_lock);
 
-       if (ret < 0) {
-               free(handler->event_name);
-               free(handler);
-               if (ret == ES_R_ENOTPERMITTED) {
-                       return event_error(EVENT_ERROR_PERMISSION_DENIED,
-                                       __FUNCTION__, NULL);
-               } else {
-                       return event_error(EVENT_ERROR_IO_ERROR,
-                                       __FUNCTION__, NULL);
-               }
-       }
+       if (ret < 0)
+               goto error;
 
        handler->reg_id = reg_id;
        handler->event_type = event_type;
@@ -162,6 +259,26 @@ int event_add_event_handler(const char *event_name, event_cb callback,
        *event_handler = handler;
 
        return EVENT_ERROR_NONE;
+
+error:
+       if (handler) {
+               if (handler->event_name)
+                       free(handler->event_name);
+               free(handler);
+       }
+
+       if (ret == ES_R_ENOTPERMITTED) {
+               return event_error(EVENT_ERROR_PERMISSION_DENIED,
+                               __FUNCTION__, NULL);
+
+       } else if (ret == ES_R_ENOMEM) {
+               return event_error(EVENT_ERROR_OUT_OF_MEMORY,
+                               __FUNCTION__, NULL);
+       } else {
+               return event_error(EVENT_ERROR_IO_ERROR,
+                               __FUNCTION__, NULL);
+       }
+
 }
 
 int event_remove_event_handler(event_handler_h event_handler)
@@ -185,10 +302,20 @@ int event_remove_event_handler(event_handler_h event_handler)
 
 int event_publish_app_event(const char *event_name, bundle *event_data)
 {
+       char *real_event_name;
+       int ret;
+
        if (event_data == NULL || event_name == NULL)
                return event_error(EVENT_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 
-       if (eventsystem_send_user_event(event_name, event_data, false) < 0)
+       if (get_real_event_name(event_name, &real_event_name)) {
+               ret = eventsystem_send_user_event(real_event_name, event_data, false);
+               free(real_event_name);
+       } else {
+               ret = eventsystem_send_user_event(event_name, event_data, false);
+       }
+
+       if (ret < 0)
                return event_error(EVENT_ERROR_IO_ERROR, __FUNCTION__, NULL);
 
        return EVENT_ERROR_NONE;
@@ -196,10 +323,20 @@ int event_publish_app_event(const char *event_name, bundle *event_data)
 
 int event_publish_trusted_app_event(const char *event_name, bundle *event_data)
 {
+       char *real_event_name;
+       int ret;
+
        if (event_data == NULL || event_name == NULL)
                return event_error(EVENT_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 
-       if (eventsystem_send_user_event(event_name, event_data, true) < 0)
+       if (get_real_event_name(event_name, &real_event_name)) {
+               ret = eventsystem_send_user_event(real_event_name, event_data, true);
+               free(real_event_name);
+       } else {
+               ret = eventsystem_send_user_event(event_name, event_data, true);
+       }
+
+       if (ret < 0)
                return event_error(EVENT_ERROR_IO_ERROR, __FUNCTION__, NULL);
 
        return EVENT_ERROR_NONE;
@@ -208,11 +345,25 @@ int event_publish_trusted_app_event(const char *event_name, bundle *event_data)
 int event_keep_last_event_data(const char *event_name)
 {
        int ret;
+       char *real_event_name = NULL;
 
        if (event_name == NULL)
                return event_error(EVENT_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 
-       ret = eventsystem_keep_last_event_data(event_name);
+       if (get_real_event_name(event_name, &real_event_name)) {
+               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);
+       } else {
+               ret = eventsystem_keep_last_event_data(event_name);
+       }
+
+
+out:
+       if (real_event_name)
+               free(real_event_name);
+
        if (ret < 0) {
                if (ret == ES_R_ENOMEM)
                        return event_error(EVENT_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);