Improve database API names

This commit modifies and improves the names of database APIs.
This changes API names from _ua_ to _uam_ to follow consistency in ua-manager.

Change-Id: I84132dbd0af3ddd3e5865eed0384921310810f63
Signed-off-by: Abhay Agarwal <ay.agarwal@samsung.com>

diff --git a/include/ua-api.h b/include/ua-api.h
index 72c6a32..fce9f59 100644 (file)
--- a/include/ua-api.h
+++ b/include/ua-api.h
@@ -1223,7 +1223,7 @@ int _uam_service_remove_device(const char *service, char *device_id,
  * @post
  */
 int _uam_service_set_device_discriminant(const char *service,
-       char *device_id, uam_tech_type_e tech_type, gboolean discriminant);
+       const char *device_id, uam_tech_type_e tech_type, gboolean discriminant);
 
 /**
  * @brief Sets detction cycle per eash service.

diff --git a/ua-api/src/ua-api.c b/ua-api/src/ua-api.c
index bee8f4a..341b702 100644 (file)
--- a/ua-api/src/ua-api.c
+++ b/ua-api/src/ua-api.c
@@ -999,7 +999,7 @@ UAM_EXPORT_API int _uam_service_remove_device(const char *service,
 }
 
 UAM_EXPORT_API int _uam_service_set_device_discriminant(const char *service,
-       char *device_id, uam_tech_type_e tech_type, gboolean discriminant)
+       const char *device_id, uam_tech_type_e tech_type, gboolean discriminant)
 {
        FUNC_ENTRY;
        int ret;

diff --git a/ua-daemon/include/ua-manager-database.h b/ua-daemon/include/ua-manager-database.h
index 6dcdeb2..c5d6461 100644 (file)
--- a/ua-daemon/include/ua-manager-database.h
+++ b/ua-daemon/include/ua-manager-database.h
@@ -87,15 +87,15 @@ int _uam_user_db_initialize(void);
 int _uam_user_db_deinitialize(void);
 
 /* select operations */
-GSList *_ua_db_get_all_users(void);
-int _ua_db_get_user(int user_id, db_user_info_t *info);
+GSList *_uam_db_get_all_users(void);
+int _uam_db_get_user(int user_id, db_user_info_t *info);
 
 /* delete operations */
-int _ua_db_delete_by_user_id(int user_id);
+int _uam_db_delete_by_user_id(int user_id);
 int _uam_user_db_clear(void);
 
 /* insert */
-int _ua_db_insert_user_info(int* user_id, const char *name, const char *account);
+int _uam_db_insert_user_info(int* user_id, const char *name, const char *account);
 
 /* DEVICE QUERIES */
 typedef struct {
@@ -106,33 +106,33 @@ typedef struct {
 } db_device_info_t;
 
 /* db init/deinit */
-int _ua_device_db_initialize(void);
-int _ua_device_db_deinitialize(void);
+int _uam_device_db_initialize(void);
+int _uam_device_db_deinitialize(void);
 
 /* select operations */
-GSList *_ua_device_db_get_all_devices(void);
-int _ua_device_db_get_device(
+GSList *_uam_device_db_get_all_devices(void);
+int _uam_device_db_get_device(
        char *device_id, int tech_type, char *address, db_device_info_t *info);
 int _uam_db_get_device_number(
        const char *device_id, int tech_type, const char *address, int *device_number);
 
 /* delete operations */
 int _uam_device_db_clear(void);
-int _ua_device_db_delete_device_info(
+int _uam_device_db_delete_device_info(
        const char *device_id, int tech_type, const char *address);
 
 /* insert */
-int _ua_device_db_insert_device_info(
+int _uam_device_db_insert_device_info(
        int user_id, const uam_device_info_s *dev_info, int presence_state, long timestamp);
 
 /* update */
-int _ua_device_db_update_device_timestamp(
+int _uam_device_db_update_device_timestamp(
        char *device_id, int tech_type, char *address, long timestamp);
-int _ua_device_db_update_device_presence(
+int _uam_device_db_update_device_presence(
        char *device_id, int tech_type, char *address, int presence_state);
-int _ua_device_db_update_device_ip_address(
+int _uam_device_db_update_device_ip_address(
        char *device_id, int tech_type, char *address, char *ip_address);
-int _ua_device_db_update_device_device(char *device_id, int tech_type,
+int _uam_device_db_update_device_device(char *device_id, int tech_type,
        char *address, char *ip, char os_type, char discriminant, uam_ble_payload_s payload);
 
 /* SERVICE QUERIES */
@@ -146,16 +146,16 @@ typedef struct {
 } db_service_info_t;
 
 /* db init/deinit */
-int _ua_service_db_initialize(void);
-int _ua_service_db_deinitialize(void);
+int _uam_service_db_initialize(void);
+int _uam_service_db_deinitialize(void);
 
 /* select operations */
 int _uam_db_get_service_info(const char *service_name, db_service_info_t *info);
-GSList *_ua_service_db_get_all_services(void);
+GSList *_uam_service_db_get_all_services(void);
 
 /* delete operations */
 int _uam_db_delete_service_info(const char *service_name);
-int _ua_service_db_clear(void);
+int _uam_service_db_clear(void);
 
 /* insert */
 int _uam_db_insert_service_info(
@@ -175,8 +175,8 @@ typedef struct {
 } db_svc_dev_info_t;
 
 /* db init/deinit */
-int _ua_device_service_db_initialize(void);
-int _ua_device_service_db_deinitialize(void);
+int _uam_device_service_db_initialize(void);
+int _uam_device_service_db_deinitialize(void);
 
 /* select operations */
 GSList *_uam_db_get_service(int device_number);
@@ -187,14 +187,14 @@ int _uam_db_get_device_services_count(const char *device_id, int tech_type,
 GSList *_uam_db_get_service_devices_info();
 
 /* delete operations */
-int _ua_device_service_db_clear(void);
+int _uam_device_service_db_clear(void);
 int _uam_db_delete_service_number(int service_number);
 int _uam_db_delete_device_service_number(
        int device_number, int service_number);
 int _uam_db_delete_device_service(const char *service_name);
 int _uam_db_delete_device_service_info(const char *device_id, int tech_type,
                const char *address, const char *service_name);
-int _uam_db_delete_device_info(const char *device_id, int tech_type,
+int _uam_db_delete_device_service_mapping(const char *device_id, int tech_type,
                const char *address);
 
 /* insert */

diff --git a/ua-daemon/src/ua-manager-core.c b/ua-daemon/src/ua-manager-core.c
index 7b68ded..3af00db 100644 (file)
--- a/ua-daemon/src/ua-manager-core.c
+++ b/ua-daemon/src/ua-manager-core.c
@@ -288,9 +288,9 @@ static void __remove_user_device(gpointer data)
                __send_device_event(UAM_EVENT_DEVICE_REMOVED, &dev_info);
 
                /* Remove device from database */
-               if (UAM_ERROR_NONE != _ua_device_db_delete_device_info(
+               if (UAM_ERROR_NONE != _uam_device_db_delete_device_info(
                                        dev_info.device_id, dev_info.type, dev_info.mac))
-                       UAM_ERR("_ua_device_db_delete_device_info failed");
+                       UAM_ERR("_uam_device_db_delete_device_info failed");
        }
 
        __free_user_device(device);
@@ -785,8 +785,8 @@ int _uam_core_add_user(const char *account, const char *name)
        user = g_new0(uam_db_user_info_t, 1);
 
        /* Add user to database */
-       if (UAM_ERROR_NONE != _ua_db_insert_user_info(&(user->user_id), name, account)) {
-               UAM_ERR("_ua_db_insert_user_info failed");
+       if (UAM_ERROR_NONE != _uam_db_insert_user_info(&(user->user_id), name, account)) {
+               UAM_ERR("_uam_db_insert_user_info failed");
                g_free(user);
                return UAM_ERROR_DB_FAILED;
        }
@@ -818,8 +818,8 @@ int _uam_core_remove_user(const char *account)
        user = l->data;
 
        /* Remove user from database */
-       if (UAM_ERROR_NONE != _ua_db_delete_by_user_id(user->user_id)) {
-               UAM_ERR("_ua_db_delete_by_user_id failed");
+       if (UAM_ERROR_NONE != _uam_db_delete_by_user_id(user->user_id)) {
+               UAM_ERR("_uam_db_delete_by_user_id failed");
                return UAM_ERROR_DB_FAILED;
        }
 
@@ -955,9 +955,9 @@ static int __uam_remove_device(int user_id, uam_db_device_info_t *device,
        __send_device_event(UAM_EVENT_DEVICE_REMOVED, dev_info);
 
        /* Remove device from database */
-       if (UAM_ERROR_NONE != _ua_device_db_delete_device_info(
+       if (UAM_ERROR_NONE != _uam_device_db_delete_device_info(
                                dev_info->device_id, dev_info->type, dev_info->mac))
-               UAM_ERR("_ua_device_db_delete_device_info failed");
+               UAM_ERR("_uam_device_db_delete_device_info failed");
 
        /* Remove device from service */
        for (l = tech->svc_list; l; l = g_slist_next(l)) {
@@ -1155,11 +1155,11 @@ int _uam_core_update_device(const uam_device_info_s *a_device)
                /* Update device's updated information to database */
                __copy_tech_info_to_device_info(tech, &temp);
 
-               ret = _ua_device_db_update_device_device(temp.device_id, temp.type,
+               ret = _uam_device_db_update_device_device(temp.device_id, temp.type,
                                temp.mac, temp.ipv4_addr, temp.operating_system, temp.discriminant,
                                temp.payload);
                if (UAM_ERROR_NONE != ret)
-                       UAM_WARN("_ua_device_db_update_device_device failed [%d]", ret);
+                       UAM_WARN("_uam_device_db_update_device_device failed [%d]", ret);
        }
 
        /* Set/update registered device list to plugins */
@@ -2120,7 +2120,7 @@ int _uam_core_init(void)
                UAM_ERR("_uam_pm_set_detection_window(%d) failed", detection_window);
 
        /* Fetch user list */
-       db_users = _ua_db_get_all_users();
+       db_users = _uam_db_get_all_users();
        if (!db_users) {
                UAM_INFO_C("No users in database");
                return UAM_ERROR_NONE;
@@ -2143,7 +2143,7 @@ int _uam_core_init(void)
        }
 
        /* Fetch service list */
-       db_svc_list = _ua_service_db_get_all_services();
+       db_svc_list = _uam_service_db_get_all_services();
        if (!db_svc_list) {
                UAM_INFO_C("No services in database");
                return UAM_ERROR_NONE;
@@ -2170,7 +2170,7 @@ int _uam_core_init(void)
        }
 
        /* Fetch device list */
-       db_devices = _ua_device_db_get_all_devices();
+       db_devices = _uam_device_db_get_all_devices();
        if (!db_devices) {
                UAM_INFO_C("No Devices registered in database");
                return UAM_ERROR_NONE;
@@ -2412,7 +2412,7 @@ void _uam_core_handle_device_added(int status,
                                UAM_PRESENCE_STATE_PRESENT, timestamp, svc_list);
 
                /* Add device to database */
-               if (UAM_ERROR_NONE != _ua_device_db_insert_device_info(user->user_id,
+               if (UAM_ERROR_NONE != _uam_device_db_insert_device_info(user->user_id,
                                        dev_info, UAM_PRESENCE_STATE_PRESENT, timestamp))
                        UAM_WARN("Device addition to persistent DB failed");
 
@@ -2726,20 +2726,20 @@ void _uam_core_handle_presence_detected(unsigned int sensor,
                        addr_info->address = g_strdup(dev_info->ipv4_addr);
 
                        /* Update address in DB */
-                       if (UAM_ERROR_NONE != _ua_device_db_update_device_ip_address(dev_info->device_id,
+                       if (UAM_ERROR_NONE != _uam_device_db_update_device_ip_address(dev_info->device_id,
                                        dev_info->type, dev_info->mac, dev_info->ipv4_addr))
-                               UAM_WARN("_ua_device_db_update_device_ip_address failed");
+                               UAM_WARN("_uam_device_db_update_device_ip_address failed");
                }
        }
 
        /* Update database (presence state & timestamp) */
-       if (UAM_ERROR_NONE != _ua_device_db_update_device_timestamp(dev_info->device_id,
+       if (UAM_ERROR_NONE != _uam_device_db_update_device_timestamp(dev_info->device_id,
                                dev_info->type, dev_info->mac, tech->timestamp))
-               UAM_WARN("_ua_device_db_update_device_timestamp failed");
+               UAM_WARN("_uam_device_db_update_device_timestamp failed");
 
-       if (UAM_ERROR_NONE != _ua_device_db_update_device_presence(dev_info->device_id,
+       if (UAM_ERROR_NONE != _uam_device_db_update_device_presence(dev_info->device_id,
                                dev_info->type, dev_info->mac, tech->presence_state))
-               UAM_WARN("_ua_device_db_update_device_presence failed");
+               UAM_WARN("_uam_device_db_update_device_presence failed");
 
        __send_user_presence_event(tech, sensor, dev_info->device_id);
 
@@ -2906,9 +2906,9 @@ void _uam_core_handle_absence_detected(unsigned int sensor,
        tech->presence_state = UAM_PRESENCE_STATE_ABSENT;
 
        /* Update database (presence state) */
-       if (UAM_ERROR_NONE != _ua_device_db_update_device_presence(dev_info->device_id,
+       if (UAM_ERROR_NONE != _uam_device_db_update_device_presence(dev_info->device_id,
                                dev_info->type, dev_info->mac, tech->presence_state))
-               UAM_WARN("_ua_device_db_update_device_presence failed");
+               UAM_WARN("_uam_device_db_update_device_presence failed");
 
        FUNC_EXIT;
 }
@@ -3273,7 +3273,7 @@ int _uam_core_register_service(uam_service_info_s *svc)
 
        /* Add service to database */
        if (UAM_ERROR_NONE != _uam_db_insert_service_info(&service_number, svc, service->cycle)) {
-               UAM_ERR("_ua_db_insert_service_info failed");
+               UAM_ERR("_uam_db_insert_service_info failed");
                g_free(service);
                return UAM_ERROR_DB_FAILED;
        }
@@ -3347,7 +3347,7 @@ int _uam_core_unregister_service(const char *svc_name)
 
        /* Remove service from database */
        if (UAM_ERROR_NONE != _uam_db_delete_service_info(service->name)) {
-               UAM_ERR("_ua_db_delete_service_info failed");
+               UAM_ERR("_uam_db_delete_service_info failed");
                return UAM_ERROR_DB_FAILED;
        }
 

diff --git a/ua-daemon/src/ua-manager-db.c b/ua-daemon/src/ua-manager-db.c
index c257241..ad92dc3 100644 (file)
--- a/ua-daemon/src/ua-manager-db.c
+++ b/ua-daemon/src/ua-manager-db.c
@@ -492,9 +492,9 @@ int _uam_db_initialize(void)
 
        /* initialize tables */
        EXEC(UAM_ERROR_NONE, _uam_user_db_initialize(), handle_error);
-       EXEC(UAM_ERROR_NONE, _ua_device_db_initialize(), handle_error);
-       EXEC(UAM_ERROR_NONE, _ua_service_db_initialize(), handle_error);
-       EXEC(UAM_ERROR_NONE, _ua_device_service_db_initialize(), handle_error);
+       EXEC(UAM_ERROR_NONE, _uam_device_db_initialize(), handle_error);
+       EXEC(UAM_ERROR_NONE, _uam_service_db_initialize(), handle_error);
+       EXEC(UAM_ERROR_NONE, _uam_device_service_db_initialize(), handle_error);
        EXEC(UAM_ERROR_NONE, _uam_adv_db_initialize(), handle_error);
 
        FUNC_EXIT;
@@ -513,9 +513,9 @@ int _uam_db_deinitialize(void)
        retv_if(NULL == database, UAM_ERROR_NONE);
 
        _uam_user_db_deinitialize();
-       _ua_device_db_deinitialize();
-       _ua_service_db_deinitialize();
-       _ua_device_service_db_deinitialize();
+       _uam_device_db_deinitialize();
+       _uam_service_db_deinitialize();
+       _uam_device_service_db_deinitialize();
        _uam_adv_db_deinitialize();
 
        FUNC_EXIT;
@@ -528,8 +528,8 @@ int _uam_db_clear(void)
 
        EXEC(UAM_ERROR_NONE, _uam_user_db_clear(), handle_error);
        EXEC(UAM_ERROR_NONE, _uam_device_db_clear(), handle_error);
-       EXEC(UAM_ERROR_NONE, _ua_service_db_clear(), handle_error);
-       EXEC(UAM_ERROR_NONE, _ua_device_service_db_clear(), handle_error);
+       EXEC(UAM_ERROR_NONE, _uam_service_db_clear(), handle_error);
+       EXEC(UAM_ERROR_NONE, _uam_device_service_db_clear(), handle_error);
        EXEC(UAM_ERROR_NONE, _uam_adv_db_clear(), handle_error);
        UAM_DBG("Table data deleted ");
 

diff --git a/ua-daemon/src/ua-manager-device-db.c b/ua-daemon/src/ua-manager-device-db.c
index 7721d6d..43ec667 100644 (file)
--- a/ua-daemon/src/ua-manager-device-db.c
+++ b/ua-daemon/src/ua-manager-device-db.c
@@ -63,7 +63,7 @@
 #define DELETE_DEVICE_INFO "delete from devices " \
        "WHERE device_id = ? AND tech_type = ? AND address = ?"
 
-static void __ua_device_finalize_delete(void);
+static void __uam_device_finalize_delete(void);
 
 /* DELETE statements */
 static sqlite3_stmt *delete_all_devices;
@@ -87,7 +87,7 @@ static sqlite3_stmt *insert_device_info;
 extern sqlite3 *database;
 static int max_device_number;
 
-static void __ua_device_finalize_delete(void)
+static void __uam_device_finalize_delete(void)
 {
        FUNC_ENTRY;
 
@@ -97,7 +97,7 @@ static void __ua_device_finalize_delete(void)
        FUNC_EXIT;
 }
 
-static void __ua_device_finalize_select(void)
+static void __uam_device_finalize_select(void)
 {
        FUNC_ENTRY;
 
@@ -109,7 +109,7 @@ static void __ua_device_finalize_select(void)
        FUNC_EXIT;
 }
 
-static void __ua_device_finalize_insert(void)
+static void __uam_device_finalize_insert(void)
 {
        FUNC_ENTRY;
 
@@ -118,7 +118,7 @@ static void __ua_device_finalize_insert(void)
        FUNC_EXIT;
 }
 
-static void __ua_device_finalize_update(void)
+static void __uam_device_finalize_update(void)
 {
        FUNC_ENTRY;
 
@@ -130,7 +130,7 @@ static void __ua_device_finalize_update(void)
        FUNC_EXIT;
 }
 
-static int __ua_device_prepare_delete(sqlite3 *db)
+static int __uam_device_prepare_delete(sqlite3 *db)
 {
        FUNC_ENTRY;
        int rc;
@@ -142,16 +142,16 @@ static int __ua_device_prepare_delete(sqlite3 *db)
        }
 
        PREPARE_QUERY(rc, db, delete_all_devices,
-               DELETE_ALL_DEVICES,     __ua_device_finalize_delete);
+               DELETE_ALL_DEVICES,     __uam_device_finalize_delete);
        PREPARE_QUERY(rc, db, delete_device_info,
-               DELETE_DEVICE_INFO, __ua_device_finalize_delete);
+               DELETE_DEVICE_INFO, __uam_device_finalize_delete);
 
        initialized = 1;
        FUNC_EXIT;
        return rc;
 }
 
-static int __ua_device_prepare_select(sqlite3 *db)
+static int __uam_device_prepare_select(sqlite3 *db)
 {
        FUNC_ENTRY;
        int rc;
@@ -163,20 +163,20 @@ static int __ua_device_prepare_select(sqlite3 *db)
        }
 
        PREPARE_QUERY(rc, db, select_all_devices,
-               SELECT_ALL_DEVICES, __ua_device_finalize_select);
+               SELECT_ALL_DEVICES, __uam_device_finalize_select);
        PREPARE_QUERY(rc, db, select_device,
-               SELECT_DEVICE, __ua_device_finalize_select);
+               SELECT_DEVICE, __uam_device_finalize_select);
        PREPARE_QUERY(rc, db, select_device_number,
-               SELECT_DEVICE_NUMBER, __ua_device_finalize_select);
+               SELECT_DEVICE_NUMBER, __uam_device_finalize_select);
        PREPARE_QUERY(rc, db, select_max_device_number,
-               SELECT_MAX_DEVICE_NUMBER, __ua_device_finalize_select);
+               SELECT_MAX_DEVICE_NUMBER, __uam_device_finalize_select);
 
        initialized = 1;
        FUNC_EXIT;
        return rc;
 }
 
-static int __ua_device_prepare_update(sqlite3 *db)
+static int __uam_device_prepare_update(sqlite3 *db)
 {
        FUNC_ENTRY;
        int rc;
@@ -188,20 +188,20 @@ static int __ua_device_prepare_update(sqlite3 *db)
        }
 
        PREPARE_QUERY(rc, db, update_timestamp,
-               UPDATE_TIMESTAMP, __ua_device_finalize_update);
+               UPDATE_TIMESTAMP, __uam_device_finalize_update);
        PREPARE_QUERY(rc, db, update_presence,
-               UPDATE_PRESENCE, __ua_device_finalize_update);
+               UPDATE_PRESENCE, __uam_device_finalize_update);
        PREPARE_QUERY(rc, db, update_ip_address,
-               UPDATE_IP_ADDRESS, __ua_device_finalize_update);
+               UPDATE_IP_ADDRESS, __uam_device_finalize_update);
        PREPARE_QUERY(rc, db, update_device,
-               UPDATE_DEVICE, __ua_device_finalize_update);
+               UPDATE_DEVICE, __uam_device_finalize_update);
 
        initialized = 1;
        FUNC_EXIT;
        return rc;
 }
 
-static int __ua_device_prepare_insert(sqlite3 *db)
+static int __uam_device_prepare_insert(sqlite3 *db)
 {
        FUNC_ENTRY;
        int rc;
@@ -213,14 +213,14 @@ static int __ua_device_prepare_insert(sqlite3 *db)
        }
 
        PREPARE_QUERY(rc, db, insert_device_info,
-               INSERT_DEVICE, __ua_device_finalize_insert);
+               INSERT_DEVICE, __uam_device_finalize_insert);
 
        initialized = 1;
        FUNC_EXIT;
        return rc;
 }
 
-static int __ua_device_table_devicesinfo_prepare(sqlite3 *db)
+static int __uam_device_table_devicesinfo_prepare(sqlite3 *db)
 {
        FUNC_ENTRY;
 
@@ -231,22 +231,22 @@ static int __ua_device_table_devicesinfo_prepare(sqlite3 *db)
                return UAM_ERROR_DB_FAILED;
        }
 
-       DB_ACTION(__ua_device_prepare_delete(db), error_code, handle_error);
-       DB_ACTION(__ua_device_prepare_select(db), error_code, handle_error);
-       DB_ACTION(__ua_device_prepare_update(db), error_code, handle_error);
-       DB_ACTION(__ua_device_prepare_insert(db), error_code, handle_error);
+       DB_ACTION(__uam_device_prepare_delete(db), error_code, handle_error);
+       DB_ACTION(__uam_device_prepare_select(db), error_code, handle_error);
+       DB_ACTION(__uam_device_prepare_update(db), error_code, handle_error);
+       DB_ACTION(__uam_device_prepare_insert(db), error_code, handle_error);
 
 handle_error:
        FUNC_EXIT;
        return error_code;
 }
 
-static void __ua_device_table_devicesinfo_finalize(void)
+static void __uam_device_table_devicesinfo_finalize(void)
 {
        FUNC_ENTRY;
-       __ua_device_finalize_delete();
-       __ua_device_finalize_select();
-       __ua_device_finalize_insert();
+       __uam_device_finalize_delete();
+       __uam_device_finalize_select();
+       __uam_device_finalize_insert();
        FUNC_EXIT;
 }
 
@@ -279,24 +279,24 @@ int _uam_db_get_max_device_number(void)
        return error_code;
 }
 
-int _ua_device_db_deinitialize(void)
+int _uam_device_db_deinitialize(void)
 {
        FUNC_ENTRY;
 
        retv_if(NULL == database, UAM_ERROR_NONE);
 
-       __ua_device_table_devicesinfo_finalize();
+       __uam_device_table_devicesinfo_finalize();
        sqlite3_close(database);
 
        FUNC_EXIT;
        return UAM_ERROR_NONE;
 }
 
-int _ua_device_db_initialize(void)
+int _uam_device_db_initialize(void)
 {
        FUNC_ENTRY;
 
-       EXEC(UAM_ERROR_NONE, __ua_device_table_devicesinfo_prepare(database), handle_error);
+       EXEC(UAM_ERROR_NONE, __uam_device_table_devicesinfo_prepare(database), handle_error);
        if (_uam_db_get_max_device_number() != UAM_ERROR_NONE)
                goto handle_error;
 
@@ -304,12 +304,12 @@ int _ua_device_db_initialize(void)
        return UAM_ERROR_NONE;
 
 handle_error:
-       _ua_device_db_deinitialize();
+       _uam_device_db_deinitialize();
        FUNC_EXIT;
        return UAM_ERROR_DB_FAILED;
 }
 
-int _ua_device_db_update_device_ip_address(char *device_id, int tech_type,
+int _uam_device_db_update_device_ip_address(char *device_id, int tech_type,
        char *address,
                char *ip_address)
 {
@@ -344,7 +344,7 @@ handle_error:
        return error_code;
 }
 
-int _ua_device_db_update_device_presence(char *device_id, int tech_type,
+int _uam_device_db_update_device_presence(char *device_id, int tech_type,
        char *address, int presence_state)
 {
        int error_code = UAM_ERROR_NONE;
@@ -377,7 +377,7 @@ handle_error:
        return error_code;
 }
 
-int _ua_device_db_update_device_timestamp(char *device_id, int tech_type,
+int _uam_device_db_update_device_timestamp(char *device_id, int tech_type,
                                          char *address, long timestamp)
 {
        int error_code = UAM_ERROR_NONE;
@@ -410,7 +410,7 @@ handle_error:
        return error_code;
 }
 
-int _ua_device_db_update_device_device(char *device_id, int tech_type,
+int _uam_device_db_update_device_device(char *device_id, int tech_type,
        char *address, char *ip, char os_type, char discriminant, uam_ble_payload_s payload)
 {
        int error_code = UAM_ERROR_NONE;
@@ -455,7 +455,7 @@ handle_error:
        return error_code;
 }
 
-int _ua_device_db_insert_device_info(int user_id,
+int _uam_device_db_insert_device_info(int user_id,
        const uam_device_info_s *dev_info, int presence_state, long timestamp)
 {
        FUNC_ENTRY;
@@ -515,7 +515,7 @@ handle_error:
        return error_code;
 }
 
-int _ua_device_db_delete_device_info(const char *device_id, int tech_type,
+int _uam_device_db_delete_device_info(const char *device_id, int tech_type,
        const char *address)
 {
        FUNC_ENTRY;
@@ -531,7 +531,7 @@ int _ua_device_db_delete_device_info(const char *device_id, int tech_type,
        DB_ACTION(sqlite3_bind_text(stmt, 3, address, -1, SQLITE_STATIC),
                error_code, handle_error);
 
-       error_code = _uam_db_delete_device_info(device_id, tech_type, address);
+       error_code = _uam_db_delete_device_service_mapping(device_id, tech_type, address);
        if (sqlite3_step(stmt) != SQLITE_DONE) {
                UAM_ERR("Failed to delete device info %s",
                         sqlite3_errmsg(__uam_db_recover_database()));
@@ -545,7 +545,7 @@ handle_error:
        return error_code;
 }
 
-int _ua_device_db_get_device(char *device_id, int tech_type, char *address,
+int _uam_device_db_get_device(char *device_id, int tech_type, char *address,
                db_device_info_t *info)
 {
        FUNC_ENTRY;
@@ -653,7 +653,7 @@ handle_error:
        return error_code;
 }
 
-GSList *_ua_device_db_get_all_devices(void)
+GSList *_uam_device_db_get_all_devices(void)
 {
        FUNC_ENTRY;
        int rc;

diff --git a/ua-daemon/src/ua-manager-device-service-db.c b/ua-daemon/src/ua-manager-device-service-db.c
index e23589e..e912ee1 100644 (file)
--- a/ua-daemon/src/ua-manager-device-service-db.c
+++ b/ua-daemon/src/ua-manager-device-service-db.c
@@ -71,7 +71,7 @@ static sqlite3_stmt *update_device_service;
 
 extern sqlite3 *database;
 
-static void __ua_device_service_finalize_delete(void)
+static void __uam_device_service_finalize_delete(void)
 {
        FUNC_ENTRY;
 
@@ -83,7 +83,7 @@ static void __ua_device_service_finalize_delete(void)
        FUNC_EXIT;
 }
 
-static void __ua_device_service_finalize_select(void)
+static void __uam_device_service_finalize_select(void)
 {
        FUNC_ENTRY;
 
@@ -94,7 +94,7 @@ static void __ua_device_service_finalize_select(void)
        FUNC_EXIT;
 }
 
-static void __ua_device_service_finalize_insert(void)
+static void __uam_device_service_finalize_insert(void)
 {
        FUNC_ENTRY;
 
@@ -103,7 +103,7 @@ static void __ua_device_service_finalize_insert(void)
        FUNC_EXIT;
 }
 
-static void __ua_device_service_finalize_update(void)
+static void __uam_device_service_finalize_update(void)
 {
        FUNC_ENTRY;
 
@@ -112,7 +112,7 @@ static void __ua_device_service_finalize_update(void)
        FUNC_EXIT;
 }
 
-static int __ua_device_service_prepare_delete(sqlite3 *db)
+static int __uam_device_service_prepare_delete(sqlite3 *db)
 {
        FUNC_ENTRY;
        int rc;
@@ -124,20 +124,20 @@ static int __ua_device_service_prepare_delete(sqlite3 *db)
        }
 
        PREPARE_QUERY(rc, db, delete_all_device_services,
-               DELETE_ALL_DEVICE_SERVICES, __ua_device_service_finalize_delete);
+               DELETE_ALL_DEVICE_SERVICES, __uam_device_service_finalize_delete);
        PREPARE_QUERY(rc, db, delete_service,
-               DELETE_SERVICE, __ua_device_service_finalize_delete);
+               DELETE_SERVICE, __uam_device_service_finalize_delete);
        PREPARE_QUERY(rc, db, delete_device_service,
-               DELETE_DEVICE_SERVICE, __ua_device_service_finalize_delete);
+               DELETE_DEVICE_SERVICE, __uam_device_service_finalize_delete);
        PREPARE_QUERY(rc, db, delete_device,
-               DELETE_DEVICE, __ua_device_service_finalize_delete);
+               DELETE_DEVICE, __uam_device_service_finalize_delete);
 
        initialized = 1;
        FUNC_EXIT;
        return rc;
 }
 
-static int __ua_device_service_prepare_select(sqlite3 *db)
+static int __uam_device_service_prepare_select(sqlite3 *db)
 {
        FUNC_ENTRY;
        int rc;
@@ -149,18 +149,18 @@ static int __ua_device_service_prepare_select(sqlite3 *db)
        }
 
        PREPARE_QUERY(rc, db, select_service,
-               SELECT_SERVICE, __ua_device_service_finalize_select);
+               SELECT_SERVICE, __uam_device_service_finalize_select);
        PREPARE_QUERY(rc, db, select_device_services_count,
-               SELECT_DEVICE_SERVICES_COUNT, __ua_device_service_finalize_select);
+               SELECT_DEVICE_SERVICES_COUNT, __uam_device_service_finalize_select);
        PREPARE_QUERY(rc, db, select_device_services,
-               SELECT_DEVICE_SERVICES, __ua_device_service_finalize_select);
+               SELECT_DEVICE_SERVICES, __uam_device_service_finalize_select);
 
        initialized = 1;
        FUNC_EXIT;
        return rc;
 }
 
-static int __ua_device_service_prepare_update(sqlite3 *db)
+static int __uam_device_service_prepare_update(sqlite3 *db)
 {
        FUNC_ENTRY;
        int rc;
@@ -172,14 +172,14 @@ static int __ua_device_service_prepare_update(sqlite3 *db)
        }
 
        PREPARE_QUERY(rc, db, update_device_service,
-               UPDATE_DEVICE_SERVICE, __ua_device_service_finalize_update);
+               UPDATE_DEVICE_SERVICE, __uam_device_service_finalize_update);
 
        initialized = 1;
        FUNC_EXIT;
        return rc;
 }
 
-static int __ua_device_service_prepare_insert(sqlite3 *db)
+static int __uam_device_service_prepare_insert(sqlite3 *db)
 {
        FUNC_ENTRY;
        int rc;
@@ -191,14 +191,14 @@ static int __ua_device_service_prepare_insert(sqlite3 *db)
        }
 
        PREPARE_QUERY(rc, db, insert_device_service,
-               INSERT_DEVICE_SERVICE, __ua_device_service_finalize_insert);
+               INSERT_DEVICE_SERVICE, __uam_device_service_finalize_insert);
 
        initialized = 1;
        FUNC_EXIT;
        return rc;
 }
 
-static int __ua_device_service_table_deviceservicesinfo_prepare(sqlite3 *db)
+static int __uam_device_service_table_deviceservicesinfo_prepare(sqlite3 *db)
 {
        FUNC_ENTRY;
 
@@ -209,51 +209,51 @@ static int __ua_device_service_table_deviceservicesinfo_prepare(sqlite3 *db)
                return UAM_ERROR_DB_FAILED;
        }
 
-       DB_ACTION(__ua_device_service_prepare_delete(db), error_code, handle_error);
-       DB_ACTION(__ua_device_service_prepare_select(db), error_code, handle_error);
-       DB_ACTION(__ua_device_service_prepare_update(db), error_code, handle_error);
-       DB_ACTION(__ua_device_service_prepare_insert(db), error_code, handle_error);
+       DB_ACTION(__uam_device_service_prepare_delete(db), error_code, handle_error);
+       DB_ACTION(__uam_device_service_prepare_select(db), error_code, handle_error);
+       DB_ACTION(__uam_device_service_prepare_update(db), error_code, handle_error);
+       DB_ACTION(__uam_device_service_prepare_insert(db), error_code, handle_error);
 
 handle_error:
        FUNC_EXIT;
        return error_code;
 }
 
-static void __ua_device_service_table_devicesinfo_finalize(void)
+static void __uam_device_service_table_devicesinfo_finalize(void)
 {
        FUNC_ENTRY;
-       __ua_device_service_finalize_delete();
-       __ua_device_service_finalize_select();
-       __ua_device_service_finalize_insert();
-       __ua_device_service_finalize_update();
+       __uam_device_service_finalize_delete();
+       __uam_device_service_finalize_select();
+       __uam_device_service_finalize_insert();
+       __uam_device_service_finalize_update();
        FUNC_EXIT;
 }
 
-int _ua_device_service_db_deinitialize(void)
+int _uam_device_service_db_deinitialize(void)
 {
        FUNC_ENTRY;
 
        retv_if(NULL == database, UAM_ERROR_NONE);
 
-       __ua_device_service_table_devicesinfo_finalize();
+       __uam_device_service_table_devicesinfo_finalize();
        sqlite3_close(database);
 
        FUNC_EXIT;
        return UAM_ERROR_NONE;
 }
 
-int _ua_device_service_db_initialize(void)
+int _uam_device_service_db_initialize(void)
 {
        FUNC_ENTRY;
 
-       EXEC(UAM_ERROR_NONE, __ua_device_service_table_deviceservicesinfo_prepare(database),
+       EXEC(UAM_ERROR_NONE, __uam_device_service_table_deviceservicesinfo_prepare(database),
                handle_error);
 
        FUNC_EXIT;
        return UAM_ERROR_NONE;
 
 handle_error:
-       _ua_device_service_db_deinitialize();
+       _uam_device_service_db_deinitialize();
        FUNC_EXIT;
        return UAM_ERROR_DB_FAILED;
 }
@@ -382,7 +382,7 @@ handle_error:
        return ret;
 }
 
-int _ua_device_service_db_clear(void)
+int _uam_device_service_db_clear(void)
 {
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = delete_all_device_services;
@@ -533,7 +533,7 @@ handle_error:
        return error_code;
 }
 
-int _uam_db_delete_device_info(const char *device_id, int tech_type,
+int _uam_db_delete_device_service_mapping(const char *device_id, int tech_type,
                const char *address)
 {
        FUNC_ENTRY;

diff --git a/ua-daemon/src/ua-manager-service-db.c b/ua-daemon/src/ua-manager-service-db.c
index 22373a0..ef37b3e 100644 (file)
--- a/ua-daemon/src/ua-manager-service-db.c
+++ b/ua-daemon/src/ua-manager-service-db.c
@@ -61,7 +61,7 @@ static sqlite3_stmt *insert_service_info;
 extern sqlite3 *database;
 static int max_service_number;
 
-static void __ua_service_finalize_delete(void)
+static void __uam_service_finalize_delete(void)
 {
        FUNC_ENTRY;
 
@@ -71,7 +71,7 @@ static void __ua_service_finalize_delete(void)
        FUNC_EXIT;
 }
 
-static void __ua_service_finalize_select(void)
+static void __uam_service_finalize_select(void)
 {
        FUNC_ENTRY;
 
@@ -82,7 +82,7 @@ static void __ua_service_finalize_select(void)
        FUNC_EXIT;
 }
 
-static void __ua_service_finalize_insert(void)
+static void __uam_service_finalize_insert(void)
 {
        FUNC_ENTRY;
 
@@ -91,7 +91,7 @@ static void __ua_service_finalize_insert(void)
        FUNC_EXIT;
 }
 
-static void __ua_service_finalize_update(void)
+static void __uam_service_finalize_update(void)
 {
        FUNC_ENTRY;
 
@@ -100,7 +100,7 @@ static void __ua_service_finalize_update(void)
        FUNC_EXIT;
 }
 
-static int __ua_service_prepare_delete(sqlite3 *db)
+static int __uam_service_prepare_delete(sqlite3 *db)
 {
        FUNC_ENTRY;
        int rc;
@@ -112,16 +112,16 @@ static int __ua_service_prepare_delete(sqlite3 *db)
        }
 
        PREPARE_QUERY(rc, db, delete_all_services,
-               DELETE_ALL_SERVICES, __ua_service_finalize_delete);
+               DELETE_ALL_SERVICES, __uam_service_finalize_delete);
        PREPARE_QUERY(rc, db, delete_service_info,
-               DELETE_SERVICE_INFO, __ua_service_finalize_delete);
+               DELETE_SERVICE_INFO, __uam_service_finalize_delete);
 
        initialized = 1;
        FUNC_EXIT;
        return rc;
 }
 
-static int __ua_service_prepare_select(sqlite3 *db)
+static int __uam_service_prepare_select(sqlite3 *db)
 {
        FUNC_ENTRY;
        int rc;
@@ -133,18 +133,18 @@ static int __ua_service_prepare_select(sqlite3 *db)
        }
 
        PREPARE_QUERY(rc, db, select_all_services,
-               SELECT_ALL_SERVICES, __ua_service_finalize_select);
+               SELECT_ALL_SERVICES, __uam_service_finalize_select);
        PREPARE_QUERY(rc, db, select_service,
-               SELECT_SERVICE, __ua_service_finalize_select);
+               SELECT_SERVICE, __uam_service_finalize_select);
        PREPARE_QUERY(rc, db, select_max_service_number,
-               SELECT_MAX_SERVICE_NUMBER, __ua_service_finalize_select);
+               SELECT_MAX_SERVICE_NUMBER, __uam_service_finalize_select);
 
        initialized = 1;
        FUNC_EXIT;
        return rc;
 }
 
-static int __ua_service_prepare_update(sqlite3 *db)
+static int __uam_service_prepare_update(sqlite3 *db)
 {
        FUNC_ENTRY;
        int rc;
@@ -156,14 +156,14 @@ static int __ua_service_prepare_update(sqlite3 *db)
        }
 
        PREPARE_QUERY(rc, db, update_cycle,
-               UPDATE_CYCLE, __ua_service_finalize_update);
+               UPDATE_CYCLE, __uam_service_finalize_update);
 
        initialized = 1;
        FUNC_EXIT;
        return rc;
 }
 
-static int __ua_service_prepare_insert(sqlite3 *db)
+static int __uam_service_prepare_insert(sqlite3 *db)
 {
        FUNC_ENTRY;
        int rc;
@@ -175,14 +175,14 @@ static int __ua_service_prepare_insert(sqlite3 *db)
        }
 
        PREPARE_QUERY(rc, db, insert_service_info,
-               INSERT_SERVICE, __ua_service_finalize_insert);
+               INSERT_SERVICE, __uam_service_finalize_insert);
 
        initialized = 1;
        FUNC_EXIT;
        return rc;
 }
 
-static int __ua_service_table_servicesinfo_prepare(sqlite3 *db)
+static int __uam_service_table_servicesinfo_prepare(sqlite3 *db)
 {
        FUNC_ENTRY;
 
@@ -193,10 +193,10 @@ static int __ua_service_table_servicesinfo_prepare(sqlite3 *db)
                return UAM_ERROR_DB_FAILED;
        }
 
-       DB_ACTION(__ua_service_prepare_delete(db), error_code, handle_error);
-       DB_ACTION(__ua_service_prepare_select(db), error_code, handle_error);
-       DB_ACTION(__ua_service_prepare_update(db), error_code, handle_error);
-       DB_ACTION(__ua_service_prepare_insert(db), error_code, handle_error);
+       DB_ACTION(__uam_service_prepare_delete(db), error_code, handle_error);
+       DB_ACTION(__uam_service_prepare_select(db), error_code, handle_error);
+       DB_ACTION(__uam_service_prepare_update(db), error_code, handle_error);
+       DB_ACTION(__uam_service_prepare_insert(db), error_code, handle_error);
 
 handle_error:
 
@@ -204,12 +204,12 @@ handle_error:
        return error_code;
 }
 
-static void __ua_service_table_servicesinfo_finalize(void)
+static void __uam_service_table_servicesinfo_finalize(void)
 {
        FUNC_ENTRY;
-       __ua_service_finalize_delete();
-       __ua_service_finalize_select();
-       __ua_service_finalize_insert();
+       __uam_service_finalize_delete();
+       __uam_service_finalize_select();
+       __uam_service_finalize_insert();
        FUNC_EXIT;
 }
 
@@ -242,24 +242,24 @@ int _uam_db_get_max_service_number(void)
        return error_code;
 }
 
-int _ua_service_db_deinitialize(void)
+int _uam_service_db_deinitialize(void)
 {
        FUNC_ENTRY;
 
        retv_if(NULL == database, UAM_ERROR_NONE);
 
-       __ua_service_table_servicesinfo_finalize();
+       __uam_service_table_servicesinfo_finalize();
        sqlite3_close(database);
 
        FUNC_EXIT;
        return UAM_ERROR_NONE;
 }
 
-int _ua_service_db_initialize(void)
+int _uam_service_db_initialize(void)
 {
        FUNC_ENTRY;
 
-       EXEC(UAM_ERROR_NONE, __ua_service_table_servicesinfo_prepare(database), handle_error);
+       EXEC(UAM_ERROR_NONE, __uam_service_table_servicesinfo_prepare(database), handle_error);
        if (_uam_db_get_max_service_number() != UAM_ERROR_NONE)
                goto handle_error;
 
@@ -267,7 +267,7 @@ int _ua_service_db_initialize(void)
        return UAM_ERROR_NONE;
 
 handle_error:
-       _ua_service_db_deinitialize();
+       _uam_service_db_deinitialize();
        FUNC_EXIT;
        return UAM_ERROR_DB_FAILED;
 }
@@ -342,7 +342,7 @@ handle_error:
        return error_code;
 }
 
-int _ua_service_db_clear(void)
+int _uam_service_db_clear(void)
 {
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = delete_all_services;
@@ -436,7 +436,7 @@ handle_error:
        return error_code;
 }
 
-GSList *_ua_service_db_get_all_services(void)
+GSList *_uam_service_db_get_all_services(void)
 {
        FUNC_ENTRY;
        int rc;

diff --git a/ua-daemon/src/ua-manager-user-db.c b/ua-daemon/src/ua-manager-user-db.c
index 5a30e85..5d50a90 100644 (file)
--- a/ua-daemon/src/ua-manager-user-db.c
+++ b/ua-daemon/src/ua-manager-user-db.c
@@ -57,7 +57,7 @@ static sqlite3_stmt *insert_user_info;
 extern sqlite3 *database;
 static int max_user_id;
 
-static void __ua_finalize_delete(void)
+static void __uam_finalize_delete(void)
 {
        FUNC_ENTRY;
 
@@ -67,7 +67,7 @@ static void __ua_finalize_delete(void)
        FUNC_EXIT;
 }
 
-static void __ua_finalize_select(void)
+static void __uam_finalize_select(void)
 {
        FUNC_ENTRY;
 
@@ -78,7 +78,7 @@ static void __ua_finalize_select(void)
        FUNC_EXIT;
 }
 
-static void __ua_finalize_insert(void)
+static void __uam_finalize_insert(void)
 {
        FUNC_ENTRY;
 
@@ -87,7 +87,7 @@ static void __ua_finalize_insert(void)
        FUNC_EXIT;
 }
 
-static int __ua_prepare_delete(sqlite3 *db)
+static int __uam_prepare_delete(sqlite3 *db)
 {
        FUNC_ENTRY;
        int rc;
@@ -99,16 +99,16 @@ static int __ua_prepare_delete(sqlite3 *db)
        }
 
        PREPARE_QUERY(rc, db, delete_all_users_data,
-               DELETE_ALL_USERS_DATA, __ua_finalize_delete);
+               DELETE_ALL_USERS_DATA, __uam_finalize_delete);
        PREPARE_QUERY(rc, db, delete_user_info,
-               DELETE_USER_INFO, __ua_finalize_delete);
+               DELETE_USER_INFO, __uam_finalize_delete);
 
        initialized = 1;
        FUNC_EXIT;
        return rc;
 }
 
-static int __ua_prepare_select(sqlite3 *db)
+static int __uam_prepare_select(sqlite3 *db)
 {
        FUNC_ENTRY;
        int rc;
@@ -120,18 +120,18 @@ static int __ua_prepare_select(sqlite3 *db)
        }
 
        PREPARE_QUERY(rc, db, select_all_users_data,
-               SELECT_ALL_USERS_DATA, __ua_finalize_select);
+               SELECT_ALL_USERS_DATA, __uam_finalize_select);
        PREPARE_QUERY(rc, db, select_user_data,
-               SELECT_USER_DATA, __ua_finalize_select);
+               SELECT_USER_DATA, __uam_finalize_select);
        PREPARE_QUERY(rc, db, select_max_user_id,
-               SELECT_MAX_USER_ID, __ua_finalize_select);
+               SELECT_MAX_USER_ID, __uam_finalize_select);
 
        initialized = 1;
        FUNC_EXIT;
        return rc;
 }
 
-static int __ua_prepare_update(sqlite3 *db)
+static int __uam_prepare_update(sqlite3 *db)
 {
        FUNC_ENTRY;
        //TODO
@@ -139,7 +139,7 @@ static int __ua_prepare_update(sqlite3 *db)
        return 0;
 }
 
-static int __ua_prepare_insert(sqlite3 *db)
+static int __uam_prepare_insert(sqlite3 *db)
 {
        FUNC_ENTRY;
        int rc;
@@ -151,14 +151,14 @@ static int __ua_prepare_insert(sqlite3 *db)
        }
 
        PREPARE_QUERY(rc, db, insert_user_info,
-               INSERT_USER_INFO, __ua_finalize_insert);
+               INSERT_USER_INFO, __uam_finalize_insert);
 
        initialized = 1;
        FUNC_EXIT;
        return rc;
 }
 
-static int __ua_table_usersinfo_prepare(sqlite3 *db)
+static int __uam_table_usersinfo_prepare(sqlite3 *db)
 {
        FUNC_ENTRY;
 
@@ -169,22 +169,22 @@ static int __ua_table_usersinfo_prepare(sqlite3 *db)
                return UAM_ERROR_DB_FAILED;
        }
 
-       DB_ACTION(__ua_prepare_delete(db), error_code, handle_error);
-       DB_ACTION(__ua_prepare_select(db), error_code, handle_error);
-       DB_ACTION(__ua_prepare_update(db), error_code, handle_error);
-       DB_ACTION(__ua_prepare_insert(db), error_code, handle_error);
+       DB_ACTION(__uam_prepare_delete(db), error_code, handle_error);
+       DB_ACTION(__uam_prepare_select(db), error_code, handle_error);
+       DB_ACTION(__uam_prepare_update(db), error_code, handle_error);
+       DB_ACTION(__uam_prepare_insert(db), error_code, handle_error);
 
 handle_error:
        FUNC_EXIT;
        return error_code;
 }
 
-static void __ua_table_usersinfo_finalize(void)
+static void __uam_table_usersinfo_finalize(void)
 {
        FUNC_ENTRY;
-       __ua_finalize_delete();
-       __ua_finalize_select();
-       __ua_finalize_insert();
+       __uam_finalize_delete();
+       __uam_finalize_select();
+       __uam_finalize_insert();
        FUNC_EXIT;
 }
 
@@ -221,7 +221,7 @@ int _uam_user_db_initialize(void)
 {
        FUNC_ENTRY;
 
-       EXEC(UAM_ERROR_NONE, __ua_table_usersinfo_prepare(database), handle_error);
+       EXEC(UAM_ERROR_NONE, __uam_table_usersinfo_prepare(database), handle_error);
 
        if (_uam_db_get_max_user_id() != UAM_ERROR_NONE)
                goto handle_error;
@@ -241,14 +241,14 @@ int _uam_user_db_deinitialize(void)
 
        retv_if(NULL == database, UAM_ERROR_NONE);
 
-       __ua_table_usersinfo_finalize();
+       __uam_table_usersinfo_finalize();
        sqlite3_close(database);
 
        FUNC_EXIT;
        return UAM_ERROR_NONE;
 }
 
-int _ua_db_insert_user_info(int *user_id, const char *name, const char *account)
+int _uam_db_insert_user_info(int *user_id, const char *name, const char *account)
 {
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NONE;
@@ -282,7 +282,7 @@ handle_error:
        return error_code;
 }
 
-int _ua_db_delete_by_user_id(int user_id)
+int _uam_db_delete_by_user_id(int user_id)
 {
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NONE;
@@ -307,7 +307,7 @@ handle_error:
        return error_code;
 }
 
-int _ua_db_get_user(int user_id, db_user_info_t *info)
+int _uam_db_get_user(int user_id, db_user_info_t *info)
 {
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NONE;
@@ -344,7 +344,7 @@ handle_error:
        return error_code;
 }
 
-GSList *_ua_db_get_all_users(void)
+GSList *_uam_db_get_all_users(void)
 {
        FUNC_ENTRY;
        int rc;