/*
 * Copyright (c) 2018 Samsung Electronics Co., Ltd. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License")
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#include <glib.h>
#include <ua-api.h>
#include <user-awareness.h>
#include <user-awareness-log.h>
#include <user-awareness-private.h>
#include <user-awareness-util.h>

extern GSList *ua_users_list;

GSList *ua_devices_list = NULL;
GSList *ua_devices_user_list = NULL;
ua_callback_s user_callbacks[UA_USER_EVENT_MAX] = {{NULL, NULL},};

static void __ua_check_and_free_device_info_from_list(ua_dev_info_s *device)
{
	int ret;
	gboolean is_exist = FALSE;

	ret = _ua_is_device_exist(device->device_id, device->mac, device->type, &is_exist);
	if (UA_ERROR_NONE == ret && TRUE == is_exist)
		ua_devices_list = g_slist_remove(ua_devices_list, device);

	_ua_free_ua_device_info_t((gpointer)device);
}

static void __ua_remove_device_info_from_list(uam_device_info_s *uam_info)
{
	FUNC_ENTRY;
	GSList *l;
	ua_dev_info_s *u;
	ua_mac_type_e type;
	ret_if(NULL == uam_info);

	type = _to_ua_mac_type(uam_info->type);
	for (l = ua_devices_list; l; l = g_slist_next(l)) {
		u = (ua_dev_info_s *)l->data;

		if (type != u->type)
			continue;

		if (g_strcmp0(uam_info->device_id, u->device_id))
			continue;

		if (u->create_by_app) {
			UA_INFO("Device created by APP, do not remove");
			u->isadded = false;
		}

		UA_INFO("Device found, device id[%s]", u->device_id);
		ua_devices_list = g_slist_remove(ua_devices_list, u);
		_ua_free_ua_device_info_t((gpointer)u);
		break;
	}

	FUNC_EXIT;
}

static ua_dev_info_s* __ua_add_device_info_to_list(uam_device_info_s *uam_info)
{
	FUNC_ENTRY;
	ua_dev_info_s *dev;
	retv_if(NULL == uam_info, NULL);

	dev = _ua_get_device_from_list(uam_info->device_id,
			uam_info->mac, _to_ua_mac_type(uam_info->type));
	if (dev) {
		/* Update device info */
		g_free(dev->mac);
		dev->mac = g_strdup(uam_info->mac);

		g_free(dev->ipv4);
		dev->ipv4 = g_strdup(uam_info->ipv4_addr);

		g_free(dev->device_id);
		dev->device_id = g_strdup(uam_info->device_id);

		dev->os = uam_info->operating_system;
		dev->pairing_required = FALSE;
		dev->discriminant= true;
		dev->isadded = true;
		return dev;
	}

	dev = _ua_get_device_info_from_uam(uam_info);
	retv_if(NULL == dev, NULL);

	/* Add device to list of devices */
	ua_devices_list = g_slist_append(ua_devices_list, dev);

	FUNC_EXIT;
	return dev;
}

ua_dev_info_s *_ua_get_device_from_list(const char *device_id,
	const char *mac, ua_mac_type_e type)
{
	GSList *l;
	ua_dev_info_s *dev;

	for (l = ua_devices_list; NULL != l; l = g_slist_next(l)) {
		dev = (ua_dev_info_s *)l->data;

		UA_INFO("dev->device id [%s] dev->mac [%s]", dev->device_id, dev->mac);

		if (type != dev->type)
			continue;

		if (device_id && !g_strcmp0(device_id, dev->device_id)) {
			UA_INFO("Device ID found, device id[%s]", dev->device_id);

			if (mac && !g_strcmp0(mac, dev->mac)) {
				UA_INFO("Device found, mac address[%s]", dev->mac);
				return dev;
			}
			return dev;
		}
	}

	return NULL;
}

ua_dev_info_s* _ua_get_device_info_from_uam(uam_device_info_s *uam_info)
{
	ua_dev_info_s *dev = g_malloc0(sizeof(ua_dev_info_s));
	if (!dev) {
		UA_ERR("g_malloc0 failed");
		return NULL;
	}
	dev->user = NULL;
	dev->bssid = NULL;
	dev->ipv6 = NULL;

	dev->mac = g_strdup(uam_info->mac);
	if (dev->mac == NULL) {
		UA_ERR("g_malloc0 failed");
		_ua_free_ua_device_info_t((gpointer)dev);
		return NULL;
	}

	dev->ipv4 = g_strdup(uam_info->ipv4_addr);
	if (dev->ipv4 == NULL) {
		UA_ERR("g_malloc0 failed");
		_ua_free_ua_device_info_t((gpointer)dev);
		return NULL;
	}

	dev->device_id = g_strdup(uam_info->device_id);
	if (dev->device_id == NULL) {
		UA_ERR("g_malloc0 failed");
		_ua_free_ua_device_info_t((gpointer)dev);
		return NULL;
	}

	dev->type = _to_ua_mac_type(uam_info->type);
	dev->pairing_required = FALSE;
	dev->os = uam_info->operating_system;
	dev->discriminant= uam_info->discriminant;
	dev->isadded = true;
	dev->handle = (ua_device_h)dev;

	return dev;
}

void _ua_create_ua_ble_payload_s(ua_ble_payload_s **payload_handle)
{
	FUNC_ENTRY;
	ua_ble_payload_s *payload = NULL;

	ret_if(NULL == payload_handle);

	payload = g_malloc0(sizeof(ua_ble_payload_s));
	if (!payload) {
		UA_ERR("g_malloc0 failed");
		*payload_handle = NULL;
		return;
	}

	payload->service_id = 13;
	payload->device_icon = 1;
	payload->purpose = 1;
	payload->duid = NULL;
	payload->bt_mac = NULL;

	*payload_handle = payload;
	FUNC_EXIT;
}

void _ua_free_ua_ble_payload_s(gpointer data)
{
	FUNC_ENTRY;
	ua_ble_payload_s *payload = data;

	ret_if(NULL == payload);

	g_free(payload->duid);
	g_free(payload->bt_mac);

	g_free(payload);
	FUNC_EXIT;
}

ua_ble_payload_s* _ua_get_payload_from_uam(uam_ble_payload_s *uam_payload)
{
	FUNC_ENTRY;
	ua_ble_payload_s *payload = NULL;

	retv_if(NULL == uam_payload, NULL);

	payload = g_malloc0(sizeof(ua_ble_payload_s));
	if (!payload) {
		UA_ERR("g_malloc0 failed");
		return NULL;
	}

	payload->service_id = uam_payload->service_id;
	payload->device_icon = uam_payload->device_icon;
	payload->purpose = uam_payload->purpose;

	payload->duid = g_memdup(uam_payload->duid, UA_BLE_PAYLOAD_DUID_LEN + 1);
	if (!payload->duid) {
		UA_ERR("g_malloc0 failed");
		_ua_free_ua_ble_payload_s(payload);
		return NULL;
	}

	payload->bt_mac = g_strdup(uam_payload->bt_mac);
	if (!payload->bt_mac) {
		UA_ERR("g_malloc0 failed");
		_ua_free_ua_ble_payload_s(payload);
		return NULL;
	}

	FUNC_EXIT;
	return payload;
}

void _ua_get_uam_payload_from_ua(uam_ble_payload_s *uam_payload,
	ua_ble_payload_s *payload)
{
	FUNC_ENTRY;
	memset(uam_payload, 0, sizeof(uam_ble_payload_s));

	if (NULL == payload) {
		uam_payload->service_id = 13;
		uam_payload->device_icon = 1;
		uam_payload->purpose = 1;
		UA_DBG("(NULL == payload) return");
		return;
	}

	uam_payload->service_id = payload->service_id;
	uam_payload->device_icon = payload->device_icon;
	uam_payload->purpose = payload->purpose;

	if (payload->duid)
		memcpy(uam_payload->duid, payload->duid, UA_BLE_PAYLOAD_DUID_LEN + 1);

	if (payload->bt_mac)
		g_strlcpy(uam_payload->bt_mac, payload->bt_mac, UA_BT_MAC_MAX_LEN);

	FUNC_EXIT;
}

ua_ble_payload_s* _ua_payload_clone(ua_ble_payload_s *org_payload)
{
	FUNC_ENTRY;
	ua_ble_payload_s *payload = NULL;

	retv_if(NULL == org_payload, NULL);

	payload = g_malloc0(sizeof(ua_ble_payload_s));
	if (!payload) {
		UA_ERR("g_malloc0 failed");
		return NULL;
	}

	payload->service_id = org_payload->service_id;
	payload->device_icon = org_payload->device_icon;
	payload->purpose = org_payload->purpose;

	payload->duid = g_memdup(org_payload->duid, UA_BLE_PAYLOAD_DUID_LEN + 1);
	if (!payload->duid && org_payload->duid) {
		UA_ERR("g_malloc0 failed");
		_ua_free_ua_ble_payload_s(payload);
		return NULL;
	}

	payload->bt_mac = g_strdup(org_payload->bt_mac);
	if (!payload->bt_mac && org_payload->bt_mac) {
		UA_ERR("g_malloc0 failed");
		_ua_free_ua_ble_payload_s(payload);
		return NULL;
	}

	FUNC_EXIT;
	return payload;
}

void _ua_free_ua_device_info_t(gpointer data)
{
	FUNC_ENTRY;
	ua_dev_info_s *device = data;

	ret_if(NULL == device);

	g_free(device->mac);
	g_free(device->bssid);
	g_free(device->ipv4);
	g_free(device->ipv6); // LCOV_EXCL_LINE
	g_free(device->device_id);
	_ua_free_ua_ble_payload_s(device->payload);

	g_free(device);
	FUNC_EXIT;
}

int _ua_is_device_exist(char *device_id, char *mac, ua_mac_type_e type,
	gboolean *is_exist)
{
	GSList *l;
	UA_VALIDATE_INPUT_PARAMETER(is_exist);
	ua_dev_info_s *dev;
	*is_exist = false;

	for (l = ua_devices_list; l; l = g_slist_next(l)) {
		dev = (ua_dev_info_s *)l->data;

		if ((int)type == (int)dev->type) {
			if (device_id && !g_strcmp0(device_id, dev->device_id)) {
				/* LCOV_EXCL_START */
				UA_INFO("Device found, device id[%s]", dev->device_id);
				*is_exist = true;
				/* LCOV_EXCL_STOP */
			}

			if (mac && !g_strcmp0(mac, dev->mac)) {
				/* LCOV_EXCL_START */
				UA_INFO("Device found, mac address[%s]", dev->mac);
				*is_exist = true;
				/* LCOV_EXCL_STOP */
			}
		}
	}

	return UA_ERROR_NONE;
}

int _ua_device_add_info_to_list(ua_dev_info_s* dev_info)
{
	FUNC_ENTRY;
	int ret;
	ua_dev_info_s* device_info;
	UA_VALIDATE_INPUT_PARAMETER(dev_info);

	if (NULL != _ua_get_device_from_list(
		dev_info->device_id, dev_info->mac, dev_info->type))
			return UA_ERROR_ALREADY_DONE; // LCOV_EXCL_LINE


	ret = ua_device_clone((ua_device_h)&device_info, dev_info);
	if (UA_ERROR_NONE != ret) {
		UA_ERR("ua_device_clone failed [%s]", _ua_get_error_string(ret));
		return ret;
	}

	ua_devices_list = g_slist_append(ua_devices_list, device_info);

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

void _ua_handle_device_added(int result, uam_device_info_s *uam_info)
{
	FUNC_ENTRY;
	ua_dev_info_s *dev = NULL;
	result = _ua_get_error_code(result);

	if (UA_ERROR_NONE != result) {
		if (NULL == uam_info) {
			UA_ERR("Add device failed [%s]", _ua_get_error_string(result));
		} else  {
			dev = _ua_get_device_from_list(uam_info->device_id,
					uam_info->mac, _to_ua_mac_type(uam_info->type));
			if (NULL != dev)
				UA_ERR("Add device failed for Id:[%s] MAC type:[0x%4.4X]",
						dev->device_id, dev->type);
		}
	} else {
		dev = __ua_add_device_info_to_list(uam_info);
	}

	UA_INFO("Always invoke device added callback and reset callback");
	if (user_callbacks[UA_USER_EVENT_DEVICE_ADDED].callback) {
		((ua_user_device_added_cb)user_callbacks[UA_USER_EVENT_DEVICE_ADDED].callback)(
				result, dev, user_callbacks[UA_USER_EVENT_DEVICE_ADDED].user_data);
		UA_INFO("Invoked device added callback");

		/* Reset callback */
		user_callbacks[UA_USER_EVENT_DEVICE_ADDED].callback = NULL;
		user_callbacks[UA_USER_EVENT_DEVICE_ADDED].user_data = NULL;
	}

	FUNC_EXIT;
}

void _ua_handle_device_removed(int result, uam_device_info_s *uam_info)
{
	FUNC_ENTRY;

	result = _ua_get_error_code(result);
	ret_if(UA_ERROR_NONE != result);

	__ua_remove_device_info_from_list(uam_info);

	FUNC_EXIT;
}

int ua_device_create(ua_device_h *device_handle)
{
	FUNC_ENTRY;
	ua_dev_info_s *device = NULL;

	UA_VALIDATE_INPUT_PARAMETER(device_handle);

	device = g_malloc0(sizeof(ua_dev_info_s));
	if (!device) {
		/* LCOV_EXCL_START */
		UA_ERR("g_malloc0 failed");
		return UA_ERROR_OUT_OF_MEMORY;
		/* LCOV_EXCL_STOP */
	}

	device->user = NULL;
	device->mac = NULL;
	device->bssid = NULL;
	device->ipv4 = NULL;
	device->ipv6 = NULL;
	device->device_id = NULL;
	device->type = 0;
	device->pairing_required = FALSE;
	device->state = UA_PRSENCE_STATE_INVALID;
	device->os = UA_OS_TYPE_NOT_DEFINE;
	device->isadded = false;
	device->discriminant = true;
	device->payload = NULL;

	/* Add device to list of devices */
	*device_handle = (ua_device_h)device;
	device->handle = *device_handle;
	device->create_by_app = true;

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_destroy(ua_device_h device_handle)
{
	FUNC_ENTRY;

	ua_dev_info_s *device = (ua_dev_info_s *)device_handle;

	UA_VALIDATE_INPUT_PARAMETER(device_handle);

	__ua_check_and_free_device_info_from_list(device);

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_set_mac_type(ua_device_h handle, ua_mac_type_e mac_type)
{
	FUNC_ENTRY;

	ua_dev_info_s *device = (ua_dev_info_s *)handle;

	UA_VALIDATE_INPUT_PARAMETER(handle);
	retv_if(UA_MAC_TYPE_NONE >= mac_type, UA_ERROR_INVALID_PARAMETER);
	retv_if(UA_MAC_TYPE_INVALID <= mac_type, UA_ERROR_INVALID_PARAMETER);

	device->type = mac_type;

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_get_mac_type(ua_device_h handle, ua_mac_type_e *mac_type)
{
	FUNC_ENTRY;

	ua_dev_info_s *device = (ua_dev_info_s *)handle;

	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_VALIDATE_INPUT_PARAMETER(mac_type);
	UA_PRINT_DEVICE_HANDLE(handle);

	*mac_type = device->type;

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_set_mac_address(
		ua_device_h handle,
		const char *mac_address)
{
	FUNC_ENTRY;
	int ret;
	gboolean status = false;
	ua_dev_info_s *device = (ua_dev_info_s *)handle;

	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_VALIDATE_INPUT_PARAMETER(mac_address);

	retv_if(device->isadded, UA_ERROR_PERMISSION_DENIED);

	/* This code will check if app try to add mac address which is already set for same
	 * or for some other device handle, Then it does not allow to set and restrict to make
	 * suplicate entry as mac address is suppose to same for one device.
	 */
	ret = _ua_is_device_exist(NULL, (char*)mac_address, device->type, &status);
	if (ret == UA_ERROR_NONE) {
		if (status)
			return UA_ERROR_ALREADY_DONE;
	} else
		return ret;

	retv_if((strlen(mac_address) != (UA_MAC_ADDRESS_STRING_LEN -1)), UA_ERROR_INVALID_PARAMETER);

	g_free(device->mac);
	device->mac = g_malloc0(UA_MAC_ADDRESS_STRING_LEN);
	if (device->mac == NULL) {
		UA_ERR("Failt to allocate memory");
		return UA_ERROR_OUT_OF_MEMORY;
	}

	g_strlcpy(device->mac, mac_address, UA_MAC_ADDRESS_STRING_LEN);

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_set_os_info(
		ua_device_h handle,
		ua_os_type_e os)
{
	FUNC_ENTRY;
	ua_dev_info_s *device = (ua_dev_info_s *)handle;

	UA_VALIDATE_INPUT_PARAMETER(handle);

	retv_if(device->isadded, UA_ERROR_PERMISSION_DENIED);

	if (os > UA_OS_TYPE_IOS) {
		/* LCOV_EXCL_START */
		UA_ERR("Invalid os type");
		return UA_ERROR_INVALID_PARAMETER;
		/* LCOV_EXCL_STOP */
	}

	device->os = os;

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_set_device_id(
		ua_device_h handle,
		const char *device_id)
{
	FUNC_ENTRY;
	ua_dev_info_s *device = (ua_dev_info_s *)handle;
	int ret;
	gboolean status = false;

	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_VALIDATE_INPUT_PARAMETER(device_id);

	retv_if(device->isadded, UA_ERROR_PERMISSION_DENIED);
	/* This code will check if app try to add device id which is already set for same
	 * or for some other device handle, Then it does not allow to set and restrict to make
	 * suplicate entry as device id is suppose to same for one device.
	 */
	ret = _ua_is_device_exist((char*)device_id, NULL, device->type, &status);
	if (ret == UA_ERROR_NONE) {
		if (status)
			return UA_ERROR_ALREADY_DONE;
	} else
		return ret;

	g_free(device->device_id);
	device->device_id = g_strdup(device_id);

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_set_wifi_bssid(
		ua_device_h handle,
		const char *bssid)
{
	FUNC_ENTRY;
	ua_dev_info_s *device = (ua_dev_info_s *)handle;

	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_VALIDATE_INPUT_PARAMETER(bssid);

	retv_if(device->isadded, UA_ERROR_PERMISSION_DENIED);
	retv_if((strlen(bssid) != (UA_MAC_ADDRESS_STRING_LEN -1)), UA_ERROR_INVALID_PARAMETER);

	g_free(device->bssid);
	device->bssid = g_malloc0(UA_MAC_ADDRESS_STRING_LEN);
	if (device->bssid) {
		g_strlcpy(device->bssid, bssid, UA_MAC_ADDRESS_STRING_LEN);
	} else {
		UA_ERR("Failed to allocated memory");
		return UA_ERROR_OUT_OF_MEMORY;
	}

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_set_wifi_ipv4_address(
		ua_device_h handle,
		const char *ipv4_address)
{
	FUNC_ENTRY;
	ua_dev_info_s *device = (ua_dev_info_s *)handle;

	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_VALIDATE_INPUT_PARAMETER(ipv4_address);

	retv_if(device->isadded, UA_ERROR_PERMISSION_DENIED);
	retv_if((strlen(ipv4_address) > (UA_IPV4_ADDRESS_STRING_LEN -1)), UA_ERROR_INVALID_PARAMETER);

	g_free(device->ipv4);
	device->ipv4 = g_malloc0(UA_IPV4_ADDRESS_STRING_LEN);
	if (device->ipv4) {
		g_strlcpy(device->ipv4, ipv4_address, UA_IPV4_ADDRESS_STRING_LEN);
	} else {
		UA_ERR("Failed to allocated memory");
		return UA_ERROR_OUT_OF_MEMORY;
	}

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_set_discriminant(
		ua_device_h device_handle,
		bool discriminant)
{
	FUNC_ENTRY;
	ua_dev_info_s *device = (ua_dev_info_s *)device_handle;

	UA_VALIDATE_INPUT_PARAMETER(device_handle);

	device->discriminant = discriminant;

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_set_payload_service_id(
		ua_device_h handle,
		const char service_id)
{
	FUNC_ENTRY;
	ua_dev_info_s *device = (ua_dev_info_s *)handle;

	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_PRINT_DEVICE_HANDLE(handle);
	retv_if(device->type != UA_MAC_TYPE_BLE, UA_ERROR_INVALID_PARAMETER);

	if (!device->payload) {
		_ua_create_ua_ble_payload_s(&device->payload);
		if (!device->payload) {
			UA_ERR("_ua_create_ua_ble_payload_s() failed");
			return UA_ERROR_OUT_OF_MEMORY;
		}
	}

	device->payload->service_id = service_id;

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_set_payload_device_icon(
		ua_device_h handle,
		const char device_icon)
{
	FUNC_ENTRY;
	ua_dev_info_s *device = (ua_dev_info_s *)handle;

	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_PRINT_DEVICE_HANDLE(handle);
	retv_if(device->type != UA_MAC_TYPE_BLE, UA_ERROR_INVALID_PARAMETER);

	if (!device->payload) {
		_ua_create_ua_ble_payload_s(&device->payload);
		if (!device->payload) {
			UA_ERR("_ua_create_ua_ble_payload_s() failed");
			return UA_ERROR_OUT_OF_MEMORY;
		}
	}

	device->payload->device_icon = device_icon;

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_set_payload_purpose(
		ua_device_h handle,
		const char purpose)
{
	FUNC_ENTRY;
	ua_dev_info_s *device = (ua_dev_info_s *)handle;

	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_PRINT_DEVICE_HANDLE(handle);
	retv_if(device->type != UA_MAC_TYPE_BLE, UA_ERROR_INVALID_PARAMETER);

	if (!device->payload) {
		_ua_create_ua_ble_payload_s(&device->payload);
		if (!device->payload) {
			UA_ERR("_ua_create_ua_ble_payload_s() failed");
			return UA_ERROR_OUT_OF_MEMORY;
		}
	}

	device->payload->purpose = purpose;

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_set_payload_duid(
		ua_device_h handle,
		unsigned int duid_len,
		const char *duid)
{
	FUNC_ENTRY;
	ua_dev_info_s *device = (ua_dev_info_s *)handle;

	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_VALIDATE_INPUT_PARAMETER(duid);
	UA_PRINT_DEVICE_HANDLE(handle);
	retv_if(device->type != UA_MAC_TYPE_BLE, UA_ERROR_INVALID_PARAMETER);
	retv_if(duid_len != UA_BLE_PAYLOAD_DUID_LEN, UA_ERROR_INVALID_PARAMETER);

	if (!device->payload) {
		_ua_create_ua_ble_payload_s(&device->payload);
		if (!device->payload) {
			UA_ERR("_ua_create_ua_ble_payload_s() failed");
			return UA_ERROR_OUT_OF_MEMORY;
		}
	}

	g_free(device->payload->duid);
	device->payload->duid = NULL;

	device->payload->duid = g_malloc0(UA_BLE_PAYLOAD_DUID_LEN + 1);
	if (device->payload->duid == NULL) {
		UA_ERR("g_malloc0 failed");
		_ua_free_ua_ble_payload_s((gpointer)device->payload);
		return UA_ERROR_OUT_OF_MEMORY;
	}

	memcpy(device->payload->duid, duid, UA_BLE_PAYLOAD_DUID_LEN);

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_get_mac_address(
		ua_device_h device_handle,
		char **mac_address)
{
	FUNC_ENTRY;
	ua_dev_info_s *device = (ua_dev_info_s *)device_handle;

	UA_VALIDATE_INPUT_PARAMETER(device_handle);
	UA_VALIDATE_INPUT_PARAMETER(mac_address);
	UA_PRINT_DEVICE_HANDLE(device_handle);

	if (!device->mac) {
		/* LCOV_EXCL_START */
		*mac_address = NULL;
		goto done;
		/* LCOV_EXCL_STOP */
	}

	*mac_address = g_strdup(device->mac);

	if (*mac_address == NULL) {
		/* LCOV_EXCL_START */
		UA_ERR("g_malloc0 failed");
		return UA_ERROR_OUT_OF_MEMORY;
		/* LCOV_EXCL_STOP */
	}

done:
	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_get_os_info(
		ua_device_h device_handle,
		ua_os_type_e *os_info
		)
{
	FUNC_ENTRY;
	ua_dev_info_s *device = (ua_dev_info_s *)device_handle;

	UA_VALIDATE_INPUT_PARAMETER(device_handle);
	UA_VALIDATE_INPUT_PARAMETER(os_info);
	UA_PRINT_DEVICE_HANDLE(device_handle);

	*os_info = device->os;
	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_get_device_id(
		ua_device_h device_handle,
		char **device_id)
{
	FUNC_ENTRY;
	ua_dev_info_s *device = (ua_dev_info_s *)device_handle;

	UA_VALIDATE_INPUT_PARAMETER(device_handle);
	UA_PRINT_DEVICE_HANDLE(device_handle);
	UA_VALIDATE_INPUT_PARAMETER(device_id);

	if (!device->device_id) {
		*device_id = NULL;
		goto done;
	}

	*device_id = g_strdup(device->device_id);

	if (*device_id == NULL) {
		/* LCOV_EXCL_START */
		UA_ERR("g_malloc0 failed");
		return UA_ERROR_OUT_OF_MEMORY;
		/* LCOV_EXCL_STOP */
	}

done:
	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_get_wifi_bssid(
		ua_device_h device_handle,
		char **bssid)
{
	FUNC_ENTRY;
	ua_dev_info_s *device = (ua_dev_info_s *)device_handle;

	UA_VALIDATE_INPUT_PARAMETER(device_handle);
	UA_VALIDATE_INPUT_PARAMETER(bssid);
	UA_PRINT_DEVICE_HANDLE(device_handle);

	if (!device->bssid) {
		*bssid = NULL;
		goto done;
	}

	*bssid = g_strdup(device->bssid);

	if (*bssid == NULL) {
		/* LCOV_EXCL_START */
		UA_ERR("g_malloc0 failed");
		return UA_ERROR_OUT_OF_MEMORY;
		/* LCOV_EXCL_STOP */
	}

done:
	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_get_wifi_ipv4_address(
		ua_device_h device_handle,
		char **ipv4_address)
{
	FUNC_ENTRY;
	ua_dev_info_s *device = (ua_dev_info_s *)device_handle;

	UA_VALIDATE_INPUT_PARAMETER(device_handle);
	UA_VALIDATE_INPUT_PARAMETER(ipv4_address);
	UA_PRINT_DEVICE_HANDLE(device_handle);

	if (!device->ipv4) {
		/* LCOV_EXCL_START */
		*ipv4_address = NULL;
		goto done;
		/* LCOV_EXCL_STOP */
	}

	*ipv4_address = g_strdup(device->ipv4);

	if (*ipv4_address == NULL) {
		/* LCOV_EXCL_START */
		UA_ERR("g_malloc0 failed");
		return UA_ERROR_OUT_OF_MEMORY;
		/* LCOV_EXCL_STOP */
	}

done:
	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_get_discriminant(
		ua_device_h device_handle,
		bool *discriminant)
{
	FUNC_ENTRY;
	ua_dev_info_s *device = (ua_dev_info_s *)device_handle;

	UA_VALIDATE_INPUT_PARAMETER(device_handle);
	UA_VALIDATE_INPUT_PARAMETER(discriminant);
	UA_PRINT_DEVICE_HANDLE(device_handle);

	*discriminant = device->discriminant;

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_get_last_presence(
		ua_device_h device_handle,
		unsigned long long *timestamp)
{
	FUNC_ENTRY;
	ua_dev_info_s *device = (ua_dev_info_s *)device_handle;

	UA_VALIDATE_INPUT_PARAMETER(device_handle);
	UA_VALIDATE_INPUT_PARAMETER(timestamp);
	UA_PRINT_DEVICE_HANDLE(device_handle);

	*timestamp = device->last_presence_timestamp;

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_get_payload_service_id(
		ua_device_h handle,
		char *service_id)
{
	FUNC_ENTRY;
	ua_dev_info_s *device = (ua_dev_info_s *)handle;

	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_VALIDATE_INPUT_PARAMETER(service_id);
	UA_PRINT_DEVICE_HANDLE(handle);
	retv_if(device->type != UA_MAC_TYPE_BLE, UA_ERROR_INVALID_PARAMETER);

	if (!device->payload) {
		*service_id = 0x00;
		UA_DBG("payload(service_id) is not found");
		goto done;
	}

	*service_id = device->payload->service_id;

done:
	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_get_payload_device_icon(
		ua_device_h handle,
		char *device_icon)
{
	FUNC_ENTRY;
	ua_dev_info_s *device = (ua_dev_info_s *)handle;

	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_VALIDATE_INPUT_PARAMETER(device_icon);
	UA_PRINT_DEVICE_HANDLE(handle);
	retv_if(device->type != UA_MAC_TYPE_BLE, UA_ERROR_INVALID_PARAMETER);

	if (!device->payload) {
		*device_icon = 0x00;
		UA_DBG("payload(device_icon) is not found");
		goto done;
	}

	*device_icon = device->payload->device_icon;

done:
	FUNC_EXIT;
	return UA_ERROR_NONE;
}
int ua_device_get_payload_purpose(
		ua_device_h handle,
		char *purpose)
{
	FUNC_ENTRY;
	ua_dev_info_s *device = (ua_dev_info_s *)handle;

	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_VALIDATE_INPUT_PARAMETER(purpose);
	UA_PRINT_DEVICE_HANDLE(handle);
	retv_if(device->type != UA_MAC_TYPE_BLE, UA_ERROR_INVALID_PARAMETER);

	if (!device->payload) {
		*purpose = 0x00;
		UA_DBG("payload(purpose) is not found");
		goto done;
	}

	*purpose = device->payload->purpose;

done:
	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_get_payload_duid(
		ua_device_h handle,
		char **duid)
{
	FUNC_ENTRY;
	ua_dev_info_s *device = (ua_dev_info_s *)handle;

	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_VALIDATE_INPUT_PARAMETER(duid);
	UA_PRINT_DEVICE_HANDLE(handle);
	retv_if(device->type != UA_MAC_TYPE_BLE, UA_ERROR_INVALID_PARAMETER);

	if (!device->payload || !device->payload->duid) {
		*duid = NULL;
		UA_DBG("payload(duid) is not found");
		goto done;
	}

	*duid = g_memdup(device->payload->duid, UA_BLE_PAYLOAD_DUID_LEN);
	if (*duid == NULL) {
		/* LCOV_EXCL_START */
		UA_ERR("g_memdup failed");
		return UA_ERROR_OUT_OF_MEMORY;
		/* LCOV_EXCL_STOP */
	}

done:
	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_get_by_mac_address(
		const char *mac,
		ua_device_h *device_handle)
{
	FUNC_ENTRY;
	GSList *l;
	int ret;
	ua_dev_info_s *dev;
	uam_device_info_s uam_dev;

	UA_VALIDATE_INPUT_PARAMETER(mac);
	UA_VALIDATE_INPUT_PARAMETER(device_handle);

	for (l = ua_devices_list; l; l = g_slist_next(l)) {
		dev = (ua_dev_info_s *)l->data;

		if (!g_strcmp0(mac, dev->mac)) {
			UA_INFO("MAC found [%s]", dev->mac);
			*device_handle = (ua_device_h)dev;
			goto done;
		}
	}

	/* LCOV_EXCL_START */
	ret = _ua_get_error_code(_uam_request_get_device_by_mac(mac, &uam_dev));
	if (UA_ERROR_NONE != ret) {
		UA_ERR("Failed with error: %s(0x%X)",
				_ua_get_error_string(ret), ret);
		*device_handle = NULL;
		return ret;
	}

	dev = g_malloc0(sizeof(ua_dev_info_s));
	if (!dev) {
		UA_ERR("g_malloc0 failed");
		return UA_ERROR_OUT_OF_MEMORY;
	}

	dev->user = NULL;
	dev->bssid = NULL;
	dev->ipv6 = NULL;

	dev->mac = g_strdup(uam_dev.mac);

	if (dev->mac == NULL) {
		UA_ERR("g_malloc0 failed");
		*device_handle = NULL;
		_ua_free_ua_device_info_t((gpointer)dev);
		return UA_ERROR_OUT_OF_MEMORY;
	}

	dev->ipv4 = g_strdup(uam_dev.ipv4_addr);

	if (dev->ipv4 == NULL) {
		UA_ERR("g_malloc0 failed");
		*device_handle = NULL;
		_ua_free_ua_device_info_t((gpointer)dev);
		return UA_ERROR_OUT_OF_MEMORY;
	}

	dev->device_id = g_strdup(uam_dev.device_id);

	if (dev->device_id == NULL) {
		UA_ERR("g_malloc0 failed");
		*device_handle = NULL;
		_ua_free_ua_device_info_t((gpointer)dev);
		return UA_ERROR_OUT_OF_MEMORY;
	}

	dev->payload = _ua_get_payload_from_uam(&uam_dev.payload);
	if (dev->payload == NULL) {
		UA_ERR("_ua_get_payload_from_uam() failed");
		*device_handle = NULL;
		_ua_free_ua_device_info_t((gpointer)dev);
		return UA_ERROR_OUT_OF_MEMORY;
	}

	dev->type = _to_ua_mac_type(uam_dev.type);
	dev->pairing_required = FALSE;
	dev->discriminant= uam_dev.discriminant;
	dev->os = uam_dev.operating_system;
	dev->isadded = true;

	/* Add device to list of devices */
	*device_handle = (ua_device_h)dev;
	dev->handle = *device_handle;
	ua_devices_list = g_slist_append(ua_devices_list, dev);
	/* LCOV_EXCL_STOP */

done:
	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_get_by_device_id(
		const char *device_id,
		ua_mac_type_e mac_type,
		ua_device_h *device_handle)
{
	FUNC_ENTRY;
	GSList *l;
	int ret;
	ua_dev_info_s *dev;
	uam_device_info_s uam_dev;
	uam_tech_type_e type;

	UA_VALIDATE_INPUT_PARAMETER(device_id);
	UA_VALIDATE_INPUT_PARAMETER(device_handle);
	retv_if(UA_MAC_TYPE_NONE >= mac_type, UA_ERROR_INVALID_PARAMETER);
	retv_if((UA_MAC_TYPE_INVALID <= mac_type), UA_ERROR_INVALID_PARAMETER);

	for (l = ua_devices_list; l; l = g_slist_next(l)) {
		dev = (ua_dev_info_s *)l->data;

		if ((mac_type == dev->type) && !g_strcmp0(device_id, dev->device_id)) {
			UA_INFO("Mobile ID found [%s]", dev->device_id);
			*device_handle = (ua_device_h)dev;
			goto done;
		}
	}

	/* LCOV_EXCL_START */
	type = _ua_to_uam_tech_type(mac_type);
	ret = _ua_get_error_code(_uam_request_get_device_by_deviceid(device_id, type, &uam_dev));
	if (UA_ERROR_NONE != ret) {
		UA_ERR("Failed with error: %s(0x%X)",
				_ua_get_error_string(ret), ret);
		*device_handle = NULL;
		return ret;
	}

	dev = g_malloc0(sizeof(ua_dev_info_s));
	if (!dev) {
		UA_ERR("g_malloc0 failed");
		return UA_ERROR_OUT_OF_MEMORY;
	}

	dev->user = NULL;
	dev->bssid = NULL;
	dev->ipv6 = NULL;

	dev->mac = g_strdup(uam_dev.mac);

	if (dev->mac == NULL) {
		UA_ERR("g_malloc0 failed");
		*device_handle = NULL;
		_ua_free_ua_device_info_t((gpointer)dev);
		return UA_ERROR_OUT_OF_MEMORY;
	}

	dev->ipv4 = g_strdup(uam_dev.ipv4_addr);

	if (dev->ipv4 == NULL) {
		UA_ERR("g_malloc0 failed");
		*device_handle = NULL;
		_ua_free_ua_device_info_t((gpointer)dev);
		return UA_ERROR_OUT_OF_MEMORY;
	}

	dev->device_id = g_strdup(uam_dev.device_id);

	if (dev->device_id == NULL) {
		UA_ERR("g_malloc0 failed");
		*device_handle = NULL;
		_ua_free_ua_device_info_t((gpointer)dev);
		return UA_ERROR_OUT_OF_MEMORY;
	}

	dev->payload = _ua_get_payload_from_uam(&uam_dev.payload);
	if (dev->payload == NULL) {
		UA_ERR("_ua_get_payload_from_uam() failed");
		*device_handle = NULL;
		_ua_free_ua_device_info_t((gpointer)dev);
		return UA_ERROR_OUT_OF_MEMORY;
	}

	dev->type = _to_ua_mac_type(uam_dev.type);
	dev->pairing_required = FALSE;
	dev->os = uam_dev.operating_system;
	dev->discriminant= uam_dev.discriminant;
	dev->isadded = true;

	/* Add device to list of devices */
	*device_handle = (ua_device_h)dev;
	dev->handle = *device_handle;
	ua_devices_list = g_slist_append(ua_devices_list, dev);
	/* LCOV_EXCL_STOP */

done:
	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_update(ua_device_h device_handle)
{
	int ret;
	gboolean is_registered = false;
	uam_device_info_s uam_device;
	ua_dev_info_s *device = (ua_dev_info_s *)device_handle;
	UA_PRINT_DEVICE_HANDLE(device);

	retv_if((device->device_id == NULL || device->mac == NULL), UA_ERROR_INVALID_PARAMETER);
	retv_if((UA_MAC_TYPE_NONE >= device->type), UA_ERROR_INVALID_PARAMETER);
	retv_if((UA_MAC_TYPE_INVALID <= device->type), UA_ERROR_INVALID_PARAMETER);

	memset(&uam_device, 0, sizeof(uam_device_info_s));

	uam_device.operating_system = device->os;
	uam_device.type = _ua_to_uam_tech_type(device->type);
	uam_device.discriminant = device->discriminant;

	if (device->mac)
		g_strlcpy(uam_device.mac, device->mac, UAM_MAC_ADDRESS_STRING_LEN);

	if (device->device_id)
		g_strlcpy(uam_device.device_id, device->device_id, UA_MOBILE_ID_STRING_LEN);

	if (device->ipv4)
		g_strlcpy(uam_device.ipv4_addr, device->ipv4, UA_IPV4_ADDRESS_STRING_LEN);

	_ua_get_uam_payload_from_ua(&uam_device.payload, device->payload);

	ret = _ua_get_error_code(_uam_is_device_registered(&uam_device, &is_registered));
	if (UA_ERROR_NONE != ret) {
		/* LCOV_EXCL_START */
		UA_ERR("Failed with error: %s(0x%X)",
				_ua_get_error_string(ret), ret);
		/* LCOV_EXCL_STOP */
		return ret;
	}

	if (!is_registered) {
		/* LCOV_EXCL_START */
		UA_ERR("No registerd device");
		/* LCOV_EXCL_STOP */
		return UA_ERROR_INVALID_PARAMETER;
	}

	ret = _ua_get_error_code(_uam_request_update_device(&uam_device));
	if (UA_ERROR_NONE != ret) {
		/* LCOV_EXCL_START */
		UA_ERR("_uam_request_set_device_update returned %s",
				_ua_get_error_string(ret));
		/* LCOV_EXCL_STOP */
		return ret;
	}

	FUNC_EXIT;
	return UA_ERROR_NONE;
}

int ua_device_clone(ua_device_h *cloned,
		ua_device_h origin)
{
	FUNC_ENTRY;
	int ret;
	ua_dev_info_s *device;
	uam_user_info_s uam_user;
	ua_dev_info_s *org_device = (ua_dev_info_s *)origin;

	/* LCOV_EXCL_START */
	UA_VALIDATE_INPUT_PARAMETER(cloned);
	UA_VALIDATE_INPUT_PARAMETER(origin);

	UA_DBG("org_device->device_id [%s] org_device->mac [%s] org_device->type [%d]",
		org_device->device_id, org_device->mac, org_device->type);

	UA_IS_EXIST(_ua_get_device_from_list(
					org_device->device_id, org_device->mac, org_device->type));

	device = g_malloc0(sizeof(ua_dev_info_s));
	if (!device) {
		UA_ERR("g_malloc0 failed");
		return UA_ERROR_OUT_OF_MEMORY;
	}

	device->mac = g_strdup(org_device->mac);
	if (device->mac == NULL) {
		UA_ERR("g_malloc0 failed");
		_ua_free_ua_device_info_t((gpointer)device);
		return UA_ERROR_OUT_OF_MEMORY;
	}

	device->ipv4 = g_strdup(org_device->ipv4);
	if (device->ipv4 == NULL) {
		UA_ERR("g_malloc0 failed");
		_ua_free_ua_device_info_t((gpointer)device);
		return UA_ERROR_OUT_OF_MEMORY;
	}

	device->device_id = g_strdup(org_device->device_id);
	if (device->device_id == NULL) {
		UA_ERR("g_malloc0 failed");
		_ua_free_ua_device_info_t((gpointer)device);
		return UA_ERROR_OUT_OF_MEMORY;
	}

	device->payload = _ua_payload_clone(org_device->payload);
	if (device->payload == NULL && org_device->payload) {
		UA_ERR("g_malloc0 failed");
		_ua_free_ua_device_info_t((gpointer)device);
		return UA_ERROR_OUT_OF_MEMORY;
	}

	device->isadded = org_device->isadded;
	device->type = org_device->type;
	device->os = org_device->os;
	device->discriminant = org_device->discriminant;
	device->last_presence_timestamp = org_device->last_presence_timestamp;

	if (!device->user) {
		/* Currently user info will be create and store at this point */
		ret = _ua_get_error_code(_uam_request_get_user_by_deviceid(device->device_id, &uam_user));
		if (UA_ERROR_NONE != ret) {
			UA_ERR("Failed with error: %s(0x%X)",
					_ua_get_error_string(ret), ret);
			_ua_free_ua_device_info_t((gpointer)device);
			return ret;
		} else {
			GSList *l;
			ua_user_info_s *user_info;
			int found = 0;

			for (l = ua_users_list; l; l = g_slist_next(l)) {
				user_info = (ua_user_info_s *)l->data;

				if (!g_strcmp0(uam_user.account, user_info->account)) {
					UA_INFO("User found [%s]", user_info->account);
					device->user = (ua_user_h)user_info;
					found = 1;
					break;
				}
			}

			if (!found)
				UA_ERR("User not found [%s]", uam_user.account);
			else
				UA_ERR("User found [%s]", uam_user.account);

		}
	} else
		UA_INFO("user handle is already present!");

	/* Add device to list of devices */
	*cloned = (ua_device_h)device;
	device->handle = (ua_device_h)device;
	device->create_by_app = true;

	FUNC_EXIT;
	/* LCOV_EXCL_STOP */
	return UA_ERROR_NONE;
}

int ua_device_foreach_added(
		ua_registered_dev_cb foreach_cb,
		void *user_data)
{
	FUNC_ENTRY;
	int i;
	int ret;
	GPtrArray *devices_list = NULL;
	uam_device_info_s *ptr;
	GSList *l;

	UA_VALIDATE_INPUT_PARAMETER(foreach_cb);

	devices_list = g_ptr_array_new();
	retv_if(NULL == devices_list, UA_ERROR_OUT_OF_MEMORY);

	ret = _ua_get_error_code(_uam_request_get_devices(&devices_list));
	if (UA_ERROR_NONE != ret) {
		/* LCOV_EXCL_START */
		UA_ERR("Failed with error: %s(0x%X)",
				_ua_get_error_string(ret), ret);
		g_ptr_array_free(devices_list, TRUE);
		/* LCOV_EXCL_STOP */
		return ret;
	}

	if (ua_devices_list) {
		g_slist_free_full(ua_devices_list, _ua_free_ua_device_info_t);
		ua_devices_list = NULL;
	}

	for (i = 0; i < devices_list->len; i++) {
		/* LCOV_EXCL_START */
		ptr = g_ptr_array_index(devices_list, i);
		if (ptr) {
			ua_dev_info_s* device_info;
			device_info = g_malloc0(sizeof(ua_dev_info_s));
			if (!device_info) {
				UA_ERR("g_malloc0 failed");
				ret = UA_ERROR_OUT_OF_MEMORY;
				goto done;
			}

			device_info->mac = g_strdup(ptr->mac);
			if (device_info->mac == NULL) {
				UA_ERR("g_malloc0 failed");
				_ua_free_ua_device_info_t((gpointer)device_info);
				ret = UA_ERROR_OUT_OF_MEMORY;
				goto done;
			}

			device_info->ipv4 = g_strdup(ptr->ipv4_addr);
			if (device_info->ipv4 == NULL) {
				UA_ERR("g_malloc0 failed");
				_ua_free_ua_device_info_t((gpointer)device_info);
				ret = UA_ERROR_OUT_OF_MEMORY;
				goto done;
			}

			device_info->device_id = g_strdup(ptr->device_id);
			if (device_info->device_id == NULL) {
				UA_ERR("g_malloc0 failed");
				ret = UA_ERROR_OUT_OF_MEMORY;
				_ua_free_ua_device_info_t((gpointer)device_info);
				goto done;
			}

			device_info->payload = _ua_get_payload_from_uam(&ptr->payload);
			if (device_info->payload == NULL) {
				UA_ERR("_ua_get_payload_from_uam() failed");
				ret = UA_ERROR_OUT_OF_MEMORY;
				_ua_free_ua_device_info_t((gpointer)device_info);
				goto done;
			}

			device_info->isadded = true;
			device_info->handle = (ua_device_h)device_info;
			device_info->type = _to_ua_mac_type(ptr->type);
			device_info->os = ptr->operating_system;
			device_info->discriminant = ptr->discriminant;
			device_info->last_presence_timestamp = ptr->last_seen;
			ua_devices_list = g_slist_append(ua_devices_list, device_info);
		} else {
			UA_ERR("OPERATION_FAILED(0x%08x)",
					UA_ERROR_OPERATION_FAILED);
			ret = UA_ERROR_OPERATION_FAILED;
			goto done;
		}
		/* LCOV_EXCL_STOP */
	}

	for (l = ua_devices_list; l; l = g_slist_next(l)) {
		/* LCOV_EXCL_START */
		ua_dev_info_s *u = l->data;

		if (NULL == u)
			continue;

		if (!foreach_cb(u->handle, user_data))
			break;
		/* LCOV_EXCL_STOP */
	}

done:
	g_ptr_array_foreach(devices_list, (GFunc)g_free, NULL);
	g_ptr_array_free(devices_list, TRUE);

	FUNC_EXIT;
	return ret;
}

int ua_device_foreach_added_by_user(
		ua_user_h user_handle,
		ua_registered_dev_cb foreach_cb,
		void *user_data)
{
	FUNC_ENTRY;
	int i;
	int ret;
	ua_user_info_s *user = (ua_user_info_s *)user_handle;
	GPtrArray *devices_list = NULL;
	uam_device_info_s *ptr;
	GSList *l;

	UA_VALIDATE_INPUT_PARAMETER(foreach_cb);
	UA_VALIDATE_INPUT_PARAMETER(user_handle);
	UA_VALIDATE_HANDLE(user_handle, ua_users_list);

	devices_list = g_ptr_array_new();
	retv_if(NULL == devices_list, UA_ERROR_OUT_OF_MEMORY);

	ret = _ua_get_error_code(_uam_request_get_user_devices(user->account, &devices_list));
	if (UA_ERROR_NONE != ret) {
		UA_ERR("Failed with error: %s(0x%X)",
				_ua_get_error_string(ret), ret);
		g_ptr_array_free(devices_list, TRUE);
		return ret;
	}

	if (ua_devices_user_list) {
		g_slist_free_full(ua_devices_user_list, _ua_free_ua_device_info_t);
		ua_devices_user_list= NULL;
	}

	for (i = 0; i < devices_list->len; i++) {
		/* LCOV_EXCL_START */
		ptr = g_ptr_array_index(devices_list, i);
		if (ptr) {
			ua_dev_info_s* device_info;
			device_info = g_malloc0(sizeof(ua_dev_info_s));
			if (!device_info) {
				UA_ERR("g_malloc0 failed");
				ret = UA_ERROR_OUT_OF_MEMORY;
				goto done;
			}

			device_info->mac = g_strdup(ptr->mac);
			if (device_info->mac == NULL) {
				UA_ERR("g_malloc0 failed");
				ret = UA_ERROR_OUT_OF_MEMORY;
				_ua_free_ua_device_info_t((gpointer)device_info);
				goto done;
			}

			device_info->ipv4 = g_strdup(ptr->ipv4_addr);
			if (device_info->ipv4 == NULL) {
				UA_ERR("g_malloc0 failed");
				ret = UA_ERROR_OUT_OF_MEMORY;
				_ua_free_ua_device_info_t((gpointer)device_info);
				goto done;
			}

			device_info->device_id = g_strdup(ptr->device_id);
			if (device_info->device_id == NULL) {
				UA_ERR("g_malloc0 failed");
				ret = UA_ERROR_OUT_OF_MEMORY;
				_ua_free_ua_device_info_t((gpointer)device_info);
				goto done;
			}

			device_info->payload = _ua_get_payload_from_uam(&ptr->payload);
			if (device_info->payload == NULL) {
				UA_ERR("_ua_get_payload_from_uam() failed");
				ret = UA_ERROR_OUT_OF_MEMORY;
				_ua_free_ua_device_info_t((gpointer)device_info);
				goto done;
			}

			device_info->isadded = true;
			device_info->handle = (ua_device_h)device_info;
			device_info->type = _to_ua_mac_type(ptr->type);
			device_info->os = ptr->operating_system;
			device_info->last_presence_timestamp = ptr->last_seen;
			device_info->discriminant = ptr->discriminant;
			device_info->user = (ua_user_h)user;
			ua_devices_user_list = g_slist_append(ua_devices_user_list, device_info);
		} else {
			UA_ERR("OPERATION_FAILED(0x%08x)",
					UA_ERROR_OPERATION_FAILED);
			ret = UA_ERROR_OPERATION_FAILED;
			goto done;
		}
		/* LCOV_EXCL_STOP */
	}

	for (l = ua_devices_user_list; l; l = g_slist_next(l)) {
		/* LCOV_EXCL_START */
		ua_dev_info_s *u = l->data;

		if (NULL == u)
			continue;

		if (!foreach_cb(u->handle, user_data))
			break;
		/* LCOV_EXCL_STOP */
	}

done:
	g_ptr_array_foreach(devices_list, (GFunc)g_free, NULL);
	g_ptr_array_free(devices_list, TRUE);

	FUNC_EXIT;
	return ret;
}

int ua_device_get_pairing_required(
		ua_device_h handle,
		bool *pairing_required)
{
	FUNC_ENTRY;
	int ret;
	ua_dev_info_s *device = (ua_dev_info_s *)handle;
	gboolean is_registered = FALSE;
	uam_device_info_s uam_device;

	UA_VALIDATE_INPUT_PARAMETER(handle);
	UA_VALIDATE_INPUT_PARAMETER(pairing_required);
	UA_PRINT_DEVICE_HANDLE(device_handle);

	retv_if((((device->device_id == NULL) && (device->mac == NULL))), UA_ERROR_INVALID_PARAMETER);
	retv_if((UA_MAC_TYPE_NONE >= device->type), UA_ERROR_INVALID_PARAMETER);
	retv_if((UA_MAC_TYPE_INVALID <= device->type), UA_ERROR_INVALID_PARAMETER);

	memset(&uam_device, 0, sizeof(uam_device_info_s));

	uam_device.operating_system = device->os;
	uam_device.discriminant = device->discriminant;
	uam_device.type = _ua_to_uam_tech_type(device->type);

	if (device->mac)
		g_strlcpy(uam_device.mac, device->mac, UAM_MAC_ADDRESS_STRING_LEN);

	if (device->device_id)
		g_strlcpy(uam_device.device_id, device->device_id, UA_MOBILE_ID_STRING_LEN);

	if (device->ipv4)
		g_strlcpy(uam_device.ipv4_addr, device->ipv4, UA_IPV4_ADDRESS_STRING_LEN);

	ret = _ua_get_error_code(_uam_is_device_registered(&uam_device, &is_registered));
	if (UA_ERROR_NONE != ret) {
		/* LCOV_EXCL_START */
		UA_ERR("Failed with error: %s(0x%X)",
				_ua_get_error_string(ret), ret);
		/* LCOV_EXCL_STOP */
		return ret;
	}

	*pairing_required = is_registered ? false : true;

	FUNC_EXIT;
	return UA_ERROR_NONE;
}