path: root/test/uat-users.c

/*
 * 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 <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <glib.h>
#include <gio/gio.h>

#include <user-awareness.h>

#include "uat-menu.h"
#include "uat-common.h"

extern ua_monitor_h g_ua_mon_h; /**< Monitor handle */
extern ua_device_h g_device_h; /**< Device handle */
ua_user_h g_user_h = NULL; /**< User handle */
extern ua_service_h g_service_h; /**< Service handle */

char g_user_account_str[MENU_DATA_SIZE + 1] = { "default@default.com" };
char g_user_name_str[MENU_DATA_SIZE + 1] = { "default" };

extern char g_device_type[MENU_DATA_SIZE + 1]; /**< Sensor type of the selected device */
extern char g_device_type_str[MENU_DATA_SIZE + 1]; /**< Readable sensor type string */
extern char g_device_id_str[MENU_DATA_SIZE + 1]; /**< Mobile ID of the selected device */
extern char g_mac_addr_str[MENU_DATA_SIZE + 1]; /**< MAC of the selected device */

extern char g_service_str[MENU_DATA_SIZE + 1]; /**< Service name */

GSList *user_list = NULL; /**< User List */
int idx_user = 0; /**< Found device sequence number */

extern char g_selected_device_idx[MENU_DATA_SIZE + 1]; /**< Selected device id */
extern GSList *g_device_list; /**< Device List */
extern int g_device_count; /**< Seletected service name */

char g_selected_user_idx[MENU_DATA_SIZE + 1] = {0,}; /** Selected user id */

static void update_user_info(void)
{
	int ret = UA_ERROR_NONE;
	char *account = NULL;
	char *name = NULL;

	if (0 == idx_user) {
		if (g_user_h) {
			ua_user_destroy(g_user_h);
			g_user_h = NULL;
		}
		ua_user_get_default_user(&g_user_h);
	}

	ret  = ua_user_get_account(g_user_h, &account);
	if (UA_ERROR_NONE == ret) {
		memset(g_user_account_str, 0, MENU_DATA_SIZE + 1);
		memcpy(g_user_account_str, account, MENU_DATA_SIZE);
		g_free(account);
	}
	ret  = ua_user_get_name(g_user_h, &name);
	if (UA_ERROR_NONE == ret) {
		memset(g_user_name_str, 0, MENU_DATA_SIZE + 1);
		memcpy(g_user_name_str, name, MENU_DATA_SIZE);
		g_free(name);
	}
}

static void  ___free_users(gpointer data)
{
	ua_user_h handle = data;
	ua_user_destroy(handle);
	handle = NULL;
}

void uat_clear_user_list(void)
{
	g_slist_free_full(user_list, ___free_users);
	user_list = NULL;
	idx_user = 0;
}

static bool __foreach_registered_user_cb(
	ua_user_h user_handle, void *user_data)
{
	int ret = UA_ERROR_NONE;
	ua_user_h handle = NULL;
	char *account = NULL;
	char *name = NULL;
	unsigned long long timestamp = 0;

	if (!user_handle) {
		msgr("user_handle is NULL");
		return true;
	}

	ret = ua_user_clone(&handle, user_handle);
	if (UA_ERROR_NONE != ret) {
		msgr("ua_user_clone() result: [0x%X] [%s]",
			ret, uat_get_error_str(ret));
	}

	user_list = g_slist_append(user_list, handle);
	idx_user++;

	ret = ua_user_get_account(handle, &account);
	if (UA_ERROR_NONE == ret) {
		msglr("[%d]", idx_user);
		msglr("User account info %s", account);
		g_free(account);
	}

	ret = ua_user_get_name(handle, &name);
	if (UA_ERROR_NONE == ret) {
		msglr("User Name : %s", name);
		g_free(name);
	}

	ret = ua_user_get_last_presence(handle, &timestamp);
	if (UA_ERROR_NONE == ret)
		msglr("last present at %llu", timestamp);

	return true;
}

static void __device_added_cb(int result,
		ua_device_h handle, void *user_data)
{
	int ret;
	ua_mac_type_e mac_type = UA_MAC_TYPE_INVALID;
	ua_os_type_e ostype = UA_OS_TYPE_NOT_DEFINE;
	char *device_id = NULL;
	char *mac = NULL;
	char *ipv4 = NULL;

	if (UA_ERROR_NONE != result) {
		msgr("__device_added_cb() result: [0x%X] [%s]",
			result, uat_get_error_str(result));
		return;
	}

	if (NULL == handle) {
		msgr("Device handle is NULL");
		return;
	}

	msgb("__device_added_cb() result: [0x%X] [%s]",
			result, uat_get_error_str(result));

	ret = ua_device_get_mac_type(handle, &mac_type);
	if (UA_ERROR_NONE == ret)
		msgb("Device MAC Type : %s", uat_get_mac_type_str(mac_type));

	ret = ua_device_get_os_info(handle, &ostype);
	if (UA_ERROR_NONE == ret)
		msgb("Device OS Type : %s",
				ostype == 1 ? "Tizen" :
				ostype == 2 ? "Android" :
				ostype == 3 ? "iOS" : "N/A");

	ret = ua_device_get_device_id(handle, &device_id);
	if (UA_ERROR_NONE == ret) {
		msgb("Device ID : %s", device_id);
		g_free(device_id);
	}

	ret = ua_device_get_mac_address(handle, &mac);
	if (UA_ERROR_NONE == ret) {
		msgb("Device MAC : %s", mac);
		g_free(mac);
	}

	ret = ua_device_get_wifi_ipv4_address(handle, &ipv4);
	if (UA_ERROR_NONE == ret) {
		msgb("Device IPv4 Addr : %s", ipv4);
		g_free(ipv4);
	}

}

static bool _user_foreach_added_device_cb(ua_device_h device_handle,
	void *user_data)
{
	int ret, ret_temp;
	ua_device_h handle = NULL;

	ua_mac_type_e mac_type = UA_MAC_TYPE_INVALID;
	ua_os_type_e ostype = UA_OS_TYPE_NOT_DEFINE;

	char *device_id = NULL;
	char *mac = NULL;
	char *wifi_bssid = NULL;
	char *ipv4 = NULL;
	bool required = false;
	unsigned long long timestamp = 0;
	bool discriminant = false;
	char service_id = 0;
	char device_icon = 0;
	char purpose = 0;
	char *duid = NULL;

	if (!device_handle) {
		msgr("device_handle is NULL");
		return true;
	}

	ret = ua_device_clone(&handle, device_handle);
	if (UA_ERROR_NONE != ret) {
		msgr(" - ua_device_clone() ret: [0x%X] [%s]",
			ret, uat_get_error_str(ret));
		return true;
	}

	msgc("\n[%d]", ++g_device_count);

	ret_temp = ua_device_get_mac_type(handle, &mac_type);
	if (UA_ERROR_NONE == ret_temp)
		msgc("Device MAC Type : %s", uat_get_mac_type_str(mac_type));

	ret_temp = ua_device_get_os_info(handle, &ostype);
	if (UA_ERROR_NONE == ret_temp) {
		msgc("Device OS Type : %s",
			ostype == 1 ? "Tizen" :
			ostype == 2 ? "Android" :
			ostype == 3 ? "iOS" : "N/A");
	}

	ret_temp = ua_device_get_device_id(handle, &device_id);
	if (UA_ERROR_NONE == ret_temp) {
		msgc("Device ID : %s", device_id);
		g_free(device_id);
	}

	ret_temp = ua_device_get_mac_address(handle, &mac);
	if (UA_ERROR_NONE == ret_temp) {
		msgc("Device MAC : %s", mac);
		g_free(mac);
	}

	ret_temp = ua_device_get_wifi_bssid(handle, &wifi_bssid);
	if (UA_ERROR_NONE == ret_temp) {
		msgc("Device BSSID : %s", wifi_bssid);
		g_free(wifi_bssid);
	}

	ret_temp = ua_device_get_wifi_ipv4_address(handle, &ipv4);
	if (UA_ERROR_NONE == ret_temp) {
		msgc("Device IPv4 Addr : %s", ipv4);
		g_free(ipv4);
	}

	ret_temp = ua_device_get_discriminant(handle, &discriminant);
	if (UA_ERROR_NONE == ret_temp)
		msgc("Discriminant : %s", discriminant ? "Enabled" : "Disabled");

	ret_temp = ua_device_get_pairing_required(handle, &required);
	if (UA_ERROR_NONE == ret_temp)
		msgc("Pairing Required : %s", required ? "YES" : "NO");

	ret_temp = ua_device_get_last_presence(handle, &timestamp);
	if (UA_ERROR_NONE == ret_temp)
		msgc("Last present at : %llu", timestamp);

	ret_temp = ua_device_get_payload_service_id(handle, &service_id);
	if (UA_ERROR_NONE == ret_temp)
		msgc("payload service_id : %d[hex: 0x%X]", service_id, service_id);

	ret_temp = ua_device_get_payload_device_icon(handle, &device_icon);
	if (UA_ERROR_NONE == ret_temp)
		msgc("payload device_icon : %d[hex: 0x%X]", device_icon, device_icon);

	ret_temp = ua_device_get_payload_purpose(handle, &purpose);
	if (UA_ERROR_NONE == ret_temp)
		msgc("payload purpose : %d[hex: 0x%X]", purpose, purpose);

	ret_temp = ua_device_get_payload_duid(handle, &duid);
	if (UA_ERROR_NONE == ret_temp) {
		uat_print_duid(duid);
		g_free(duid);
	}

	g_device_list = g_slist_append(g_device_list, handle);

	return true;
}

int uat_select_user(MManager *mm, struct menu_data *menu)
{
	GSList *iter = user_list;

	int id = 0;
	int selected_id = 0;

	if (strlen(g_selected_user_idx))
		selected_id = (unsigned char)strtol(g_selected_user_idx, NULL, 10);

	if (selected_id <= 0) {
		msg("Please select user first");
		return RET_SUCCESS;
	}

	while (NULL != iter) {
		GSList *next = iter->next;
		ua_user_h *handle = iter->data;
		if (handle && ++id == selected_id) {
			g_user_h = handle; /* Make selected user as a current one */
			update_user_info(); /* Update user info. */
			msg("Select user done");
			return RET_SUCCESS;
		}
		iter = next;
	}

	return RET_SUCCESS;
}

static int run_ua_user_create(MManager *mm, struct menu_data *menu)
{
	int ret = UA_ERROR_NONE;

	msg("ua_user_create");

	if (g_user_h) {
		ua_user_destroy((g_user_h));
		g_user_h = NULL;
	}

	ret = ua_user_create(&g_user_h);

	msg(" - ua_user_create() ret: [0x%X] [%s]",
			ret, uat_get_error_str(ret));

	return RET_SUCCESS;
}

static int run_ua_user_destroy(MManager *mm, struct menu_data *menu)
{
	int ret = UA_ERROR_NONE;

	msg("ua_user_destroy");

	if (g_user_h) {
		ret = ua_user_destroy((g_user_h));
		g_user_h = NULL;
	}

	msg(" - ua_user_destroy() ret: [0x%X] [%s]",
			ret, uat_get_error_str(ret));

	return RET_SUCCESS;
}

static int run_ua_user_set_account(MManager *mm, struct menu_data *menu)
{
	int ret = UA_ERROR_NONE;

	msg("ua_user_set_account");

	check_if(NULL == g_user_h);

	ret = ua_user_set_account(g_user_h, g_user_account_str);

	msg(" - ua_user_set_account() ret: [0x%X] [%s]",
			ret, uat_get_error_str(ret));

	return RET_SUCCESS;
}

static int run_ua_user_set_name(MManager *mm, struct menu_data *menu)
{
	int ret = UA_ERROR_NONE;

	msg("ua_user_set_name");

	check_if(NULL == g_user_h);

	ret = ua_user_set_name(g_user_h, g_user_name_str);

	msg(" - ua_user_set_name() ret: [0x%X] [%s]",
			ret, uat_get_error_str(ret));

	return RET_SUCCESS;
}

static int run_ua_user_add(MManager *mm, struct menu_data *menu)
{
	int ret = UA_ERROR_NONE;

	msg("ua_user_add");

	check_if(NULL == g_user_h);

	ret = ua_user_add(g_user_h);

	msg(" - ua_user_add() ret: [0x%X] [%s]",
			ret, uat_get_error_str(ret));

	return RET_SUCCESS;
}

static int run_ua_user_remove(MManager *mm, struct menu_data *menu)
{
	int ret = UA_ERROR_NONE;

	msg("ua_user_remove");

	check_if(NULL == g_user_h);

	ret = ua_user_remove(g_user_h);

	msg(" - ua_user_remove() ret: [0x%X] [%s]",
			ret, uat_get_error_str(ret));

	return RET_SUCCESS;
}

static int run_ua_user_update(MManager *mm, struct menu_data *menu)
{
	int ret = UA_ERROR_NONE;

	msg("ua_user_update");

	check_if(NULL == g_user_h);

	ret = ua_user_update(g_user_h);

	msg(" - ua_user_update() ret: [0x%X] [%s]",
			ret, uat_get_error_str(ret));

	return RET_SUCCESS;
}

static int run_ua_user_get_default_user(MManager *mm, struct menu_data *menu)
{
	int ret = UA_ERROR_NONE;

	msg("ua_user_get_default_user");

	if (g_user_h) {
		ua_user_destroy(g_user_h);
		g_user_h = NULL;
	}

	ret = ua_user_get_default_user(&g_user_h);
	if (UA_ERROR_NONE == ret)
		update_user_info();

	msg(" - ua_get_default_user() ret: [0x%X] [%s]",
		ret, uat_get_error_str(ret));

	return RET_SUCCESS;
}

static int run_ua_user_get_by_account(MManager *mm, struct menu_data *menu)
{
	int ret = UA_ERROR_NONE;
	ua_user_h user_handle;

	msg("ua_user_get_by_account");

	ret = ua_user_get_by_account(g_user_account_str, &user_handle);

	msg(" - ua_user_get_by_account() ret: [0x%X] [%s]",
			ret, uat_get_error_str(ret));

	if (UA_ERROR_NONE == ret) {
		msgb("User Handle [%p]", user_handle);
		ua_user_destroy(g_user_h);
		g_user_h = user_handle;
		update_user_info();
	}
	return RET_SUCCESS;
}

static int run_ua_user_foreach(
	MManager *mm, struct menu_data *menu)
{
	int ret = UA_ERROR_NONE;
	msg("ua_user_foreach_added");

	uat_clear_user_list();

	ret = ua_user_foreach_added(__foreach_registered_user_cb, NULL);

	msg(" - ua_user_foreach_added() ret: [0x%X] [%s]",
				ret, uat_get_error_str(ret));

	return RET_SUCCESS;
}

static int run_ua_user_add_device(
	MManager *mm, struct menu_data *menu)
{
	int ret = UA_ERROR_NONE;

	msg("ua_user_add_device");

	check_if(NULL == g_device_h);

	ret = ua_user_add_device(g_user_h, g_device_h, __device_added_cb, NULL);

	msg(" - ua_user_add_device() ret: [0x%X] [%s]",
			ret, uat_get_error_str(ret));

	return RET_SUCCESS;
}

static int run_ua_user_remove_device(
	MManager *mm, struct menu_data *menu)
{
	int ret = UA_ERROR_NONE;

	msg("ua_user_remove_device");

	check_if(NULL == g_user_h);
	check_if(NULL == g_device_h);

	ret = ua_user_remove_device(g_user_h, g_device_h);

	msg(" - ua_user_remove_device() ret: [0x%X] [%s]",
			ret, uat_get_error_str(ret));

	return RET_SUCCESS;
}

static int run_ua_user_remove_device_by_device_id(
	MManager *mm, struct menu_data *menu)
{
	int ret = UA_ERROR_NONE;
	uat_mac_type_e idx = UAT_MAC_TYPE_MAX;

	msg("ua_user_remove_device_by_device_id");

	if (strlen(g_device_type))
		idx  = (unsigned char)strtol(g_device_type, NULL, 10);

	msgb("idx [%d] mac_type[%d]", idx, uat_convert_idx_to_device_type(idx));

	ret = ua_user_remove_device_by_device_id(g_device_id_str,
			uat_convert_idx_to_device_type(idx));

	msg(" - ua_user_remove_device_by_device_id() ret: [0x%X] [%s]",
			ret, uat_get_error_str(ret));

	return RET_SUCCESS;
}

static int run_ua_user_remove_device_by_mac_address(
	MManager *mm, struct menu_data *menu)
{
	int ret = UA_ERROR_NONE;
	uat_mac_type_e idx = UAT_MAC_TYPE_MAX;

	msg("ua_user_remove_device_by_mac_address");

	if (strlen(g_device_type))
		idx = (unsigned char)strtol(g_device_type, NULL, 10);

	msgb("idx [%d] mac_type[%d]", idx, uat_convert_idx_to_device_type(idx));

	ret = ua_user_remove_device_by_mac_address(g_mac_addr_str);

	msg(" - ua_user_remove_device_by_mac_address() ret: [0x%X] [%s]",
			ret, uat_get_error_str(ret));

	return RET_SUCCESS;
}

static int run_ua_user_foreach_added_devices(MManager *mm, struct menu_data *menu)
{
	int ret = UA_ERROR_NONE;
	ua_user_h user_handle;

	msg("ua_user_foreach_added_devices");

	ret = ua_user_get_by_account(g_user_account_str, &user_handle);
	if (UA_ERROR_NONE == ret) {
		msgb("User Handle [%p]", user_handle);
		ua_user_destroy(g_user_h);
		g_user_h = user_handle;
		update_user_info();
	} else {
		msg(" - ua_user_get_by_account() ret: [0x%X] [%s]",
				ret, uat_get_error_str(ret));
	}

	uat_clear_device_list();

	ret = ua_user_foreach_added_devices(g_user_h,
					_user_foreach_added_device_cb, NULL);

	msg(" - ua_user_foreach_added_devices() ret: [0x%X] [%s]",
			ret, uat_get_error_str(ret));

	return RET_SUCCESS;
}

static int run_select_device(MManager *mm, struct menu_data *menu)
{
	GSList *iter = g_device_list;

	int id = 0;
	int selected_id = 0;

	if (strlen(g_selected_device_idx))
		selected_id = (unsigned char)strtol(g_selected_device_idx, NULL, 10);

	if (selected_id <= 0) {
		msg("Please select device first");
		return RET_SUCCESS;
	}

	while (NULL != iter) {
		GSList *next = iter->next;
		ua_device_h *handle = iter->data;
		if (handle && ++id == selected_id) {
			g_device_h = handle; /* Make selected device as a current one */
			uat_update_device_info(); /* Update device info. */
			msg("[%d] device selected", selected_id);
			return RET_SUCCESS;
		}
		iter = next;
	}

	return RET_SUCCESS;
}

static struct menu_data menu_ua_user_account[] = {
	{ "1", "account",
		NULL, NULL, g_user_account_str },
	{ "2", "run", NULL,
		run_ua_user_set_account, NULL },
	{ NULL, NULL, },
};

static struct menu_data menu_ua_user_name[] = {
	{ "1", "name",
		NULL, NULL, g_user_name_str },
	{ "2", "run", NULL,
		run_ua_user_set_name, NULL },
	{ NULL, NULL, },
};

static struct menu_data menu_ua_user_get_handle_by_account[] = {
	{ "1", "account",
		NULL, NULL, g_user_account_str},
	{ "2", "run", NULL,
		run_ua_user_get_by_account, NULL },
	{ NULL, NULL, },
};

struct menu_data menu_sel_added_user[] = {
	{ "1", "User list", NULL,
		run_ua_user_foreach, g_selected_user_idx},
	{ "2", "Apply", NULL, uat_select_user, NULL },
	{ NULL, NULL, },
};

static struct menu_data menu_ua_rm_dev_by_device_id[] = {
	{ "1", "type (1:BT 2:BLE 3:Wi-Fi 4:P2P)",
		NULL, NULL, g_device_type },
	{ "2", "device_id",
		NULL, NULL, g_device_id_str },
	{ "3", "run", NULL,
		run_ua_user_remove_device_by_device_id, NULL },
	{ NULL, NULL, },
};

static struct menu_data menu_ua_rm_dev_by_addr[] = {
	{ "1", "type (1:BT 2:BLE 3:Wi-Fi 4:P2P)",
		NULL, NULL, g_device_type },
	{ "2", "MAC",
		NULL, NULL, g_mac_addr_str },
	{ "3", "run", NULL,
		run_ua_user_remove_device_by_mac_address, NULL },
	{ NULL, NULL, },
};

struct menu_data menu_ua_user_added_devlist[] = {
	{ "1", "Device list", NULL,
		run_ua_user_foreach_added_devices, g_selected_device_idx},
	{ "2", "Apply", NULL, run_select_device, NULL },
	{ NULL, NULL, },
};

struct menu_data menu_ua_users[] = {
	{ "1", "ua_user_create",
		NULL, run_ua_user_create, NULL },
	{ "2", "ua_user_destroy",
		NULL, run_ua_user_destroy, NULL },
	{ "3", "ua_user_set_account",
		menu_ua_user_account, NULL, g_user_account_str },
	{ "4", "ua_user_set_name",
		menu_ua_user_name, NULL, g_user_name_str },
	{ "5", "ua_user_add",
		NULL, run_ua_user_add, NULL },
	{ "6", "ua_user_remove",
		NULL, run_ua_user_remove, NULL},
	{ "7", "ua_user_update",
		NULL, run_ua_user_update, NULL},
	{ "8", "ua_user_get_default_user",
		NULL, run_ua_user_get_default_user, NULL },
	{ "9", "ua_user_get_handle_by_account",
		menu_ua_user_get_handle_by_account, NULL, NULL },
	{ "10", ANSI_COLOR_LIGHTMAGENTA "ua_user_foreach_added" ANSI_COLOR_NORMAL,
		menu_sel_added_user, NULL, NULL },
	{ "11", ANSI_COLOR_LIGHTGREEN "ua_user_add_device" ANSI_COLOR_NORMAL,
		NULL, run_ua_user_add_device, NULL },
	{ "12", ANSI_COLOR_LIGHTRED "ua_user_remove_device" ANSI_COLOR_NORMAL,
		NULL, run_ua_user_remove_device, NULL },
	{ "13", "ua_user_remove_device_by_device_id",
		menu_ua_rm_dev_by_device_id, NULL, NULL },
	{ "14", "ua_user_remove_device_by_mac_address",
		menu_ua_rm_dev_by_addr, NULL, NULL },
	{ "15", ANSI_COLOR_LIGHTMAGENTA "ua_user_foreach_added_devices" ANSI_COLOR_NORMAL,
		menu_ua_user_added_devlist, NULL, NULL },
	{ NULL, NULL, },
};

struct menu_data menu_sel_user[] = {
	{ "1", "User list", NULL, run_ua_user_foreach, g_selected_user_idx},
	{ "2", "Apply", NULL, uat_select_user , NULL },
	{ NULL, NULL, },
};