Refactoring to improve SAM-DC score

Change-Id: I9f3490dbb97d31a8f6f292152ec50b944014a322
Signed-off-by: hyunuk.tak <hyunuk.tak@samsung.com>

diff --git a/ua-api/src/ua-api.c b/ua-api/src/ua-api.c
index a8eca80..bc6c63c 100755 (executable)
--- a/ua-api/src/ua-api.c
+++ b/ua-api/src/ua-api.c
@@ -152,17 +152,16 @@ UAM_EXPORT_API int _uam_is_device_registered(uam_device_info_s *dev_info,
        return ret;
 }
 
-UAM_EXPORT_API int _uam_get_default_user(uam_user_info_s *user)
+static int __uam_sync_request(
+               int req_func,
+               uam_user_info_s *user,
+               GArray *in_param1,
+               GArray *in_param2,
+               GArray *in_param3,
+               GArray *in_param4,
+               GArray *out_param)
 {
-       FUNC_ENTRY;
-       int ret;
-
-       UAM_VALIDATE_INPUT_PARAMETER(user);
-
-       UAM_INIT_PARAMS();
-       UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
-
-       ret = _uam_sync_request(UAM_REQUEST_GET_DEFAULT_USER,
+       int ret = _uam_sync_request(req_func,
                        in_param1, in_param2, in_param3, in_param4, &out_param);
 
        if (UAM_ERROR_NONE == ret) {
@@ -182,6 +181,19 @@ UAM_EXPORT_API int _uam_get_default_user(uam_user_info_s *user)
        return ret;
 }
 
+UAM_EXPORT_API int _uam_get_default_user(uam_user_info_s *user)
+{
+       FUNC_ENTRY;
+
+       UAM_VALIDATE_INPUT_PARAMETER(user);
+
+       UAM_INIT_PARAMS();
+       UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+       return __uam_sync_request(UAM_REQUEST_GET_DEFAULT_USER, user,
+                       in_param1, in_param2, in_param3, in_param4, out_param);
+}
+
 UAM_EXPORT_API int _uam_add_user(uam_user_info_s *user)
 {
        FUNC_ENTRY;
@@ -256,7 +268,6 @@ UAM_EXPORT_API int _uam_request_get_user_by_account(char *account,
        uam_user_info_s *user)
 {
        FUNC_ENTRY;
-       int ret;
        char str[UAM_USER_ACCOUNT_MAX_STRING_LEN];
 
        UAM_VALIDATE_INPUT_PARAMETER(account);
@@ -267,31 +278,15 @@ UAM_EXPORT_API int _uam_request_get_user_by_account(char *account,
 
        g_strlcpy(str, account, UAM_USER_ACCOUNT_MAX_STRING_LEN);
        g_array_append_vals(in_param1, str, sizeof(str));
-       ret = _uam_sync_request(UAM_REQUEST_GET_USER_BY_ACCOUNT,
-                       in_param1, in_param2, in_param3, in_param4, &out_param);
-
-       if (UAM_ERROR_NONE == ret) {
-               if (out_param->len > 0) {
-                       uam_user_info_s *info;
-
-                       info = &g_array_index(out_param, uam_user_info_s, 0);
-                       memcpy(user, info, sizeof(uam_user_info_s));
-               } else {
-                       UAM_WARN("out_param length is 0");
-               }
-       }
-
-       UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 
-       FUNC_EXIT;
-       return ret;
+       return __uam_sync_request(UAM_REQUEST_GET_USER_BY_ACCOUNT, user,
+                       in_param1, in_param2, in_param3, in_param4, out_param);
 }
 
 UAM_EXPORT_API int _uam_request_get_user_by_deviceid(char *device_id,
        uam_user_info_s *user)
 {
        FUNC_ENTRY;
-       int ret;
        char str[UAM_DEVICE_ID_MAX_STRING_LEN];
 
        UAM_VALIDATE_INPUT_PARAMETER(device_id);
@@ -302,31 +297,15 @@ UAM_EXPORT_API int _uam_request_get_user_by_deviceid(char *device_id,
 
        g_strlcpy(str, device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
        g_array_append_vals(in_param1, str, sizeof(str));
-       ret = _uam_sync_request(UAM_REQUEST_GET_USER_BY_DEVICE_ID,
-                       in_param1, in_param2, in_param3, in_param4, &out_param);
-
-       if (UAM_ERROR_NONE == ret) {
-               if (out_param->len > 0) {
-                       uam_user_info_s * info;
-
-                       info = &g_array_index(out_param, uam_user_info_s, 0);
-                       memcpy(user, info, sizeof(uam_user_info_s));
-               } else {
-                       UAM_WARN("out_param length is 0");
-               }
-       }
-
-       UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 
-       FUNC_EXIT;
-       return ret;
+       return __uam_sync_request(UAM_REQUEST_GET_USER_BY_DEVICE_ID, user,
+                       in_param1, in_param2, in_param3, in_param4, out_param);
 }
 
 UAM_EXPORT_API int _uam_request_get_user_by_mac(char *mac,
        uam_user_info_s *user)
 {
        FUNC_ENTRY;
-       int ret;
        char str[UAM_MAC_ADDRESS_STRING_LEN];
 
        UAM_VALIDATE_INPUT_PARAMETER(mac);
@@ -337,24 +316,9 @@ UAM_EXPORT_API int _uam_request_get_user_by_mac(char *mac,
 
        g_strlcpy(str, mac, UAM_MAC_ADDRESS_STRING_LEN);
        g_array_append_vals(in_param1, str, sizeof(str));
-       ret = _uam_sync_request(UAM_REQUEST_GET_USER_BY_MAC,
-                       in_param1, in_param2, in_param3, in_param4, &out_param);
-
-       if (UAM_ERROR_NONE == ret) {
-               if (out_param->len > 0) {
-                       uam_user_info_s * info;
-
-                       info = &g_array_index(out_param, uam_user_info_s, 0);
-                       memcpy(user, info, sizeof(uam_user_info_s));
-               } else {
-                       UAM_WARN("out_param length is 0");
-               }
-       }
-
-       UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 
-       FUNC_EXIT;
-       return ret;
+       return __uam_sync_request(UAM_REQUEST_GET_USER_BY_MAC, user,
+                       in_param1, in_param2, in_param3, in_param4, out_param);
 }
 
 UAM_EXPORT_API int _uam_request_add_device(char *account,
@@ -524,23 +488,24 @@ UAM_EXPORT_API int _uam_request_get_device_by_mac(const char *mac,
        return ret;
 }
 
-UAM_EXPORT_API int _uam_request_get_devices(GPtrArray **devices_list)
+static int _uam_sync_request_get(
+               GPtrArray **devices_list,
+               int req_func,
+               GArray *in_param1,
+               GArray *in_param2,
+               GArray *in_param3,
+               GArray *in_param4,
+               GArray **out_param
+               )
 {
        FUNC_ENTRY;
-       int ret;
-
-       UAM_VALIDATE_INPUT_PARAMETER(devices_list);
-
-       UAM_INIT_PARAMS();
-       UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
-
-       ret = _uam_sync_request(UAM_REQUEST_GET_DEVICES,
-                       in_param1, in_param2, in_param3, in_param4, &out_param);
+       int ret = _uam_sync_request(req_func,
+                       in_param1, in_param2, in_param3, in_param4, out_param);
        if (UAM_ERROR_NONE == ret && NULL != out_param) {
                int i;
                int count;
 
-               count = (out_param->len)/sizeof(uam_device_info_s);
+               count = ((*out_param)->len)/sizeof(uam_device_info_s);
                if (0 == count)
                        UAM_INFO("No registered device");
 
@@ -548,24 +513,36 @@ UAM_EXPORT_API int _uam_request_get_devices(GPtrArray **devices_list)
                        uam_device_info_s *device_info = NULL;
                        uam_device_info_s *info;
 
-                       info = &g_array_index(out_param, uam_device_info_s, i);
+                       info = &g_array_index(*out_param, uam_device_info_s, i);
                        device_info = g_memdup2(info, sizeof(uam_device_info_s));
                        if (device_info)
                                g_ptr_array_add(*devices_list, (gpointer)device_info);
                }
        }
 
-       UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+       UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, *out_param);
 
        FUNC_EXIT;
        return ret;
 }
 
+UAM_EXPORT_API int _uam_request_get_devices(GPtrArray **devices_list)
+{
+       FUNC_ENTRY;
+
+       UAM_VALIDATE_INPUT_PARAMETER(devices_list);
+
+       UAM_INIT_PARAMS();
+       UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+       return _uam_sync_request_get(devices_list, UAM_REQUEST_GET_DEVICES,
+                       in_param1, in_param2, in_param3, in_param4, &out_param);
+}
+
 UAM_EXPORT_API int _uam_request_get_user_devices(char *account,
        GPtrArray **devices_list)
 {
        FUNC_ENTRY;
-       int ret;
        char str[UAM_USER_ACCOUNT_MAX_STRING_LEN];
 
        UAM_VALIDATE_INPUT_PARAMETER(devices_list);
@@ -577,31 +554,8 @@ UAM_EXPORT_API int _uam_request_get_user_devices(char *account,
        g_strlcpy(str, account, UAM_USER_ACCOUNT_MAX_STRING_LEN);
        g_array_append_vals(in_param1, str, sizeof(str));
 
-       ret = _uam_sync_request(UAM_REQUEST_GET_USER_DEVICES,
+       return _uam_sync_request_get(devices_list, UAM_REQUEST_GET_USER_DEVICES,
                        in_param1, in_param2, in_param3, in_param4, &out_param);
-       if (UAM_ERROR_NONE == ret && NULL != out_param) {
-               int i;
-               int count;
-
-               count = (out_param->len)/sizeof(uam_device_info_s);
-               if (0 == count)
-                       UAM_INFO("No registered device");
-
-               for (i = 0; i < count; i++) {
-                       uam_device_info_s *device_info = NULL;
-                       uam_device_info_s *info;
-
-                       info = &g_array_index(out_param, uam_device_info_s, i);
-                       device_info = g_memdup2(info, sizeof(uam_device_info_s));
-                       if (device_info)
-                               g_ptr_array_add(*devices_list, (gpointer)device_info);
-               }
-       }
-
-       UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
-
-       FUNC_EXIT;
-       return ret;
 }
 
 UAM_EXPORT_API int _uam_request_set_detection_threshold(
@@ -999,8 +953,8 @@ UAM_EXPORT_API int _uam_service_remove_user(const char *service,
        return ret;
 }
 
-UAM_EXPORT_API int _uam_service_add_device(const char *service, char *device_id,
-       uam_tech_type_e tech_type)
+static int __uam_service_sync_request(int req_func, const char *service,
+               const char *device_id, uam_tech_type_e tech_type, void *user_data)
 {
        FUNC_ENTRY;
        int ret;
@@ -1019,9 +973,24 @@ UAM_EXPORT_API int _uam_service_add_device(const char *service, char *device_id,
        g_strlcpy(str, device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
        g_array_append_vals(in_param2, str, sizeof(str));
        g_array_append_vals(in_param3, &tech_type, sizeof(int));
+       if (req_func == UAM_REQUEST_SET_DEVICE_SERVICES_DISCRIMINANT) {
+               gboolean *discriminant = (gboolean *)user_data;
+               g_array_append_vals(in_param4, discriminant, sizeof(gboolean));
+       }
 
-       ret = _uam_sync_request(UAM_REQUEST_ADD_DEVICE_TO_SERVICE,
-                       in_param1, in_param2, in_param3, in_param4, &out_param);
+       ret = _uam_sync_request(req_func, in_param1, in_param2, in_param3, in_param4, &out_param);
+       if (req_func == UAM_REQUEST_GET_DEVICE_SERVICES_DISCRIMINANT && UAM_ERROR_NONE == ret) {
+               gboolean *discriminant = (gboolean *)user_data;
+               *discriminant = g_array_index(out_param, gboolean, 0);
+               UAM_INFO("Discriminant: %d for %s-%d-%s", *discriminant, device_id,
+               tech_type, service);
+       }
+       if (req_func == UAM_REQUEST_GET_DEVICE_SERVICES_LAST_SEEN && UAM_ERROR_NONE == ret) {
+               unsigned long long *last_seen = (unsigned long long *)user_data;
+               *last_seen = g_array_index(out_param, unsigned long long, 0);
+               UAM_INFO("Last seen: %llu for %s-%d-%s", *last_seen, device_id,
+               tech_type, service);
+       }
 
        UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 
@@ -1029,133 +998,39 @@ UAM_EXPORT_API int _uam_service_add_device(const char *service, char *device_id,
        return ret;
 }
 
+UAM_EXPORT_API int _uam_service_add_device(const char *service, char *device_id,
+       uam_tech_type_e tech_type)
+{
+       return __uam_service_sync_request(UAM_REQUEST_ADD_DEVICE_TO_SERVICE,
+                       service, device_id, tech_type, NULL);
+}
+
 UAM_EXPORT_API int _uam_service_remove_device(const char *service,
        char *device_id, uam_tech_type_e tech_type)
 {
-       FUNC_ENTRY;
-       int ret;
-       char svc_str[UAM_SERVICE_MAX_STRING_LEN];
-       char str[UAM_DEVICE_ID_MAX_STRING_LEN];
-
-       UAM_VALIDATE_INPUT_PARAMETER(service);
-       UAM_VALIDATE_INPUT_PARAMETER(device_id);
-
-       UAM_INIT_PARAMS();
-       UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
-
-       g_strlcpy(svc_str, service, UAM_SERVICE_MAX_STRING_LEN);
-       g_array_append_vals(in_param1, svc_str, sizeof(svc_str));
-
-       g_strlcpy(str, device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
-       g_array_append_vals(in_param2, str, sizeof(str));
-       g_array_append_vals(in_param3, &tech_type, sizeof(int));
-
-       ret = _uam_sync_request(UAM_REQUEST_REMOVE_DEVICE_FROM_SERVICE,
-                       in_param1, in_param2, in_param3, in_param4, &out_param);
-
-       UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
-
-       FUNC_EXIT;
-       return ret;
+       return __uam_service_sync_request(UAM_REQUEST_REMOVE_DEVICE_FROM_SERVICE,
+                       service, device_id, tech_type, NULL);
 }
 
 UAM_EXPORT_API int _uam_service_set_device_discriminant(const char *service,
        const char *device_id, uam_tech_type_e tech_type, gboolean discriminant)
 {
-       FUNC_ENTRY;
-       int ret;
-       char svc_str[UAM_SERVICE_MAX_STRING_LEN];
-       char str[UAM_DEVICE_ID_MAX_STRING_LEN];
-
-       UAM_VALIDATE_INPUT_PARAMETER(service);
-       UAM_VALIDATE_INPUT_PARAMETER(device_id);
-
-       UAM_INIT_PARAMS();
-       UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
-
-       g_strlcpy(svc_str, service, UAM_SERVICE_MAX_STRING_LEN);
-       g_array_append_vals(in_param1, svc_str, sizeof(svc_str));
-
-       g_strlcpy(str, device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
-       g_array_append_vals(in_param2, str, sizeof(str));
-       g_array_append_vals(in_param3, &tech_type, sizeof(int));
-       g_array_append_vals(in_param4, &discriminant, sizeof(gboolean));
-
-       ret = _uam_sync_request(UAM_REQUEST_SET_DEVICE_SERVICES_DISCRIMINANT,
-                       in_param1, in_param2, in_param3, in_param4, &out_param);
-
-       UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
-
-       FUNC_EXIT;
-       return ret;
+       return __uam_service_sync_request(UAM_REQUEST_SET_DEVICE_SERVICES_DISCRIMINANT,
+                       service, device_id, tech_type, &discriminant);
 }
 
 UAM_EXPORT_API int _uam_service_get_device_discriminant(const char *service,
        const char *device_id, uam_tech_type_e tech_type, gboolean *discriminant)
 {
-       FUNC_ENTRY;
-       int ret;
-       char svc_str[UAM_SERVICE_MAX_STRING_LEN];
-       char str[UAM_DEVICE_ID_MAX_STRING_LEN];
-
-       UAM_VALIDATE_INPUT_PARAMETER(service);
-       UAM_VALIDATE_INPUT_PARAMETER(device_id);
-
-       UAM_INIT_PARAMS();
-       UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
-
-       g_strlcpy(svc_str, service, UAM_SERVICE_MAX_STRING_LEN);
-       g_array_append_vals(in_param1, svc_str, sizeof(svc_str));
-
-       g_strlcpy(str, device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
-       g_array_append_vals(in_param2, str, sizeof(str));
-       g_array_append_vals(in_param3, &tech_type, sizeof(int));
-
-       ret = _uam_sync_request(UAM_REQUEST_GET_DEVICE_SERVICES_DISCRIMINANT,
-                       in_param1, in_param2, in_param3, in_param4, &out_param);
-       if (UAM_ERROR_NONE == ret) {
-               *discriminant = g_array_index(out_param, gboolean, 0);
-               UAM_INFO("Discriminant: %d for %s-%d-%s", *discriminant, device_id,
-               tech_type, service);
-       }
-       UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
-
-       FUNC_EXIT;
-       return ret;
+       return __uam_service_sync_request(UAM_REQUEST_GET_DEVICE_SERVICES_DISCRIMINANT,
+                       service, device_id, tech_type, discriminant);
 }
 
 UAM_EXPORT_API int _uam_service_get_device_last_seen(const char *service,
        const char *device_id, uam_tech_type_e tech_type, unsigned long long *last_seen)
 {
-       FUNC_ENTRY;
-       int ret;
-       char svc_str[UAM_SERVICE_MAX_STRING_LEN];
-       char str[UAM_DEVICE_ID_MAX_STRING_LEN];
-
-       UAM_VALIDATE_INPUT_PARAMETER(service);
-       UAM_VALIDATE_INPUT_PARAMETER(device_id);
-
-       UAM_INIT_PARAMS();
-       UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
-
-       g_strlcpy(svc_str, service, UAM_SERVICE_MAX_STRING_LEN);
-       g_array_append_vals(in_param1, svc_str, sizeof(svc_str));
-
-       g_strlcpy(str, device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
-       g_array_append_vals(in_param2, str, sizeof(str));
-       g_array_append_vals(in_param3, &tech_type, sizeof(int));
-
-       ret = _uam_sync_request(UAM_REQUEST_GET_DEVICE_SERVICES_LAST_SEEN,
-                       in_param1, in_param2, in_param3, in_param4, &out_param);
-       if (UAM_ERROR_NONE == ret) {
-               *last_seen = g_array_index(out_param, unsigned long long, 0);
-               UAM_INFO("Last seen: %llu for %s-%d-%s", *last_seen, device_id,
-               tech_type, service);
-       }
-       UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
-
-       FUNC_EXIT;
-       return ret;
+       return __uam_service_sync_request(UAM_REQUEST_GET_DEVICE_SERVICES_LAST_SEEN,
+                       service, device_id, tech_type, last_seen);
 }
 
 
@@ -1366,7 +1241,6 @@ UAM_EXPORT_API int _uam_request_get_service_devices(char *svc_name,
        GPtrArray **devices_list)
 {
        FUNC_ENTRY;
-       int ret;
        char str[UAM_SERVICE_MAX_STRING_LEN];
 
        UAM_VALIDATE_INPUT_PARAMETER(devices_list);
@@ -1378,31 +1252,8 @@ UAM_EXPORT_API int _uam_request_get_service_devices(char *svc_name,
        g_strlcpy(str, svc_name, UAM_SERVICE_MAX_STRING_LEN);
        g_array_append_vals(in_param1, str, sizeof(str));
 
-       ret = _uam_sync_request(UAM_REQUEST_GET_SERVICE_DEVICES,
+       return _uam_sync_request_get(devices_list, UAM_REQUEST_GET_SERVICE_DEVICES,
                        in_param1, in_param2, in_param3, in_param4, &out_param);
-       if (UAM_ERROR_NONE == ret && NULL != out_param) {
-               int i;
-               int count;
-
-               count = (out_param->len)/sizeof(uam_device_info_s);
-               if (0 == count)
-                       UAM_INFO("No registered device");
-
-               for (i = 0; i < count; i++) {
-                       uam_device_info_s *device_info = NULL;
-                       uam_device_info_s *info;
-
-                       info = &g_array_index(out_param, uam_device_info_s, i);
-                       device_info = g_memdup2(info, sizeof(uam_device_info_s));
-                       if (device_info)
-                               g_ptr_array_add(*devices_list, (gpointer)device_info);
-               }
-       }
-
-       UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
-
-       FUNC_EXIT;
-       return ret;
 }
 
 UAM_EXPORT_API int _uam_request_get_service_users(char *svc_name,

diff --git a/ua-daemon/src/pm/ua-plugin-manager.c b/ua-daemon/src/pm/ua-plugin-manager.c
index 309eb6d..d65f595 100644 (file)
--- a/ua-daemon/src/pm/ua-plugin-manager.c
+++ b/ua-daemon/src/pm/ua-plugin-manager.c
@@ -414,18 +414,12 @@ gboolean _uam_pm_is_sensor_ready(unsigned int sensor_bitmask)
        return (UAS_STATE_READY == state ? TRUE : FALSE);
 }
 
-int _uam_pm_register_device(int user_id, const uam_device_info_s *dev)
+static int __uam_pm_set_dev_info(int user_id, const uam_device_info_s *dev,
+               uam_sensor_plugin_info_t *plugin, uas_device_info_t *device)
 {
-       FUNC_ENTRY;
-
-       int id;
-       int ret = UAM_ERROR_NONE;
-       uam_sensor_plugin_info_t *plugin;
-       uas_device_info_t *device = NULL;
-
        retv_if(NULL == dev, UAM_ERROR_INVALID_PARAMETER);
 
-       id = _pm_util_uam_tech_type_to_plugin_id(dev->type);
+       int id = _pm_util_uam_tech_type_to_plugin_id(dev->type);
        UAM_DBG("Plugin id: %d", id);
        retv_if(UAS_PLUGIN_ID_MAX <= id, UAM_ERROR_INVALID_PARAMETER);
 
@@ -442,8 +436,22 @@ int _uam_pm_register_device(int user_id, const uam_device_info_s *dev)
 
        device->user_id = user_id;
 
-       ret = plugin->api->add_device(device);
+       return UAM_ERROR_NONE;
+}
+
+int _uam_pm_register_device(int user_id, const uam_device_info_s *dev)
+{
+       FUNC_ENTRY;
+
+       int ret = UAM_ERROR_NONE;
+       uam_sensor_plugin_info_t *plugin = NULL;
+       uas_device_info_t *device = NULL;
+
+       ret = __uam_pm_set_dev_info(user_id, dev, plugin, device);
+       retv_if(ret != UAM_ERROR_NONE, ret);
+       retv_if(!plugin || !plugin->api, UAM_ERROR_NOT_SUPPORTED);
 
+       ret = plugin->api->add_device(device);
        if (UAS_STATUS_SUCCESS != ret)
                UAM_ERR("plugin->add_device() failed");
 
@@ -456,31 +464,18 @@ int _uam_pm_register_device(int user_id, const uam_device_info_s *dev)
 int _uam_pm_unregister_device(int user_id, const uam_device_info_s *dev)
 {
        FUNC_ENTRY;
-       int id;
-       uam_sensor_plugin_info_t *plugin;
+
+       int ret = UAM_ERROR_NONE;
+       uam_sensor_plugin_info_t *plugin = NULL;
        uas_device_info_t *device = NULL;
-       int ret;
 
        retv_if(NULL == dev, UAM_ERROR_INVALID_PARAMETER);
 
-       id = _pm_util_uam_tech_type_to_plugin_id(dev->type);
-       UAM_DBG("Plugin id: %d", id);
-       retv_if(UAS_PLUGIN_ID_MAX <= id, UAM_ERROR_INVALID_PARAMETER);
-
-       plugin = plugins[id];
+       ret = __uam_pm_set_dev_info(user_id, dev, plugin, device);
+       retv_if(ret != UAM_ERROR_NONE, ret);
        retv_if(!plugin || !plugin->api, UAM_ERROR_NOT_SUPPORTED);
-       retv_if(UAS_SUPPORT_USER != plugin->capability, UAM_ERROR_NOT_SUPPORTED);
-
-       if (plugin->module)
-               UAM_DBG("Register device MAC: [%s] for user-id[%d] on [%s]",
-                       dev->mac, user_id, plugin->module->name);
-
-       device = _pm_util_uam_dev_info_to_uas_dev_info(dev);
-       retv_if(NULL == device, UAM_ERROR_INTERNAL);
-       device->user_id = user_id;
 
        ret = plugin->api->remove_device(device);
-
        if (UAS_STATUS_SUCCESS != ret && UAS_STATUS_ALREADY_DONE != ret)
                UAM_ERR("plugin->remove_device() failed");
 

diff --git a/ua-daemon/src/ua-manager-core.c b/ua-daemon/src/ua-manager-core.c
index 58b585c..572b98b 100755 (executable)
--- a/ua-daemon/src/ua-manager-core.c
+++ b/ua-daemon/src/ua-manager-core.c
@@ -3920,6 +3920,47 @@ static int __uam_core_update_device_addr(uam_db_address_info_t *addr,
        return ret;
 }
 
+static int __uam_core_search_user(int user_id, uam_db_user_info_t *user)
+{
+       GSList *l = g_slist_find_custom(users, &user_id, __compare_user_id);
+       if (NULL == l) {
+               UAM_ERR("Invalid user_id [%d]", user_id);
+               return UAM_ERROR_INVALID_PARAMETER;
+       }
+
+       user = l->data;
+       return UAM_ERROR_NONE;
+}
+
+static int __uam_core_search_device(uam_device_info_s *dev_info,
+               int user_id, uam_db_user_info_t *user, uam_db_device_info_t *device)
+{
+       GSList *l = g_slist_find_custom(user->devices,
+                       dev_info->device_id, __compare_device_id);
+       if (NULL == l) {
+               UAM_ERR("Valid user_id [%d] but Invalid device_id [%s]",
+                               user_id, dev_info->device_id);
+               return UAM_ERROR_INVALID_PARAMETER;
+       }
+
+       device = l->data;
+       return UAM_ERROR_NONE;
+}
+
+static int __uam_core_search_tech(uam_device_info_s *dev_info,
+               uam_db_device_info_t *device, uam_db_tech_info_t *tech)
+{
+       GSList *l = g_slist_find_custom(device->tech_list,
+                       &(dev_info->type), __compare_tech_type);
+       if (NULL == l) {
+               UAM_ERR("Strange, tech type [%d] not found", dev_info->type);
+               return UAM_ERROR_INVALID_PARAMETER;
+       }
+
+       tech = l->data;
+       return UAM_ERROR_NONE;
+}
+
 int _uam_core_handle_presence_detected(unsigned int sensor,
                int user_id, void *info, uam_ble_payload_s *payload)
 {
@@ -3927,9 +3968,9 @@ int _uam_core_handle_presence_detected(unsigned int sensor,
        int ret = UAM_ERROR_NONE;
 
        GSList *l;
-       uam_db_user_info_t *user;
-       uam_db_device_info_t *device;
-       uam_db_tech_info_t *tech;
+       uam_db_user_info_t *user = NULL;
+       uam_db_device_info_t *device = NULL;
+       uam_db_tech_info_t *tech = NULL;
 
        uam_device_info_s *dev_info = NULL;
        uam_sensor_info_s *sensor_info = NULL;
@@ -3958,36 +3999,16 @@ int _uam_core_handle_presence_detected(unsigned int sensor,
        /* fetch the app_num info for the corresponding user_id */
        _uam_core_get_app_num_from_userid(user_id, &dev_info->app_num);
 
-       l = g_slist_find_custom(users, &user_id, __compare_user_id);
-       if (NULL == l) {
-               UAM_ERR("Invalid user_id [%d]", user_id);
-               return UAM_ERROR_INVALID_PARAMETER;
-       }
-       user = l->data;
-
-       l = g_slist_find_custom(user->devices,
-                       dev_info->device_id, __compare_device_id);
-       if (NULL == l) {
-               UAM_ERR("Valid user_id [%d] but Invalid device_id [%s]",
-                               user_id, dev_info->device_id);
-               return UAM_ERROR_INVALID_PARAMETER;
-       }
-       device = l->data;
+       retv_if(UAM_ERROR_NONE != __uam_core_search_user(user_id, user), UAM_ERROR_INVALID_PARAMETER);
 
+       retv_if(UAM_ERROR_NONE != __uam_core_search_device(dev_info, user_id, user, device), UAM_ERROR_INVALID_PARAMETER);
        if (!(device->supported_techs & dev_info->type)) {
                UAM_ERR("Valid device_id [%s] but Invalid tech type [%d]",
                                dev_info->device_id, dev_info->type);
                return UAM_ERROR_INVALID_PARAMETER;
        }
 
-       l = g_slist_find_custom(device->tech_list,
-                       &(dev_info->type), __compare_tech_type);
-       if (NULL == l) {
-               UAM_ERR("Strange, tech type [%d] not found", dev_info->type);
-               return UAM_ERROR_INVALID_PARAMETER;
-       }
-       tech = l->data;
-
+       retv_if(UAM_ERROR_NONE != __uam_core_search_tech(dev_info, device, tech), UAM_ERROR_INVALID_PARAMETER);
        tech->presence_state = UAM_PRESENCE_STATE_PRESENT;
        tech->last_seen = dev_info->last_seen;
 
@@ -4129,10 +4150,9 @@ int _uam_core_handle_location_detected(unsigned int sensor,
        FUNC_ENTRY;
        int ret = UAM_ERROR_NONE;
 
-       GSList *l;
-       uam_db_user_info_t *user;
-       uam_db_device_info_t *device;
-       uam_db_tech_info_t *tech;
+       uam_db_user_info_t *user = NULL;
+       uam_db_device_info_t *device = NULL;
+       uam_db_tech_info_t *tech = NULL;
        uam_device_info_s *dev_info = NULL;
 
        UAM_INFO("sensor: 0x%8.8X, user_id: %d", sensor, user_id);
@@ -4153,36 +4173,18 @@ int _uam_core_handle_location_detected(unsigned int sensor,
        _uam_core_get_app_num_from_userid(user_id, &dev_info->app_num);
 
        /* Search user */
-       l = g_slist_find_custom(users, &user_id, __compare_user_id);
-       if (NULL == l) {
-               UAM_ERR("Invalid user_id [%d]", user_id);
-               return UAM_ERROR_INVALID_PARAMETER;
-       }
-       user = l->data;
+       retv_if(UAM_ERROR_NONE != __uam_core_search_user(user_id, user), UAM_ERROR_INVALID_PARAMETER);
 
        /* Search device */
-       l = g_slist_find_custom(user->devices,
-                       dev_info->device_id, __compare_device_id);
-       if (NULL == l) {
-               UAM_ERR("Valid user_id [%d] but Invalid device_id [%s]",
-                               user_id, dev_info->device_id);
-               return UAM_ERROR_INVALID_PARAMETER;
-       }
-       device = l->data;
-
+       retv_if(UAM_ERROR_NONE != __uam_core_search_device(dev_info, user_id, user, device), UAM_ERROR_INVALID_PARAMETER);
        if (!(device->supported_techs & dev_info->type)) {
                UAM_ERR("Valid device_id [%s] but Invalid tech type [%d]",
                                dev_info->device_id, dev_info->type);
                return UAM_ERROR_INVALID_PARAMETER;
        }
 
-       l = g_slist_find_custom(device->tech_list,
-                       &(dev_info->type), __compare_tech_type);
-       if (NULL == l) {
-               UAM_ERR("Strange, tech type [%d] not found", dev_info->type);
-               return UAM_ERROR_INVALID_PARAMETER;
-       }
-       tech = l->data;
+       /* Search tech */
+       retv_if(UAM_ERROR_NONE != __uam_core_search_tech(dev_info, device, tech), UAM_ERROR_INVALID_PARAMETER);
 
        /* Send user location event */
        __send_user_location_event(tech, sensor, dev_info);

diff --git a/ua-daemon/src/ua-manager-payload-db.c b/ua-daemon/src/ua-manager-payload-db.c
index 3d53fa1..d6defc6 100644 (file)
--- a/ua-daemon/src/ua-manager-payload-db.c
+++ b/ua-daemon/src/ua-manager-payload-db.c
@@ -310,12 +310,11 @@ handle_error:
        return error_code;
 }
 
-int _uam_db_get_payload_device_number(uam_ble_payload_s *payload,
-               int *device_number, const int app_num)
+static int __uam_db_get_payload_number(uam_ble_payload_s *payload, int *number,
+               const int app_num, sqlite3_stmt *stmt, const char *number_info)
 {
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NONE;
-       sqlite3_stmt *stmt = select_payload_device;
        int sql_ret = SQLITE_OK;
 
        retv_if(NULL == payload, UAM_ERROR_INVALID_PARAMETER);
@@ -337,14 +336,14 @@ int _uam_db_get_payload_device_number(uam_ble_payload_s *payload,
                case SQLITE_DONE:
                        break;
                case SQLITE_ROW:
-                       UAM_DBG("Device number info found");
-                       *device_number = sqlite3_column_int(stmt, 0);
-                       UAM_INFO("device_number %d", *device_number);
+                       UAM_DBG("%s number info found", number_info);
+                       *number = sqlite3_column_int(stmt, 0);
+                       UAM_INFO("%s_number %d", number_info, *number);
                        break;
                case SQLITE_ERROR:
                default:
-                       UAM_ERR("Failed to select payload device number [%d:%s]",
-                               sql_ret, sqlite3_errmsg(database_handle));
+                       UAM_ERR("Failed to select payload %s number [%d:%s]",
+                               number_info, sql_ret, sqlite3_errmsg(database_handle));
                }
        } while (sql_ret == SQLITE_ROW);
 
@@ -354,48 +353,16 @@ handle_error:
        return error_code;
 }
 
+int _uam_db_get_payload_device_number(uam_ble_payload_s *payload,
+               int *device_number, const int app_num)
+{
+       return __uam_db_get_payload_number(payload, device_number, app_num, select_payload_device, "device");
+}
+
 int _uam_db_get_payload_number(uam_ble_payload_s *payload,
                int *payload_number, const int app_num)
 {
-       FUNC_ENTRY;
-       int error_code = UAM_ERROR_NONE;
-       sqlite3_stmt *stmt = select_payload_number;
-       int sql_ret = SQLITE_OK;
-
-       retv_if(NULL == payload, UAM_ERROR_INVALID_PARAMETER);
-       retv_if(0 > app_num, UAM_ERROR_INVALID_PARAMETER);
-
-       DB_ACTION(sqlite3_bind_text(stmt, 1, &(payload->primary_key), 1, SQLITE_TRANSIENT),
-               error_code, handle_error);
-       DB_ACTION(sqlite3_bind_text(stmt, 2, &(payload->secondary_key), 1, SQLITE_TRANSIENT),
-               error_code, handle_error);
-       DB_ACTION(sqlite3_bind_text(stmt, 3, payload->device_uid, payload->device_uid_len, SQLITE_TRANSIENT),
-               error_code, handle_error);
-       DB_ACTION(sqlite3_bind_int(stmt, 4, app_num),
-               error_code, handle_error);
-
-       do {
-               sql_ret = sqlite3_step(stmt);
-
-               switch (sql_ret) {
-               case SQLITE_DONE:
-                       break;
-               case SQLITE_ROW:
-                       UAM_DBG("Payload number info found");
-                       *payload_number = sqlite3_column_int(stmt, 0);
-                       UAM_INFO("payload number: %d", *payload_number);
-                       break;
-               case SQLITE_ERROR:
-               default:
-                       UAM_ERR("Failed to select payload device number [%d:%s]",
-                               sql_ret, sqlite3_errmsg(database_handle));
-               }
-       } while (sql_ret == SQLITE_ROW);
-
-handle_error:
-       sqlite3_reset(stmt);
-       FUNC_EXIT;
-       return error_code;
+       return __uam_db_get_payload_number(payload, payload_number, app_num, select_payload_number, "payload");
 }