MDG_ERROR_PLUGIN_FAIL = TIZEN_ERROR_MDG | 0x08, /**< Plugin failed */
MDG_ERROR_ALREADY_IN_PROGRESS = TIZEN_ERROR_MDG | 0x09, /**< Already in progress */
MDG_ERROR_NOT_STARTED = TIZEN_ERROR_MDG | 0x0A, /**< Not Started */
- MDG_ERROR_ALREADY_INITIALIZED = TIZEN_ERROR_MDG | 0x0B, /**< Already initilized */
MDG_ERROR_UNKNOWN = -999,
} mdg_error_e;
* @since_tizen 5.0
*/
typedef enum {
- MDG_GROUP_TYPE_ERROR = 0, /**< Error */
- MDG_GROUP_TYPE_MINE = 1, /**< Local group */
+ MDG_GROUP_TYPE_LOCAL = 1, /**< Local group */
MDG_GROUP_TYPE_REMOTE = 2, /**< Remote grojp */
} mdg_group_type_e;
typedef void (*mdg_group_find_finish_cb)(int result, void *user_data);
/**
- * @brief Finds group resources in local and the network.
+ * @brief Finds group resources in the network.
* @details This function is find group resources in the network plus my local network.
*
* @since_tizen 5.0
* @retval #MDG_ERROR_INVALID_PARAMETER Invalid parameter
*
* @see mdg_group_create()
- * @see mdg_group_get_found_groups()
*
*/
int mdg_group_find(mdg_h handle, int timeout,
void *user_data);
/**
- * @brief Gets a list of group resources.
- * @details This function retrieves a list of group resources found.
- *
- * @since_tizen 5.0
- * @privlevel public
- * @privilege %http://tizen.org/privilege/internet
- *
- * @param[in] handle The multi device group manager handle
- * @param[in] groups Group resource list
- * @param[out] count Number of groups
- *
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #MDG_ERROR_NONE Successful
- * @retval #MDG_ERROR_INVALID_PARAMETER Invalid parameter
- *
- * @see mdg_group_create()
- * @see mdg_group_find()
- *
- */
-int mdg_group_get_found_groups(mdg_h handle,
- mdg_group_h **groups, int *count);
-
-/**
* @}
*/
* @retval #MDG_ERROR_INVALID_PARAMETER Invalid parameter
*
* @see mdg_group_find()
- * @see mdg_group_get_found_groups()
*
*/
int mdg_group_create(mdg_h handle, char *group_name);
*
* @see mdg_group_invite_device()
*/
-typedef void (*mdg_group_invite_device_result_cb)(int result, void *user_data);
+typedef void (*mdg_group_invite_device_finish_cb)(int result, void *user_data);
/**
* @brief Called after mdg_group_eject_device().
*
* @see mdg_group_ejecct_device()
*/
-typedef void (*mdg_group_eject_device_result_cb)(int result, void *user_data);
+typedef void (*mdg_group_eject_device_finish_cb)(int result, void *user_data);
/**
* @brief Requests to invite a device to the group which local device owns.
*/
int mdg_group_invite_device(mdg_h handle, mdg_group_h group,
mdg_device_h device, char *PIN,
- mdg_group_invite_device_result_cb callback, void *user_data);
+ mdg_group_invite_device_finish_cb callback, void *user_data);
/**
* @brief Requests to expel the device from the group which local device owns.
*
*/
int mdg_group_eject_device(mdg_h handle, mdg_group_h group,
- mdg_device_h device, mdg_group_eject_device_result_cb callback,
+ mdg_device_h device, mdg_group_eject_device_finish_cb callback,
void *user_data);
* @see mdg_group_get_member_devices()
*
*/
-int mdg_request_leave_group (mdg_h handle, mdg_group_h group,
+int mdg_request_leave_group(mdg_h handle, mdg_group_h group,
mdg_request_result_cb cb, void *user_data);
/**
mdg_device_h device, mdg_request_result_cb cb, void *user_data);
/**
- * @brief Requests to delete the group.
- * @details This function deletes a specific group and expels all devices in that group.
- *
- * @since_tizen 5.0
- * @privlevel public
- * @privilege %http://tizen.org/privilege/internet
- *
- * @param[in] handle The multi device group manager handle
- * @param[in] group Group handle
- * @param[in] cb Callback handler to receive the result
- * @param[in] user_data User data pointer
- *
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #MDG_ERROR_NONE Successful
- * @retval #MDG_ERROR_INVALID_PARAMETER Invalid parameter
- *
- * @see mdg_request_create_group()
- * @see mdg_request_invite_device()
- * @see mdg_request_eject_device()
- * @see mdg_request_result_callback()
- * @see mdg_device_send_data()
- *
- */
-int mdg_request_delete_group(mdg_h handle, mdg_group_h group,
- mdg_request_result_cb cb, void *user_data);
-
-/**
* @}
*/
* @see mdg_group_info_get_host_addr()
*
*/
-int mdg_group_info_clone(mdg_group_h dst,
+int mdg_group_info_clone(mdg_group_h *dst,
mdg_group_h src);
/**
*/
int mdg_group_info_destroy(mdg_group_h group);
+int mdg_group_info_get_device_id(mdg_group_h group, char **device_id);
+int mdg_group_info_get_host_addr(mdg_group_h group, char **host_addr);
+
/**
* @brief Gets group type of the group handle.
*
* @see mdg_group_info_get_host_addr()
*
*/
-int mdg_group_info_get_type(mdg_group_h group,
- mdg_group_type_e *type);
-
-/**
- * @brief Gets resource type of the group handle.
- *
- * @since_tizen 5.0
- * @privlevel public
- *
- * @remarks The @a resource_type should be released using free().
- *
- * @param[in] group Group handle
- * @param[out] resource_type Resource type
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #MDG_ERROR_NONE Successful
- * @retval #MDG_ERROR_INVALID_PARAMETER Invalid parameter
- *
- * @see mdg_group_info_create()
- * @see mdg_group_info_clone()
- * @see mdg_group_info_destroy()
- * @see mdg_group_info_get_type()
- * @see mdg_group_info_get_uri_path()
- * @see mdg_group_info_get_name()
- * @see mdg_group_info_get_host_addr()
- *
- */
-int mdg_group_info_get_resource_type(
- mdg_group_h group, char **resource_type);
-
-/**
- * @brief Gets URI path of the group handle.
- *
- * @since_tizen 5.0
- * @privlevel public
- *
- * @remarks The @a uri_path should be released using free().
- *
- * @param[in] group Group handle
- * @param[out] uri_path URI path
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #MDG_ERROR_NONE Successful
- * @retval #MDG_ERROR_INVALID_PARAMETER Invalid parameter
- *
- * @see mdg_group_info_create()
- * @see mdg_group_info_clone()
- * @see mdg_group_info_destroy()
- * @see mdg_group_info_get_type()
- * @see mdg_group_info_get_resource_type()
- * @see mdg_group_info_get_name()
- * @see mdg_group_info_get_host_addr()
- *
- */
-int mdg_group_info_get_uri_path(mdg_group_h group,
- char **uri_path);
+int mdg_group_info_get_type(mdg_group_h group, mdg_group_type_e *type);
/**
* @brief Gets name of the group handle.
* @see mdg_group_info_get_host_addr()
*
*/
-int mdg_group_info_get_name(mdg_group_h group,
- char **name);
-
-/**
- * @brief Gets host address of the group handle.
- *
- * @since_tizen 5.0
- * @privlevel public
- *
- * @remarks The @a host_addr should be released using free().
- *
- * @param[in] group Group handle
- * @param[out] host_addr Host address of the group
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #MDG_ERROR_NONE Successful
- * @retval #MDG_ERROR_INVALID_PARAMETER Invalid parameter
- *
- * @see mdg_group_info_create()
- * @see mdg_group_info_clone()
- * @see mdg_group_info_destroy()
- * @see mdg_group_info_get_type()
- * @see mdg_group_info_get_resource_type()
- * @see mdg_group_info_get_name()
- * @see mdg_group_info_get_uri_path()
- *
- */
-int mdg_group_info_get_host_addr(mdg_group_h group,
- char **host_addr);
+int mdg_group_info_get_name(mdg_group_h group, char **name);
/**
* @}
* @since_tizen 5.0
*/
typedef enum {
- MDG_DEVICE_TYPE_ERROR = 0, /**< Error */
MDG_DEVICE_TYPE_LOCAL = 1, /**< Local device */
MDG_DEVICE_TYPE_REMOTE = 2, /**< Remote device */
} mdg_device_type_e;
/**
- * @brief Device Status.
- *
- * @since_tizen 5.0
- */
-typedef enum {
- MDG_DEVICE_ADDED = 0, /**< Device Added */
- MDG_DEVICE_REMOVED = 1, /**< Device Removed */
-} mdg_device_status_e;
-
-/**
* @brief Called after mdg_device_find().
* @details This function can receive a device found.
*
*
* @see mdg_device_send_data()
*/
-typedef void (*mdg_device_send_data_finish_cb)(int result, char *resp_data,
- void *user_data);
-
-/**
- * @brief Callback function pointer to be regsitered after enabling device
- * monitor
- *
- * @since_tizen 5.0
- * @privlevel public
- * @privilege %http://tizen.org/privilege/internet
- *
- * @remarks The @a uuid, @arg should not be released.
- * @remarks The @a uuid, @arg can be used only in the callback. To use outside, make a copy.
- * @remarks The @a group_name, @arg should not be released.
- * @remarks The @a group_name, @arg can be used only in the callback. To use outside, make a copy.
- *
- * @param[out] uuid Device ID
- * @param[out] group_name Group name
- * @param[out] status Device Status
- * @param[out] user_data User data pointer
- *
- * @pre The callback must be registered with mdg_request_result_callback()
- *
- * @see mdg_device_monitor_start()
- */
-typedef void (*mdg_device_monitor_result_cb)(char *uuid, char *group_name,
- mdg_device_status_e status, void *user_data);
+typedef void (*mdg_device_send_data_finish_cb)(int result, void *user_data);
/**
- * @brief Finds candidate devices to include my groups in the network.
- * @details This function will search for candidate devices that can be included in local group.
+ * @brief Gets my local device handle.
+ * @details This function returns the local device information handle.
*
* @since_tizen 5.0
- * @privlevel public
- * @privilege %http://tizen.org/privilege/internet
- *
- * @param[in] handle The multi device group manager handle
- * @param[in] timeout Time to find
- * @param[in] found_cb Callback handler to retrieve the found device
- * @param[in] finish_cb Callback handler to know finding process finished
- * @param[in] user_data User data poiter
- *
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #MDG_ERROR_NONE Successful
- * @retval #MDG_ERROR_INVALID_PARAMETER Invalid parameter
- *
- * @see mdg_device_get_found_devices()
- *
- */
-int mdg_device_find(mdg_h handle, int timeout,
- mdg_device_found_cb found_cb, mdg_device_find_finish_cb finish_cb,
- void *user_data);
-
-/**
- * @brief Gets a list of candidate devices to can be included my group.
- * @details This function retrieves a list of multiple owner enabled devices found.
*
- * @since_tizen 5.0
- * @privlevel public
- * @privilege %http://tizen.org/privilege/internet
+ * @remarks The @a target should be released using mdg_device_info_destroy().
*
* @param[in] handle The multi device group manager handle
- * @param[in] devices Device list
- * @param[in] count Number of devices
- *
+ * @param[in] device Local device handle
*
* @return 0 on success, otherwise a negative error value.
* @retval #MDG_ERROR_NONE Successful
* @retval #MDG_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MDG_ERROR_NO_DATA No data
*
- * @see mdg_device_find_mowned_device()
+ * @see mdg_device_info_get_my_uuid()
*
*/
-int mdg_device_get_found_devices(mdg_h handle,
- mdg_device_h **devices, int *count);
+int mdg_device_get_local_device(mdg_h handle,
+ mdg_device_h *device);
/**
- * @brief Finds my owned devices in the network.
- * @details This function looks up devices on your network that are registered as multiple
- * owners.
+ * @brief Finds candidate devices to include my groups in the network.
+ * @details This function will search for candidate devices that can be included in local group.
*
* @since_tizen 5.0
* @privlevel public
* @retval #MDG_ERROR_NONE Successful
* @retval #MDG_ERROR_INVALID_PARAMETER Invalid parameter
*
- * @see mdg_device_get_found_mowned_devices()
- *
*/
-int mdg_device_find_mowned_device(mdg_h handle, int timeout,
+int mdg_device_find(mdg_h handle, int timeout, bool is_invited,
mdg_device_found_cb found_cb, mdg_device_find_finish_cb finish_cb,
void *user_data);
-/**
- * @brief Gets a list of discovered owned devices.
- * @details This function retrieves a list of my owned devices found.
- *
- * @since_tizen 5.0
- * @privlevel public
- * @privilege %http://tizen.org/privilege/internet
- *
- * @param[in] handle The multi device group manager handle
- * @param[in] devices Device list
- * @param[in] count Number of devices
- *
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #MDG_ERROR_NONE Successful
- * @retval #MDG_ERROR_INVALID_PARAMETER Invalid parameter
- *
- * @see mdg_device_find_mowned_device()
- *
- */
-int mdg_device_get_found_mowned_devices(mdg_h handle,
- mdg_device_h **devices, int *count);
+typedef void (*mdg_channel_cb)(int result, mdg_device_h device, char *channel_id,
+ unsigned char *arg, int len, void *user_data);
+
+/* Server Side */
+int mdg_device_regist_channel(mdg_h handle, char *channel_id,
+ mdg_channel_cb channel_cb, void *user_data);
+
+int mdg_device_unregist_channel(mdg_h handle, char *channel_id);
+
+/* Client Side */
+//int mdg_device_get_channels(mdg_h handle, mdg_device_h device,
+// mdg_device_get_channels_cb get_channels_cb, void *user_data);
/**
* @brief Sends data to the remote device.
* @see mdg_request_result_callback()
*
*/
-int mdg_device_send_data(mdg_h handle, mdg_device_h device,
+int mdg_device_send_data(mdg_h handle, mdg_device_h device, char *channel_id,
unsigned char *data, int len,
mdg_device_send_data_finish_cb finish_cb, void *user_data);
/**
- * @brief Starts monitoring peers in the network.
- *
- * @since_tizen 5.0
- * @privlevel public
- * @privilege %http://tizen.org/privilege/internet
- *
- * @param[in] handle The multi device group manager handle
- * @param[in] cb Callback to be called when receiving keep alive message from peers
- * @param[in] user_data User data pointer
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #MDG_ERROR_NONE Successful
- * @retval #MDG_ERROR_INVALID_PARAMETER Invalid parameter
- *
- * @see mdg_device_monitor_stop()
- *
- */
-int mdg_device_monitor_start(mdg_h handle, mdg_device_monitor_result_cb cb,
- void *user_data);
-
-/**
- * @brief Stops monitoring peers in the network.
- *
- * @since_tizen 5.0
- * @privlevel public
- * @privilege %http://tizen.org/privilege/internet
- *
- * @param[in] handle The multi device group manager handle
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #MDG_ERROR_NONE Successful
- * @retval #MDG_ERROR_INVALID_PARAMETER Invalid parameter
- *
- * @see mdg_device_monitor_start()
- *
- */
-int mdg_device_monitor_stop(mdg_h handle);
-
-
-/**
* @}
*/
*/
/**
- * @brief Gets my local device ID.
- * @details This function returns current UUID of local device.
- *
- * @since_tizen 5.0
- *
- * @remarks The @a uuid should not be released.
- * @remarks The @a uuid can be used only in the callback. To use outside, make a copy.
- *
- * @param[in] handle The multi device group manager handle
- * @param[out] uuid Local device UUID
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #MDG_ERROR_NONE Successful
- * @retval #MDG_ERROR_INVALID_PARAMETER Invalid parameter
- *
- * @see mdg_device_info_get_my_device()
- *
- */
-
-int mdg_device_info_get_my_uuid(mdg_h handle, char **uuid);
-
-/**
- * @brief Gets my local device handle.
- * @details This function returns the local device information handle.
- *
- * @since_tizen 5.0
- *
- * @remarks The @a target should be released using mdg_device_info_destroy().
- *
- * @param[in] handle The multi device group manager handle
- * @param[in] device Local device handle
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #MDG_ERROR_NONE Successful
- * @retval #MDG_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #MDG_ERROR_NO_DATA No data
- *
- * @see mdg_device_info_get_my_uuid()
- *
- */
-int mdg_device_info_get_my_device(mdg_h handle,
- mdg_device_h *device);
-
-/**
* @brief Clones the device handle.
*
* @since_tizen 5.0
* @see mdg_device_info_get_model_name()
*
*/
-int mdg_device_info_clone(mdg_device_h target,
+int mdg_device_info_clone(mdg_device_h *target,
mdg_device_h source);
/**
* @see mdg_device_info_get_model_name()
*
*/
-int mdg_device_info_get_ip(mdg_device_h device, char **ip);
+int mdg_device_info_get_addr(mdg_device_h device, char **addr);
+int mdg_device_info_get_port(mdg_device_h device, int *port);
+int mdg_device_info_get_secure_port(mdg_device_h device, int *secure_port);
/**
- * @brief Gets device type of the device handle.
+ * @brief Gets model name of the device handle.
*
* @since_tizen 5.0
* @privlevel public
*
- * @remarks The @a device_type should be released using free().
+ * @remarks The @a model_name should be released using free().
*
* @param[in] device Device handle
- * @param[out] device_type Device type
+ * @param[out] model_name Model name
*
* @return 0 on success, otherwise a negative error value.
* @retval #MDG_ERROR_NONE Successful
* @see mdg_device_info_destroy()
* @see mdg_device_info_get_device_id()
* @see mdg_device_info_get_ip()
- * @see mdg_device_info_get_model_name()
+ * @see mdg_device_info_get_device_type()
*
*/
-int mdg_device_info_get_device_type(mdg_device_h device,
- mdg_device_type_e *device_type);
+int mdg_device_info_get_model_name(mdg_device_h device, char **model_name);
+int mdg_device_info_get_device_name(mdg_device_h device, char **device_name);
+int mdg_device_info_get_platform_ver(mdg_device_h device, char **platform_ver);
+int mdg_device_info_get_vendor_id(mdg_device_h device, char **vendor_id);
+int mdg_device_info_get_profile(mdg_device_h device, char **profile);
+int mdg_device_info_is_invited(mdg_device_h device, bool *is_invited);
/**
- * @brief Gets model name of the device handle.
+ * @brief Gets device type of the device handle.
*
* @since_tizen 5.0
* @privlevel public
*
- * @remarks The @a model_name should be released using free().
+ * @remarks The @a device_type should be released using free().
*
* @param[in] device Device handle
- * @param[out] model_name Model name
+ * @param[out] device_type Device type
*
* @return 0 on success, otherwise a negative error value.
* @retval #MDG_ERROR_NONE Successful
* @see mdg_device_info_destroy()
* @see mdg_device_info_get_device_id()
* @see mdg_device_info_get_ip()
- * @see mdg_device_info_get_device_type()
+ * @see mdg_device_info_get_model_name()
*
*/
-int mdg_device_info_get_model_name(mdg_device_h device,
- char **model_name);
+int mdg_device_info_get_type(mdg_device_h device,
+ mdg_device_type_e *device_type);
/**
* @}
#include <mdg_gdbus.h>
#include <mdg_private.h>
-/**
- * Companion Manager CAPI
- */
-
-static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; /**< Mutex for dbus */
-
-#define MDG_LOCK \
-do { \
- pthread_mutex_lock(&mutex); \
-} while (0);
-
-#define MDG_UNLOCK \
-do { \
- pthread_mutex_unlock(&mutex); \
-} while (0);
-
-int ref_count = 0; /**< How many clients are alive */
-bool __is_initialized = false; /**< Initialize or not */
+GSList *handle_list = NULL;
EXPORT_API int mdg_initialize(mdg_h *handle)
{
}
*handle = mdg_manager;
- if (__is_initialized) {
- /* LCOV_EXCL_START */
- _DBG("Already initialized");
- return MDG_ERROR_ALREADY_INITIALIZED;
- /* LCOV_EXCL_STOP */
- }
-
- MDG_LOCK;
ret = gdbus_initialize(*handle);
- __is_initialized = true;
- MDG_UNLOCK;
- ref_count++;
+
+ handle_list = g_slist_prepend(handle_list, *handle);
_END();
int ret = MDG_ERROR_NONE;
CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
+ CHECK_HANDLE_IS_VALID(handle);
_BEGIN();
- MDG_LOCK;
+ handle_list = g_slist_remove(handle_list, handle);
- if (0 > --ref_count) {
- /* LCOV_EXCL_START */
- _DBG("all connections closed\n");
- ref_count = 0;
- MDG_UNLOCK;
- return ret;
- /* LCOV_EXCL_STOP */
- }
-
- if (__is_initialized == true && ref_count == 0) {
- ret = gdbus_deinitialize(handle);
- __is_initialized = false;
- }
-
- MDG_UNLOCK;
+ ret = gdbus_deinitialize(handle);
_END();
return ret;
-
}
EXPORT_API int mdg_group_create(mdg_h handle, char *group_name)
mdg_manager_s *_handle = handle;
mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
- if (0 == strlen(group_name))
- return MDG_ERROR_INVALID_PARAMETER;
+ CHECK_HANDLE_IS_VALID(handle);
/* create group to daemon using gdbus */
group_call_create_sync(_handle->group_proxy, group_name, &ret, NULL, &error);
mdg_check_null_ret("group", group);
- if (group->uri_path) {
- g_free(group->uri_path);
- group->uri_path = NULL;
- }
if (group->device_id) {
g_free(group->device_id);
group->device_id = NULL;
g_free(group->group_name);
group->group_name = NULL;
}
- if (group->host_addr) {
- g_free(group->host_addr);
- group->host_addr = NULL;
- }
- if (group->resource_type) {
- g_free(group->resource_type);
- group->resource_type = NULL;
- }
+
g_free(group);
group = NULL;
}
mdg_manager_s *_handle = handle;
mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
+ CHECK_HANDLE_IS_VALID(handle);
_handle->group_found_cb.found_cb = found_cb;
_handle->group_find_finish_cb.finish_cb = finish_cb;
/* get groups from daemon using gdbus */
group_call_find_sync(_handle->group_proxy, timeout, &ret, NULL, &error);
+ if (error) {
+ _ERR("Failed DBus call [%s]", error->message);
+ g_error_free(error);
+ ret = MDG_ERROR_IO_ERROR;
+ }
return ret;
}
-EXPORT_API int mdg_group_get_found_groups(mdg_h handle,
- mdg_group_h **groups, int *count)
+EXPORT_API int mdg_device_find(mdg_h handle, int timeout, bool is_invited,
+ mdg_device_found_cb found_cb, mdg_device_find_finish_cb finish_cb,
+ void *user_data)
{
int ret = MDG_ERROR_NONE;
- GVariant *va = NULL;
GError *error = NULL;
CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
mdg_manager_s *_handle = handle;
mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
+ CHECK_HANDLE_IS_VALID(handle);
+
+ _handle->device_found_cb.found_cb = found_cb;
+ _handle->device_found_cb.user_data = user_data;
+ _handle->device_find_finish_cb.finish_cb = finish_cb;
+ _handle->device_find_finish_cb.user_data = user_data;
/* get groups from daemon using gdbus */
- group_call_get_found_groups_sync(_handle->group_proxy, &ret, &va, NULL, &error);
- *count = g_variant_n_children(va);
-
- _DBG("get found groups : %d", *count);
-
- /* LCOV_EXCL_START */
- if (*count > 0) {
- GVariantIter *iter = NULL, *iter_row = NULL;
- GVariant *key_value;
- const gchar *key;
- guint i = 0;
-
- *groups = g_new0(mdg_group_h, *count);
-
- g_variant_get(va, "aa{sv}", &iter);
- while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
-
- char *uri_path = NULL;
- char *device_id = NULL;
- char *group_name = NULL;
- char *host_addr = NULL;
- char *resource_type = NULL;
-
- mdg_group_s *group = NULL;
- mdg_group_type_e type = MDG_GROUP_TYPE_ERROR;
-
- while (g_variant_iter_loop(iter_row, "{sv}", &key, &key_value)) {
- if (g_strcmp0(key, "URI") == 0)
- uri_path = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "DeviceID") == 0)
- device_id = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "GroupName") == 0)
- group_name = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "HostAddress") == 0)
- host_addr = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "GroupDeviceType") == 0)
- resource_type = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "GroupType") == 0)
- type = g_variant_get_int32(key_value);
- }
- g_variant_iter_free(iter_row);
-
- _INFO("DeviceID %s GroupName %s HostAddress %s GroupDeviceType %s",
- device_id, group_name, host_addr, resource_type);
-
- group = create_group_handle(uri_path,
- device_id, group_name, host_addr, resource_type, type);
-
- (*groups)[i++] = (mdg_group_h)group;
- }
- g_variant_iter_free(iter);
+ group_call_find_device_sync(_handle->group_proxy, timeout, is_invited, &ret, NULL, &error);
+ if (error) {
+ _ERR("Failed DBus call [%s]", error->message);
+ g_error_free(error);
+ ret = MDG_ERROR_IO_ERROR;
}
- /* LCOV_EXCL_STOP */
- g_variant_unref(va);
return ret;
}
-EXPORT_API int mdg_device_find(mdg_h handle, int timeout,
- mdg_device_found_cb found_cb, mdg_device_find_finish_cb finish_cb,
- void *user_data)
+typedef struct _channel_cb_s {
+ char *channel_id;
+ mdg_channel_cb cb;
+ void *user_data;
+} channel_cb_s;
+
+/**
+ * Companion Manager CAPI
+ */
+int __add_channel_cb(mdg_manager_s *handle, char *channel_id, mdg_channel_cb channel_cb, void *user_data)
+{
+ channel_cb_s *channel_s;
+
+ GSList *l1, *l2;
+ for (l1 = handle_list; l1 != NULL; l1 = l1->next) {
+ mdg_manager_s *tmp_handle = (mdg_manager_s *)l1->data;
+ for (l2 = tmp_handle->channel_cb_list; l2 != NULL; l2 = l2->next) {
+ channel_cb_s *tmp_channel = (channel_cb_s *)l2->data;
+ if (g_strcmp0(tmp_channel->channel_id, channel_id) == 0)
+ return MDG_ERROR_UNKNOWN;
+ }
+ }
+
+ channel_s = g_try_new0(channel_cb_s, 1);
+ if (channel_s == NULL)
+ return MDG_ERROR_OUT_OF_MEMORY;
+
+ channel_s->channel_id = g_strdup(channel_id);
+ channel_s->cb = channel_cb;
+ channel_s->user_data = user_data;
+
+ handle->channel_cb_list = g_slist_prepend(handle->channel_cb_list, channel_s);
+
+ return 0;
+}
+
+EXPORT_API int mdg_device_regist_channel(mdg_h handle, char *channel_id,
+ mdg_channel_cb channel_cb, void *user_data)
{
int ret = MDG_ERROR_NONE;
GError *error = NULL;
mdg_manager_s *_handle = handle;
mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
+ CHECK_HANDLE_IS_VALID(_handle);
- _handle->device_found_cb.found_cb = found_cb;
- _handle->device_found_cb.user_data = user_data;
- _handle->device_find_finish_cb.finish_cb = finish_cb;
- _handle->device_find_finish_cb.user_data = user_data;
+ _BEGIN();
- /* get groups from daemon using gdbus */
- group_call_device_find_sync(_handle->group_proxy, timeout, &ret, NULL, &error);
+ group_call_regist_channel_sync(_handle->group_proxy, channel_id, &ret, NULL, &error);
if (error) {
_ERR("Failed DBus call [%s]", error->message);
g_error_free(error);
ret = MDG_ERROR_IO_ERROR;
}
+ if (ret == MDG_ERROR_NONE)
+ ret = __add_channel_cb(handle, channel_id, channel_cb, user_data);
+
+ _END();
+
return ret;
}
-EXPORT_API int mdg_device_find_mowned_device(mdg_h handle,
- int timeout, mdg_device_found_cb found_cb,
- mdg_device_find_finish_cb finish_cb, void *user_data)
+EXPORT_API int mdg_device_unregist_channel(mdg_h handle, char *channel_id)
{
int ret = MDG_ERROR_NONE;
+ bool is_exist = false;
GError *error = NULL;
CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
mdg_manager_s *_handle = handle;
mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
+ CHECK_HANDLE_IS_VALID(handle);
- _handle->mowned_device_found_cb.found_cb = found_cb;
- _handle->mowned_device_found_cb.user_data = user_data;
- _handle->mowned_device_find_finish_cb.finish_cb = finish_cb;
- _handle->mowned_device_find_finish_cb.user_data = user_data;
+ _BEGIN();
- /* get groups from daemon using gdbus */
- group_call_find_mowned_devices_sync(_handle->group_proxy, timeout, &ret, NULL, &error);
- if (error) {
- _ERR("Failed DBus call [%s]", error->message);
- g_error_free(error);
- ret = MDG_ERROR_IO_ERROR;
+ GSList *l;
+ for (l = _handle->channel_cb_list; l != NULL; l = l->next) {
+ channel_cb_s *tmp_channel = (channel_cb_s *)l->data;
+ if (g_strcmp0(tmp_channel->channel_id, channel_id) == 0) {
+ g_free(tmp_channel->channel_id);
+ _handle->channel_cb_list = g_slist_remove_link(_handle->channel_cb_list, l);
+ is_exist = true;
+ break;
+ }
+ }
+
+ if (is_exist == false)
+ ret = MDG_ERROR_UNKNOWN;
+
+ if (ret == MDG_ERROR_NONE) {
+ group_call_unregist_channel_sync(_handle->group_proxy, channel_id, &ret, NULL, &error);
+ if (error) {
+ _ERR("Failed DBus call [%s]", error->message);
+ g_error_free(error);
+ ret = MDG_ERROR_IO_ERROR;
+ }
}
+ _END();
+
return ret;
}
EXPORT_API int mdg_device_send_data(mdg_h handle,
- mdg_device_h device, unsigned char *data, int len,
+ mdg_device_h device, char *channel_id, unsigned char *data, int len,
mdg_device_send_data_finish_cb finish_cb, void *user_data)
{
int ret = MDG_ERROR_NONE;
mdg_manager_s *_handle = handle;
mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
+ CHECK_HANDLE_IS_VALID(handle);
mdg_device_s *dev = (mdg_device_s *)device;
mdg_check_null_ret_error("dev", dev, MDG_ERROR_INVALID_PARAMETER);
_handle->send_data_finish_cb.finish_cb = finish_cb;
_handle->send_data_finish_cb.user_data = user_data;
- group_call_send_data_sync(_handle->group_proxy, dev->device_id, dev->ip,
- dev->sec_port, params, &ret, NULL, &error);
+ group_call_send_data_sync(_handle->group_proxy, dev->device_id, dev->addr,
+ dev->secure_port, params, &ret, NULL, &error);
if (error) {
_ERR("Failed DBus call [%s]", error->message);
g_error_free(error);
return ret;
}
-/* mdg_request_join_group : join to remote group. if group handle is my daemon's,
- then the api return fail error */
-EXPORT_API int mdg_device_get_found_devices(mdg_h handle,
- mdg_device_h **devices, int *count)
-{
- int ret = MDG_ERROR_NONE;
- int num = 0;
- GVariant *va = NULL;
- GError *error = NULL;
-
- CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
-
- mdg_manager_s *_handle = handle;
- mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
-
- /* get groups from daemon using gdbus */
- group_call_get_remote_device_sync(_handle->group_proxy, &num, &va, NULL, &error);
- if (error) {
- _ERR("Failed DBus call [%s]", error->message);
- g_error_free(error);
- ret = MDG_ERROR_IO_ERROR;
- }
- /* *count = g_variant_n_children(va); */
- *count = num;
-
- _DBG("get found devices : %d", *count);
- /* LCOV_EXCL_START */
- if (*count > 0) {
- GVariantIter *iter = NULL, *iter_row = NULL;
- GVariant *key_value = NULL;
- const gchar *key;
- guint i = 0;
-
- *devices = g_new0(mdg_group_h, *count);
-
- g_variant_get(va, "aa{sv}", &iter);
- while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
- char *deviceid = NULL;
- char *addr = NULL;
- int device_type = MDG_DEVICE_TYPE_ERROR;
- int port;
- int sec_port;
- mdg_device_s *device = NULL;
- char *model_name = NULL;
- char *device_name = NULL;
- char *platform_ver = NULL;
- char *vendor_id = NULL;
- char *profile = NULL;
-
- while (g_variant_iter_loop(iter_row, "{sv}", &key, &key_value)) {
- if (g_strcmp0(key, "DeviceID") == 0)
- deviceid = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "Address") == 0)
- addr = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "DeviceType") == 0)
- device_type = g_variant_get_uint16(key_value);
- else if (g_strcmp0(key, "Port") == 0)
- port = g_variant_get_uint16(key_value);
- else if (g_strcmp0(key, "SecurePort") == 0)
- sec_port = g_variant_get_uint16(key_value);
- else if (g_strcmp0(key, "ModelName") == 0)
- model_name = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "DeviceName") == 0)
- device_name = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "PlatformVer") == 0)
- platform_ver = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "VendorID") == 0)
- vendor_id = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "Profile") == 0)
- profile = (char *)g_variant_get_string(key_value, NULL);
- }
- g_variant_iter_free(iter_row);
-
- device = create_device_handle(deviceid, addr, device_type, port, sec_port,
- model_name, device_name, platform_ver, vendor_id, profile);
-
- (*devices)[i++] = (mdg_device_h)device;
- }
- g_variant_iter_free(iter);
- }
- /* LCOV_EXCL_STOP */
- g_variant_unref(va);
-
- return ret;
-}
-
-EXPORT_API int mdg_device_get_found_mowned_devices(
- mdg_h handle, mdg_device_h **devices, int *count)
-{
- int ret = MDG_ERROR_NONE;
- int num = 0;
- GVariant *va = NULL;
- GError *error = NULL;
-
- CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
-
- mdg_manager_s *_handle = handle;
- mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
-
- /* get groups from daemon using gdbus */
- group_call_get_mowned_device_sync(_handle->group_proxy, &num, &va, NULL, &error);
- if (error) {
- _ERR("Failed DBus call [%s]", error->message);
- g_error_free(error);
- ret = MDG_ERROR_IO_ERROR;
- }
- /* *count = g_variant_n_children(va); */
- *count = num;
-
- _INFO("get found mowned devices : %d", *count);
-
- /* LCOV_EXCL_START */
- if (*count > 0) {
- GVariantIter *iter = NULL, *iter_row = NULL;
- GVariant *key_value;
- const gchar *key;
- guint i = 0;
-
- *devices = g_new0(mdg_device_h, *count);
-
- g_variant_get(va, "aa{sv}", &iter);
- while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
- char *deviceid = NULL;
- char *addr = NULL;
- int device_type = MDG_DEVICE_TYPE_ERROR;
- int port;
- int sec_port;
- mdg_device_s *device = NULL;
- char *model_name = NULL;
- char *device_name = NULL;
- char *platform_ver = NULL;
- char *vendor_id = NULL;
- char *profile = NULL;
-
- while (g_variant_iter_loop(iter_row, "{sv}", &key, &key_value)) {
- if (g_strcmp0(key, "DeviceID") == 0)
- deviceid = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "Address") == 0)
- addr = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "DeviceType") == 0)
- device_type = g_variant_get_uint16(key_value);
- else if (g_strcmp0(key, "Port") == 0)
- port = g_variant_get_uint16(key_value);
- else if (g_strcmp0(key, "SecurePort") == 0)
- sec_port = g_variant_get_uint16(key_value);
- else if (g_strcmp0(key, "ModelName") == 0)
- model_name = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "DeviceName") == 0)
- device_name = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "PlatformVer") == 0)
- platform_ver = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "VendorID") == 0)
- vendor_id = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "Profile") == 0)
- profile = (char *)g_variant_get_string(key_value, NULL);
- }
- g_variant_iter_free(iter_row);
-
- device = create_device_handle(deviceid, addr, device_type, port, sec_port,
- model_name, device_name, platform_ver, vendor_id, profile);
-
- (*devices)[i++] = (mdg_device_h)device;
- }
- g_variant_iter_free(iter);
- }
- /* LCOV_EXCL_STOP */
- g_variant_unref(va);
-
- return ret;
-}
-
-EXPORT_API int mdg_device_info_get_my_uuid(mdg_h handle, char **uuid)
-{
- int ret = 0;
- GError *error = NULL;
-
- CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
-
- mdg_manager_s *_handle = handle;
- mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
-
- group_call_get_my_uuid_sync(_handle->group_proxy, uuid, NULL, &error);
- if (error) {
- _ERR("Failed DBus call [%s]", error->message);
- g_error_free(error);
- ret = MDG_ERROR_IO_ERROR;
- }
-
- return ret;
-}
-
-EXPORT_API int mdg_device_info_get_my_device(mdg_h handle,
+EXPORT_API int mdg_device_get_local_device(mdg_h handle,
mdg_device_h *device)
{
int ret = MDG_ERROR_NONE;
GError *error = NULL;
GVariant *va = NULL;
- GVariantIter *iter = NULL;
- const gchar *key;
- GVariant *key_value = NULL;
- char *deviceid = NULL;
- char *addr = NULL;
- int device_type = MDG_DEVICE_TYPE_ERROR;
- int port = -1;
- int sec_port = -1;
- char *model_name = NULL;
- char *device_name = NULL;
- char *platform_ver = NULL;
- char *vendor_id = NULL;
- char *profile = NULL;
CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
mdg_manager_s *_handle = handle;
mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
+ CHECK_HANDLE_IS_VALID(handle);
- group_call_get_my_mowned_device_sync(_handle->group_proxy, &va, NULL, &error);
+ group_call_get_local_device_sync(_handle->group_proxy, &va, NULL, &error);
if (error) {
_ERR("Failed DBus call [%s]", error->message);
g_error_free(error);
ret = MDG_ERROR_IO_ERROR;
}
- g_variant_get(va, "a{sv}", &iter);
- /* LCOV_EXCL_START */
- while (g_variant_iter_loop(iter, "{sv}", &key, &key_value)) {
- if (g_strcmp0(key, "DeviceID") == 0)
- deviceid = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "Address") == 0)
- addr = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "DeviceType") == 0)
- device_type = g_variant_get_uint16(key_value);
- else if (g_strcmp0(key, "Port") == 0)
- port = g_variant_get_uint16(key_value);
- else if (g_strcmp0(key, "SecurePort") == 0)
- sec_port = g_variant_get_uint16(key_value);
- else if (g_strcmp0(key, "ModelName") == 0)
- model_name = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "DeviceName") == 0)
- device_name = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "PlatformVer") == 0)
- platform_ver = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "VendorID") == 0)
- vendor_id = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "Profile") == 0)
- profile = (char *)g_variant_get_string(key_value, NULL);
- }
-
- if (deviceid == NULL || addr == NULL)
- return MDG_ERROR_NO_DATA;
- /* LCOV_EXCL_STOP */
-
- *device = (mdg_device_h)create_device_handle(deviceid, addr, device_type, port, sec_port,
- model_name, device_name, platform_ver, vendor_id, profile);
-
- g_variant_iter_free(iter);
-
- return ret;
-}
-
-/* group merge */
-EXPORT_API int mdg_group_merge(mdg_h hadnle,
- mdg_group_h dest_group, mdg_group_h src_group)
-{
- int ret = MDG_ERROR_NONE;
-
- CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
-
- NOTUSED(dest_group);
- NOTUSED(src_group);
+ *device = mdg_get_device_from_variant(va);
return ret;
}
mdg_manager_s *_handle = handle;
mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
+ CHECK_HANDLE_IS_VALID(handle);
mdg_group_s *grp = (mdg_group_s *)group;
mdg_check_null_ret_error("grp", grp, MDG_ERROR_INVALID_PARAMETER);
- group_call_delete_sync(_handle->group_proxy, grp->group_name, &ret, NULL,
- &error);
- if (error) {
- _ERR("Failed DBus call [%s]", error->message);
- g_error_free(error);
- ret = MDG_ERROR_IO_ERROR;
- }
+ /* create group to daemon using gdbus */
+ group_call_delete_sync(_handle->group_proxy, grp->group_name, &ret, NULL, &error);
return ret;
}
EXPORT_API int mdg_group_invite_device(mdg_h handle,
mdg_group_h group, mdg_device_h device, char *PIN,
- mdg_group_invite_device_result_cb result_cb, void *user_data)
+ mdg_group_invite_device_finish_cb finish_cb, void *user_data)
{
int ret = MDG_ERROR_NONE;
GError *error = NULL;
mdg_manager_s *_handle = handle;
mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
+ CHECK_HANDLE_IS_VALID(handle);
mdg_group_s *grp = (mdg_group_s *)group;
mdg_check_null_ret_error("grp", grp, MDG_ERROR_INVALID_PARAMETER);
mdg_device_s *dev = (mdg_device_s *)device;
mdg_check_null_ret_error("dev", dev, MDG_ERROR_INVALID_PARAMETER);
- _handle->device_invite_result_cb.result_cb = result_cb;
- _handle->device_invite_result_cb.user_data = user_data;
+ _handle->device_invite_finish_cb.finish_cb = finish_cb;
+ _handle->device_invite_finish_cb.user_data = user_data;
- /* Now, for the sake of convenience, we change 'mdg_group_invite_device' to
- 'group_call_invite_sync'. */
-#if 0
- group_call_device_invite_sync(group_proxy, dev->device_id, PIN, &ret, NULL, &error);
-#else
- group_call_invite_sync(_handle->group_proxy, grp->group_name, dev->device_id, PIN,
+ group_call_invite_device_sync(_handle->group_proxy, grp->group_name, dev->device_id, PIN,
&ret, NULL, &error);
-#endif
return ret;
}
EXPORT_API int mdg_group_eject_device(mdg_h handle,
mdg_group_h group, mdg_device_h device,
- mdg_group_eject_device_result_cb result_cb, void *user_data)
+ mdg_group_eject_device_finish_cb finish_cb, void *user_data)
{
int ret = MDG_ERROR_NONE;
GError *error = NULL;
mdg_manager_s *_handle = handle;
mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
+ CHECK_HANDLE_IS_VALID(handle);
mdg_device_s *dev = (mdg_device_s *)device;
mdg_check_null_ret_error("dev", dev, MDG_ERROR_INVALID_PARAMETER);
mdg_group_s *grp = (mdg_group_s *)group;
mdg_check_null_ret_error("grp", grp, MDG_ERROR_INVALID_PARAMETER);
- _handle->device_eject_result_cb.result_cb = result_cb;
- _handle->device_eject_result_cb.user_data = user_data;
+ _handle->device_eject_finish_cb.finish_cb = finish_cb;
+ _handle->device_eject_finish_cb.user_data = user_data;
- /* Now, for the sake of convenience, we change 'mdg_device_eject' to
- 'group_call_eject_sync'. */
-#if 0
- group_call_device_eject_sync(group_proxy, dev->device_id, &ret, NULL, &error);
-#else
- group_call_eject_sync(_handle->group_proxy, grp->group_name, dev->device_id, &ret,
+ group_call_eject_device_sync(_handle->group_proxy, grp->group_name, dev->device_id, &ret,
NULL, &error);
-#endif
return ret;
}
return ret;
}
-EXPORT_API int mdg_group_info_clone(mdg_group_h target,
+EXPORT_API int mdg_group_info_clone(mdg_group_h *target,
mdg_group_h source)
{
int ret = MDG_ERROR_NONE;
CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
- mdg_group_s * dst = (mdg_group_s *)target;
- mdg_check_null_ret_error("target", target, MDG_ERROR_INVALID_PARAMETER);
-
mdg_group_s * src = (mdg_group_s *)source;
mdg_check_null_ret_error("source", source, MDG_ERROR_INVALID_PARAMETER);
- ret = mdg_group_info_create(&target);
- if (MDG_ERROR_NONE != ret) {
- /* LCOV_EXCL_START */
- _ERR("mdg_group_info_create() Failed(%d)", ret);
- return ret;
- /* LCOV_EXCL_STOP */
- }
-
- if (src->uri_path)
- dst->uri_path = g_strdup(src->uri_path);
+ *target = (mdg_group_s *)g_malloc0(sizeof(mdg_group_s));
+ mdg_check_null_ret_error("target", target, MDG_ERROR_INVALID_PARAMETER);
+ mdg_group_s *dst = *target;
if (src->device_id)
dst->device_id = g_strdup(src->device_id);
- if (src->group_name)
- dst->group_name = g_strdup(src->group_name);
-
if (src->host_addr)
dst->host_addr = g_strdup(src->host_addr);
- if (src->resource_type)
- dst->resource_type = g_strdup(src->resource_type);
+ if (src->group_name)
+ dst->group_name = g_strdup(src->group_name);
dst->type = src->type;
mdg_group_s * group = (mdg_group_s *)data;
mdg_check_null_ret_error("group", group, MDG_ERROR_INVALID_PARAMETER);
- if (group->uri_path) {
- g_free(group->uri_path);
- group->uri_path = NULL;
- }
if (group->device_id) {
g_free(group->device_id);
group->device_id = NULL;
}
- if (group->group_name) {
- g_free(group->group_name);
- group->group_name = NULL;
- }
if (group->host_addr) {
- g_free((mdg_group_s *)group->host_addr);
+ g_free(group->host_addr);
group->host_addr = NULL;
}
- if (group->resource_type) {
- g_free((mdg_group_s *)group->resource_type);
- group->resource_type = NULL;
+ if (group->group_name) {
+ g_free(group->group_name);
+ group->group_name = NULL;
}
+
g_free(group);
group = NULL;
return ret;
}
-EXPORT_API int mdg_group_info_get_type(mdg_group_h group,
- mdg_group_type_e *type)
+EXPORT_API int mdg_group_info_get_device_id(
+ mdg_group_h group, char **device_id)
{
int ret = MDG_ERROR_NONE;
CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
- *type = ((mdg_group_s *)group)->type;
+ *device_id = g_strdup(((mdg_group_s *)group)->device_id);
return ret;
}
-EXPORT_API int mdg_group_info_get_resource_type(
- mdg_group_h group, char **resource_type)
+EXPORT_API int mdg_group_info_get_host_addr(
+ mdg_group_h group, char **host_addr)
{
int ret = MDG_ERROR_NONE;
CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
- *resource_type = g_strdup(((mdg_group_s *)group)->resource_type);
+ *host_addr = g_strdup(((mdg_group_s *)group)->host_addr);
return ret;
}
-EXPORT_API int mdg_group_info_get_uri_path(
- mdg_group_h group, char **uri_path)
+EXPORT_API int mdg_group_info_get_type(mdg_group_h group,
+ mdg_group_type_e *type)
{
int ret = MDG_ERROR_NONE;
CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
- *uri_path = g_strdup(((mdg_group_s *)group)->uri_path);
+ *type = ((mdg_group_s *)group)->type;
return ret;
}
return ret;
}
-EXPORT_API int mdg_group_info_get_host_addr
- (mdg_group_h group, char **host_addr)
+EXPORT_API int mdg_device_info_clone(mdg_device_h *target,
+ mdg_device_h source)
{
int ret = MDG_ERROR_NONE;
CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
- *host_addr = g_strdup(((mdg_group_s *)group)->host_addr);
-
- return ret;
-}
+ mdg_device_s * src = (mdg_device_s *)source;
+ mdg_check_null_ret_error("source", source, MDG_ERROR_INVALID_PARAMETER);
-EXPORT_API int mdg_device_info_create(mdg_device_h* device)
-{
- int ret = MDG_ERROR_NONE;
+ *target = (mdg_device_s *)g_malloc0(sizeof(mdg_device_s));
+ mdg_check_null_ret_error("target", target, MDG_ERROR_INVALID_PARAMETER);
+ mdg_device_s *dst = *target;
- CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
+ if (src->device_id)
+ dst->device_id = g_strdup(src->device_id);
- mdg_device_h _device = g_malloc0(sizeof(mdg_device_s));
- if (NULL == device) {
- /* LCOV_EXCL_START */
- _ERR("Memory allocation Failed(%d)", errno);
- return MDG_ERROR_OUT_OF_MEMORY;
- /* LCOV_EXCL_STOP */
- }
- *device = _device;
+ if (src->addr)
+ dst->addr = g_strdup(src->addr);
- return ret;
-}
+ dst->port = src->port;
+ dst->secure_port = src->secure_port;
+ dst->conn_type = src->conn_type;
-EXPORT_API int mdg_device_info_clone(mdg_device_h target,
- mdg_device_h source)
-{
- int ret = MDG_ERROR_NONE;
+ if (src->model_name)
+ dst->model_name = g_strdup(src->model_name);
- CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
+ if (src->device_name)
+ dst->device_name = g_strdup(src->device_name);
- mdg_device_s *dst = (mdg_device_s *)target;
- mdg_check_null_ret_error("target", target, MDG_ERROR_INVALID_PARAMETER);
+ if (src->platform_ver)
+ dst->platform_ver = g_strdup(src->platform_ver);
- mdg_device_s *src = (mdg_device_s *)source;
- mdg_check_null_ret_error("source", source, MDG_ERROR_INVALID_PARAMETER);
+ if (src->vendor_id)
+ dst->vendor_id = g_strdup(src->vendor_id);
- ret = mdg_device_info_create(&target);
- if (MDG_ERROR_NONE != ret) {
- /* LCOV_EXCL_START */
- _ERR("mdg_device_info_create() Failed(%d)", ret);
- return ret;
- /* LCOV_EXCL_STOP */
- }
+ if (src->profile)
+ dst->profile = g_strdup(src->profile);
- if (src->device_id)
- dst->device_id = g_strdup(src->device_id);
- if (src->ip)
- dst->ip = g_strdup(src->ip);
- if (src->device_type)
- dst->device_type = src->device_type;
+ dst->is_invited = src->is_invited;
+ dst->type = src->type;
return ret;
}
g_free(device->device_id);
device->device_id = NULL;
}
- if (device->ip) {
- g_free(device->ip);
- device->ip = NULL;
+
+ if (device->addr) {
+ g_free(device->addr);
+ device->addr = NULL;
+ }
+
+ if (device->model_name) {
+ g_free(device->model_name);
+ device->model_name = NULL;
+ }
+
+ if (device->device_name) {
+ g_free(device->device_name);
+ device->device_name = NULL;
+ }
+
+ if (device->platform_ver) {
+ g_free(device->platform_ver);
+ device->platform_ver = NULL;
+ }
+
+ if (device->vendor_id) {
+ g_free(device->vendor_id);
+ device->vendor_id = NULL;
+ }
+
+ if (device->profile) {
+ g_free(device->profile);
+ device->profile = NULL;
}
g_free(device);
*device_id = g_strdup(((mdg_device_s *)device)->device_id);
return ret;
-
}
-EXPORT_API int mdg_device_info_get_ip(
- mdg_device_h device, char **ip)
+
+EXPORT_API int mdg_device_info_get_addr(
+ mdg_device_h device, char **addr)
{
int ret = MDG_ERROR_NONE;
CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
- *ip = g_strdup(((mdg_device_s *)device)->ip);
+ *addr = g_strdup(((mdg_device_s *)device)->addr);
return ret;
+}
+EXPORT_API int mdg_device_info_get_port(
+ mdg_device_h device, int *port)
+{
+ int ret = MDG_ERROR_NONE;
+
+ CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
+
+ *port = (((mdg_device_s *)device)->port);
+
+ return ret;
}
-EXPORT_API int mdg_device_info_get_device_type(
- mdg_device_h device, mdg_device_type_e *device_type)
+
+EXPORT_API int mdg_device_info_get_secure_port(
+ mdg_device_h device, int *secure_port)
{
int ret = MDG_ERROR_NONE;
CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
- *device_type = ((mdg_device_s *)device)->device_type;
+ *secure_port = (((mdg_device_s *)device)->secure_port);
return ret;
}
return ret;
}
-EXPORT_API int mdg_request_create_group(mdg_h handle,
- mdg_device_h device, char *group_name, mdg_request_result_cb cb,
- void *user_data)
+EXPORT_API int mdg_device_info_get_device_name(
+ mdg_device_h device, char **device_name)
{
int ret = MDG_ERROR_NONE;
- GError *error = NULL;
- NOTUSED(cb);
- NOTUSED(user_data);
+ CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
+
+ *device_name = g_strdup(((mdg_device_s *)device)->device_name);
+
+ return ret;
+}
+
+EXPORT_API int mdg_device_info_get_platform_ver(
+ mdg_device_h device, char **platform_ver)
+{
+ int ret = MDG_ERROR_NONE;
CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
- mdg_manager_s *_handle = handle;
- mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
+ *platform_ver = g_strdup(((mdg_device_s *)device)->platform_ver);
- mdg_device_s *dev = (mdg_device_s *)device;
- mdg_check_null_ret_error("device", device, MDG_ERROR_INVALID_PARAMETER);
- mdg_check_null_ret_error("group_name", group_name,
- MDG_ERROR_INVALID_PARAMETER);
+ return ret;
+}
- _DBG("Device id : %s", dev->device_id);
+EXPORT_API int mdg_device_info_get_vendor_id(
+ mdg_device_h device, char **vendor_id)
+{
+ int ret = MDG_ERROR_NONE;
- group_call_request_create_group_sync(_handle->group_proxy, dev->device_id,
- group_name, &ret, NULL, &error);
+ CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
+
+ *vendor_id = g_strdup(((mdg_device_s *)device)->vendor_id);
return ret;
}
-EXPORT_API int mdg_request_join_group(mdg_h handle, mdg_group_h group,
- mdg_request_result_cb callback, void *user_data)
+EXPORT_API int mdg_device_info_get_profile(
+ mdg_device_h device, char **profile)
{
int ret = MDG_ERROR_NONE;
CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
- NOTUSED(handle);
- NOTUSED(group);
- NOTUSED(callback);
- NOTUSED(user_data);
+ *profile = g_strdup(((mdg_device_s *)device)->profile);
return ret;
}
-EXPORT_API int mdg_request_leave_group (mdg_h handle,
- mdg_group_h group, mdg_request_result_cb callback, void *user_data)
+EXPORT_API int mdg_device_info_is_invited(
+ mdg_device_h device, bool *is_invited)
{
int ret = MDG_ERROR_NONE;
CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
- NOTUSED(handle);
- NOTUSED(group);
- NOTUSED(callback);
+ *is_invited = ((mdg_device_s *)device)->is_invited;
+
+ return ret;
+}
+
+EXPORT_API int mdg_device_info_get_type(
+ mdg_device_h device, mdg_device_type_e *type)
+{
+ int ret = MDG_ERROR_NONE;
+
+ CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
+
+ *type = ((mdg_device_s *)device)->type;
+
+ return ret;
+}
+
+EXPORT_API int mdg_request_create_group(mdg_h handle,
+ mdg_device_h device, char *group_name, mdg_request_result_cb cb,
+ void *user_data)
+{
+ int ret = MDG_ERROR_NONE;
+ GError *error = NULL;
+
+ NOTUSED(cb);
NOTUSED(user_data);
+ CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
+
+ mdg_manager_s *_handle = handle;
+ mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
+ CHECK_HANDLE_IS_VALID(handle);
+
+ mdg_device_s *dev = (mdg_device_s *)device;
+ mdg_check_null_ret_error("device", device, MDG_ERROR_INVALID_PARAMETER);
+ mdg_check_null_ret_error("group_name", group_name,
+ MDG_ERROR_INVALID_PARAMETER);
+
+ _DBG("Device id : %s", dev->device_id);
+
+ group_call_request_create_group_sync(_handle->group_proxy, dev->device_id,
+ group_name, &ret, NULL, &error);
+
return ret;
}
mdg_manager_s *_handle = handle;
mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
+ CHECK_HANDLE_IS_VALID(handle);
mdg_group_s *grp = (mdg_group_s *)group;
mdg_check_null_ret_error("group", group, MDG_ERROR_INVALID_PARAMETER);
mdg_manager_s *_handle = handle;
mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
+ CHECK_HANDLE_IS_VALID(handle);
mdg_group_s *grp = (mdg_group_s *)group;
mdg_check_null_ret_error("group", group, MDG_ERROR_INVALID_PARAMETER);
return ret;
}
-EXPORT_API int mdg_request_delete_group(mdg_h handle,
- mdg_group_h group, mdg_request_result_cb cb, void *user_data)
-{
- int ret = MDG_ERROR_NONE;
-
- CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
-
- NOTUSED(handle);
- NOTUSED(group);
- NOTUSED(cb);
- NOTUSED(user_data);
- return ret;
-}
-
EXPORT_API int mdg_request_result_callback(mdg_h handle,
mdg_request_result_cb result_cb, void *user_data)
{
return ret;
}
-
-EXPORT_API int mdg_device_monitor_start(mdg_h handle,
- mdg_device_monitor_result_cb cb, void *user_data)
-{
- int ret = MDG_ERROR_NONE;
- GError *error = NULL;
-
- CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
-
- mdg_manager_s *_handle = handle;
- mdg_check_null_ret_error("handle", handle,
- MDG_ERROR_INVALID_PARAMETER);
-
- group_call_start_invited_device_monitor_sync(_handle->group_proxy, 1, &ret,
- NULL, &error);
- if (ret != MDG_ERROR_NONE) {
- _ERR("Failed to start monitor");
- return ret;
- } else if (error) {
- _ERR("Failed DBus call [%s]", error->message);
- g_error_free(error);
- ret = MDG_ERROR_IO_ERROR;
- }
-
- _handle->monitor_result_cb.cb = cb;
- _handle->monitor_result_cb.user_data = user_data;
-
- return ret;
-}
-
-EXPORT_API int mdg_device_monitor_stop(mdg_h handle)
-{
- int ret = MDG_ERROR_NONE;
- GError *error = NULL;
-
- CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
-
- mdg_manager_s *_handle = handle;
- mdg_check_null_ret_error("handle", handle,
- MDG_ERROR_INVALID_PARAMETER);
-
- if (_handle->monitor_result_cb.cb == NULL) {
- _ERR("Monitor is not started");
- return MDG_ERROR_NOT_STARTED;
- }
-
- group_call_start_invited_device_monitor_sync(_handle->group_proxy, 0, &ret,
- NULL, &error);
- if (ret != MDG_ERROR_NONE) {
- _ERR("Failed to stop monitor");
- return ret;
- } else if (error) {
- _ERR("Failed DBus call [%s]", error->message);
- g_error_free(error);
- ret = MDG_ERROR_IO_ERROR;
- }
-
- _handle->monitor_result_cb.cb = NULL;
- _handle->monitor_result_cb.user_data = NULL;
-
- return ret;
-}
#include <mdg_gdbus.h>
#include <mdg_private.h>
-#define MDG_DBUS_SERVICE "org.tizen.mdg" /**< For mdg dbus */
-#define MDG_DBUS_GROUP_PATH "/org/tizen/mdg/group" /**< For group dbus */
-#define MDG_DBUS_ENABLER_PATH "/org/tizen/mdg/enabler" /**< dbus auto-activation */
-
/* LCOV_EXCL_START */
-static void __group_found_cb(Group *object, GVariant *va, gpointer user_data)
+static void __event_cb(Group *object,
+ gint event_type, gint ret, GVariant *va, gpointer user_data)
{
- GVariantIter *iter = NULL;
- const gchar *key;
- GVariant *key_value = NULL;
- mdg_group_s *group = NULL;
- char *uri_path = NULL;
- char *device_id = NULL;
- char *group_name = NULL;
- char *host_addr = NULL;
- char *resource_type = NULL;
- mdg_group_type_e type = MDG_GROUP_TYPE_ERROR;
-
NOTUSED(object);
-
- mdg_manager_s *handle = user_data;
mdg_check_null_ret("user_data", user_data);
- g_variant_get(va, "a{sv}", &iter);
- while (g_variant_iter_loop(iter, "{sv}", &key, &key_value)) {
- if (g_strcmp0(key, "URI") == 0)
- uri_path = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "DeviceID") == 0)
- device_id = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "GroupName") == 0)
- group_name = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "HostAddress") == 0)
- host_addr = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "GroupDeviceType") == 0)
- resource_type = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "GroupType") == 0)
- type = g_variant_get_int32(key_value);
- }
-
- g_variant_iter_free(iter);
-
- group = create_group_handle(uri_path, device_id, group_name, host_addr,
- resource_type, type);
- if (handle->group_found_cb.found_cb)
- handle->group_found_cb.found_cb(type, group, handle->group_found_cb.user_data);
-}
-
-static void _group_find_finish_cb(Group *object, gint ret, gpointer user_data)
-{
- NOTUSED(object);
-
mdg_manager_s *handle = user_data;
- mdg_check_null_ret("user_data", user_data);
-
- if (handle->group_find_finish_cb.finish_cb)
- handle->group_find_finish_cb.finish_cb(ret,
- handle->group_find_finish_cb.user_data);
-}
-static void __device_found_cb(Group *object, gint count, GVariant *va,
- gpointer user_data)
-{
- GVariantIter *iter = NULL;
- GVariantIter *iter_row = NULL;
- const gchar *key;
- GVariant *key_value;
- mdg_device_s *device = NULL;
+ _BEGIN();
- NOTUSED(object);
+ _DBG("Event occured : %d", event_type);
- mdg_manager_s *handle = user_data;
- mdg_check_null_ret("user_data", user_data);
+ if (event_type == MDG_EVENT_GROUP_FOUND) {
+ mdg_group_s *group = NULL;
- g_variant_get(va, "aa{sv}", &iter);
- while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
- char *device_id = NULL;
- char *ip = NULL;
- int device_type = MDG_DEVICE_TYPE_ERROR;
- int port = -1;
- int sec_port = -1;
- char *model_name = NULL;
- char *device_name = NULL;
- char *platform_ver = NULL;
- char *vendor_id = NULL;
- char *profile = NULL;
-
- while (g_variant_iter_loop(iter_row, "{sv}", &key, &key_value)) {
- if (g_strcmp0(key, "DeviceID") == 0)
- device_id = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "Address") == 0)
- ip = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "DeviceType") == 0)
- device_type = g_variant_get_uint16(key_value);
- else if (g_strcmp0(key, "Port") == 0)
- port = g_variant_get_uint16(key_value);
- else if (g_strcmp0(key, "SecurePort") == 0)
- sec_port = g_variant_get_uint16(key_value);
- else if (g_strcmp0(key, "ModelName") == 0)
- model_name = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "DeviceName") == 0)
- device_name = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "PlatformVer") == 0)
- platform_ver = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "VendorID") == 0)
- vendor_id = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "Profile") == 0)
- profile = (char *)g_variant_get_string(key_value, NULL);
+ group = mdg_get_group_from_variant(va);
+ if (handle->group_found_cb.found_cb) {
+ handle->group_found_cb.found_cb(group->type, group,
+ handle->group_found_cb.user_data);
+ } else {
+ _ERR("The callback not exists");
}
- g_variant_iter_free(iter_row);
-
- device = create_device_handle(device_id, ip, device_type, port,
- sec_port, model_name, device_name, platform_ver, vendor_id, profile);
- if (handle->device_found_cb.found_cb)
- handle->device_found_cb.found_cb(device, handle->device_found_cb.user_data);
- }
- g_variant_iter_free(iter);
-}
-
-static void _device_find_finish_cb(Group *object, gint ret, gpointer user_data)
-{
- NOTUSED(object);
-
- mdg_manager_s *handle = user_data;
- mdg_check_null_ret("user_data", user_data);
-
- if (handle->device_find_finish_cb.finish_cb)
- handle->device_find_finish_cb.finish_cb(ret,
- handle->device_find_finish_cb.user_data);
-}
-
-static void __mowned_device_found_cb(Group *object, gint count, GVariant *va,
- gpointer user_data)
-{
- GVariantIter *iter = NULL;
- GVariantIter *iter_row = NULL;
- const gchar *key;
- GVariant *key_value;
- mdg_device_s *device = NULL;
-
- NOTUSED(object);
-
- mdg_manager_s *handle = user_data;
- mdg_check_null_ret("user_data", user_data);
-
- g_variant_get(va, "aa{sv}", &iter);
- while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
- char *device_id = NULL;
- char *ip = NULL;
- int device_type = MDG_DEVICE_TYPE_ERROR;
- int port = -1;
- int sec_port = -1;
- char *model_name = NULL;
- char *device_name = NULL;
- char *platform_ver = NULL;
- char *vendor_id = NULL;
- char *profile = NULL;
-
- while (g_variant_iter_loop(iter_row, "{sv}", &key, &key_value)) {
- if (g_strcmp0(key, "DeviceID") == 0)
- device_id = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "Address") == 0)
- ip = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "DeviceType") == 0)
- device_type = g_variant_get_uint16(key_value);
- else if (g_strcmp0(key, "Port") == 0)
- port = g_variant_get_uint16(key_value);
- else if (g_strcmp0(key, "SecurePort") == 0)
- sec_port = g_variant_get_uint16(key_value);
- else if (g_strcmp0(key, "ModelName") == 0)
- model_name = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "DeviceName") == 0)
- device_name = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "PlatformVer") == 0)
- platform_ver = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "VendorID") == 0)
- vendor_id = (char *)g_variant_get_string(key_value, NULL);
- else if (g_strcmp0(key, "Profile") == 0)
- profile = (char *)g_variant_get_string(key_value, NULL);
+ } else if (event_type == MDG_EVENT_GROUP_FIND_FINISH) {
+ if (handle->group_find_finish_cb.finish_cb) {
+ handle->group_find_finish_cb.finish_cb(ret,
+ handle->group_find_finish_cb.user_data);
+ } else {
+ _ERR("The callback not exists");
+ }
+ } else if (event_type == MDG_EVENT_DEVICE_FOUND) {
+ mdg_device_s *device = NULL;
+
+ device = mdg_get_device_from_variant(va);
+ if (handle->device_found_cb.found_cb) {
+ handle->device_found_cb.found_cb(device,
+ handle->device_found_cb.user_data);
+ } else {
+ _ERR("The callback not exists");
+ }
+ } else if (event_type == MDG_EVENT_DEVICE_FIND_FINISH) {
+ if (handle->device_find_finish_cb.finish_cb) {
+ handle->device_find_finish_cb.finish_cb(ret,
+ handle->device_find_finish_cb.user_data);
+ } else {
+ _ERR("The callback not exists");
+ }
+ } else if (event_type == MDG_EVENT_INVITE_DEVICE_FINISH) {
+ if (handle->device_invite_finish_cb.finish_cb) {
+ handle->device_invite_finish_cb.finish_cb(ret,
+ handle->device_invite_finish_cb.user_data);
+ } else {
+ _ERR("The callback not exists");
+ }
+ } else if (event_type == MDG_EVENT_EJECT_DEVICE_FINISH) {
+ if (handle->device_eject_finish_cb.finish_cb) {
+ handle->device_eject_finish_cb.finish_cb(ret,
+ handle->device_eject_finish_cb.user_data);
+ } else {
+ _ERR("The callback not exists");
+ }
+ } else if (event_type == MDG_EVENT_SEND_DATA_FINISH) {
+ if (handle->send_data_finish_cb.finish_cb) {
+ handle->send_data_finish_cb.finish_cb(ret,
+ handle->send_data_finish_cb.user_data);
+ } else {
+ _ERR("The callback not exists");
}
- g_variant_iter_free(iter_row);
-
- device = create_device_handle(device_id, ip, device_type, port,
- sec_port, model_name, device_name, platform_ver, vendor_id, profile);
- if (handle->mowned_device_found_cb.found_cb)
- handle->mowned_device_found_cb.found_cb(device,
- handle->mowned_device_found_cb.user_data);
- destroy_device_handle(device);
- }
- g_variant_iter_free(iter);
-}
-
-static void _mowned_device_find_finish_cb(Group *object, gint ret,
- gpointer user_data)
-{
- NOTUSED(object);
-
- mdg_manager_s *handle = user_data;
- mdg_check_null_ret("user_data", user_data);
-
- if (handle->mowned_device_find_finish_cb.finish_cb)
- handle->mowned_device_find_finish_cb.finish_cb(ret,
- handle->mowned_device_find_finish_cb.user_data);
-}
-
-static void __device_invite_result_cb(Group *object, gint ret, gpointer user_data)
-{
- NOTUSED(object);
-
- mdg_manager_s *handle = user_data;
- mdg_check_null_ret("user_data", user_data);
-
- if (handle->device_invite_result_cb.result_cb)
- handle->device_invite_result_cb.result_cb(ret,
- handle->device_invite_result_cb.user_data);
-}
-
-static void __device_eject_result_cb(Group *object, gint ret, gpointer user_data)
-{
- NOTUSED(object);
-
- mdg_manager_s *handle = user_data;
- mdg_check_null_ret("user_data", user_data);
-
- if (handle->device_eject_result_cb.result_cb)
- handle->device_eject_result_cb.result_cb(ret,
- handle->device_eject_result_cb.user_data);
-}
-
-static void __send_data_finish_cb(Group *object, gchar *resp_data, gint ret,
- gpointer user_data)
-{
- NOTUSED(object);
-
- mdg_manager_s *handle = user_data;
- mdg_check_null_ret("user_data", user_data);
-
- if (handle->send_data_finish_cb.finish_cb)
- handle->send_data_finish_cb.finish_cb(ret, resp_data,
- handle->send_data_finish_cb.user_data);
-}
-
-static void __request_result_cb(Group *object, gchar *cmd, gchar *device_id,
- GVariant *arg, gint ret, gpointer user_data)
-{
- int len, length = 0;
- unsigned char *data;
- GVariantIter *iter;
-
- NOTUSED(object);
-
- mdg_manager_s *handle = user_data;
- mdg_check_null_ret("user_data", user_data);
-
- g_variant_get(arg, "(iay)", &len, &iter);
-
- data = g_try_malloc0(len + 1);
- if (data) {
- data = NULL;
- len = 0;
} else {
- while (g_variant_iter_loop(iter, "y", &data[length]))
- length += 1;
-
- data[length > len ? len : length] = '\0';
- _DBG("Received result length %d data %s", len, data);
-
- g_variant_iter_free(iter);
+ _ERR("Unknown Event");
}
- if (handle->request_result_cb.result_cb)
- handle->request_result_cb.result_cb(cmd, device_id, data, len, ret,
- handle->request_result_cb.user_data);
-
- g_free(data);
-}
-
-static void __monitor_result_cb(Group *object, gchar *uuid, gchar *group_name,
- gchar *status, gpointer user_data)
-{
- mdg_device_status_e device_status;
- mdg_manager_s *handle = user_data;
- mdg_check_null_ret("user_data", user_data);
-
- _DBG("Received Monitor Result uuid %s group name %s status %s", uuid,
- group_name, status);
-
- if (g_strcmp0(status, "Added") == 0)
- device_status = MDG_DEVICE_ADDED;
- else if (g_strcmp0(status, "Removed") == 0)
- device_status = MDG_DEVICE_REMOVED;
- else
- return;
-
- if (handle->monitor_result_cb.cb) {
- handle->monitor_result_cb.cb(uuid, group_name, device_status,
- handle->monitor_result_cb.user_data);
- }
+ _END();
}
/* LCOV_EXCL_STOP */
-
static int _enabler_proxy_init(mdg_manager_s *handle)
{
GError *error = NULL;
}
g_signal_connect(handle->group_proxy,
- "group-found", G_CALLBACK(__group_found_cb), handle);
- g_signal_connect(handle->group_proxy,
- "group-find-finish", G_CALLBACK(_group_find_finish_cb), handle);
- g_signal_connect(handle->group_proxy,
- "device-found", G_CALLBACK(__device_found_cb), handle);
- g_signal_connect(handle->group_proxy,
- "device-find-finish", G_CALLBACK(_device_find_finish_cb), handle);
- g_signal_connect(handle->group_proxy,
- "mowned-device-found", G_CALLBACK(__mowned_device_found_cb), handle);
- g_signal_connect(handle->group_proxy,
- "mowned-device-find-finish", G_CALLBACK(_mowned_device_find_finish_cb), handle);
- g_signal_connect(handle->group_proxy,
- "device-invite-result", G_CALLBACK(__device_invite_result_cb), handle);
- g_signal_connect(handle->group_proxy,
- "device-eject-result", G_CALLBACK(__device_eject_result_cb), handle);
- g_signal_connect(handle->group_proxy,
- "send-data-finish", G_CALLBACK(__send_data_finish_cb), handle);
- g_signal_connect(handle->group_proxy,
- "request-result", G_CALLBACK(__request_result_cb), handle);
- g_signal_connect(handle->group_proxy,
- "device-monitor-result", G_CALLBACK(__monitor_result_cb), handle);
+ "event", G_CALLBACK(__event_cb), handle);
return MDG_ERROR_NONE;
}
if (handle->enabler_proxy == NULL)
ret = -1; /* LCOV_EXCL_LINE */
- handle->ca = g_cancellable_new();
-
return ret;
}
_group_proxy_deinit(handle);
_enabler_proxy_deinit(handle);
- g_cancellable_cancel(handle->ca);
- g_object_unref(handle->ca);
- handle->ca = NULL;
-
return ret;
}
{
#endif
+#define MDG_DBUS_SERVICE "org.tizen.mdg" /**< For mdg dbus */
+#define MDG_DBUS_GROUP_PATH "/org/tizen/mdg/group" /**< For group dbus */
+#define MDG_DBUS_ENABLER_PATH "/org/tizen/mdg/enabler" /**< dbus auto-activation */
+
int gdbus_initialize(mdg_manager_s *handle);
int gdbus_deinitialize(mdg_manager_s *handle);
<arg type="i" name="timeout" direction="in" />
<arg type="i" name="result" direction="out" />
</method>
- <method name="GetFoundGroups">
- <arg type="i" name="result" direction="out" />
- <arg type="aa{sv}" name="groups" direction="out" />
- </method>
- <method name="Join">
- <arg type="i" name="result" direction="out" />
- </method>
- <method name="Leave">
- <arg type="i" name="result" direction="out" />
- </method>
<method name="Delete">
- <arg type="s" name="group_name" direction="in"/>
- <arg type="i" name="result" direction="out"/>
+ <arg type="s" name="group_name" direction="in" />
+ <arg type="i" name="result" direction="out" />
</method>
- <method name="DeviceFind">
+ <method name="FindDevice">
<arg type="i" name="timeout" direction="in" />
+ <arg type="i" name="is_invited" direction="in" />
<arg type="i" name="result" direction="out" />
</method>
- <method name="Invite">
+ <method name="InviteDevice">
<arg type="s" name="group_name" direction="in"/>
<arg type="s" name="uuid" direction="in"/>
<arg type="s" name="pin" direction="in" />
<arg type="i" name="result" direction="out"/>
</method>
- <method name="Eject">
+ <method name="EjectDevice">
<arg type="s" name="group_name" direction="in"/>
<arg type="s" name="uuid" direction="in"/>
<arg type="i" name="result" direction="out" />
</method>
- <method name="DeviceInvite">
- <arg type="s" name="uuid_dev1" direction="in"/>
- <arg type="s" name="uuid_dev2" direction="in"/>
- <arg type="s" name="pin" direction="in" />
- <arg type="s" name="uri_1" direction="in"/>
- <arg type="s" name="rt_1" direction="in"/>
- <arg type="s" name="interface_1" direction="in"/>
- <arg type="i" name="permission_1" direction="in"/>
- <arg type="s" name="uri_2" direction="in"/>
- <arg type="s" name="rt_2" direction="in"/>
- <arg type="s" name="interface_2" direction="in"/>
- <arg type="i" name="permission_2" direction="in"/>
- <arg type="i" name="result" direction="out"/>
+ <method name="GetLocalDevice">
+ <arg type="a{sv}" name="local_device" direction="out" />
</method>
- <method name="DeviceEject">
- <arg type="s" name="uuid_dev1" direction="in"/>
- <arg type="s" name="uuid_dev2" direction="in"/>
- <arg type="i" name="result" direction="out" />
+ <method name="GetMemberDevices">
+ <arg type="s" name="group_name" direction="in"/>
+ <arg type="aa{sv}" name="devices" direction="out" />
</method>
- <method name="GetRemoteDevice">
- <arg type="i" name="device_count" direction="out" />
- <arg type="aa{sv}" name="device_info" direction="out" />
- </method>
- <method name="PairResource">
- <arg type="s" name="target_1" direction="in"/>
- <arg type="s" name="subject_1" direction="in"/>
- <arg type="s" name="uri_1" direction="in"/>
- <arg type="s" name="rt_1" direction="in"/>
- <arg type="s" name="interface_1" direction="in"/>
- <arg type="i" name="permission_1" direction="in"/>
- <arg type="s" name="target_2" direction="in"/>
- <arg type="s" name="subject_2" direction="in"/>
- <arg type="s" name="uri_2" direction="in"/>
- <arg type="s" name="rt_2" direction="in"/>
- <arg type="s" name="interface_2" direction="in"/>
- <arg type="i" name="permission_2" direction="in"/>
- <arg type="i" name="result" direction="out"/>
+ <method name="RegistChannel">
+ <arg type="s" name="channel_id" direction="in"/>
+ <arg type="i" name="result" direction="out" />
</method>
- <method name="UnpairResource">
- <arg type="s" name="uuid_dev1" direction="in"/>
- <arg type="s" name="uuid_dev2" direction="in"/>
- <arg type="i" name="result" direction="out"/>
+ <method name="UnregistChannel">
+ <arg type="s" name="channel_id" direction="in"/>
+ <arg type="i" name="result" direction="out" />
</method>
<method name="SendData">
<arg type="s" name="uuid" direction="in" />
<arg type="(iay)" name="data" direction="in"/>
<arg type="i" name="result" direction="out" />
</method>
- <method name="FindMownedDevices">
- <arg type="i" name="timeout" direction="in" />
- <arg type="i" name="result" direction="out" />
- </method>
- <method name="GetMownedDevice">
- <arg type="i" name="device_count" direction="out" />
- <arg type="aa{sv}" name="device_info" direction="out" />
- </method>
- <method name="GetMyMownedDevice">
- <arg type="a{sv}" name="device_info" direction="out" />
- </method>
- <method name="GetMyUuid">
- <arg type="s" name="uuid" direction="out" />
- </method>
<method name="RequestCreateGroup">
<arg type="s" name="uuid" direction="in" />
<arg type="s" name="group_name" direction="in" />
<arg type="s" name="group_name" direction="in" />
<arg type="i" name="result" direction="out" />
</method>
- <method name="StartInvitedDeviceMonitor">
- <arg type="i" name="start" direction="in" />
- <arg type="i" name="result" direction="out" />
- </method>
<!-- Signal (D-Bus) definitions -->
- <signal name="GroupFound">
- <arg type="a{sv}" name="group_info" direction="out" />
- </signal>
- <signal name="GroupFindFinish">
- <arg type="i" name="result" direction="out" />
- </signal>
- <signal name="DeviceFound">
- <arg type="i" name="device_count" direction="out" />
- <arg type="aa{sv}" name="device_info" direction="out" />
- </signal>
- <signal name="DeviceFindFinish">
- <arg type="i" name="result" direction="out" />
- </signal>
- <signal name="DeviceInviteResult">
- <arg type="i" name="result" direction="out" />
- </signal>
- <signal name="DeviceEjectResult">
- <arg type="i" name="result" direction="out" />
- </signal>
- <signal name="MownedDeviceFound">
- <arg type="i" name="device_count" direction="out" />
- <arg type="aa{sv}" name="device_info" direction="out" />
- </signal>
- <signal name="MownedDeviceFindFinish">
- <arg type="i" name="result" direction="out" />
- </signal>
- <signal name="JoinResult">
+ <signal name="Event">
+ <arg type="i" name="type" direction="out" />
<arg type="i" name="result" direction="out" />
- </signal>
- <signal name="SendDataFinish">
- <arg type="s" name="resp_data" direction="out" />
- <arg type="i" name="result" direction="out" />
- </signal>
- <signal name="RequestResult">
- <arg type="s" name="command" direction="out" />
- <arg type="s" name="device_id" direction="out" />
- <arg type="(iay)" name="arg" direction="out" />
- <arg type="i" name="result" direction="out" />
- </signal>
- <signal name="DeviceMonitorResult">
- <arg type="s" name="uuid" direct="out" />
- <arg type="s" name="group_name" direct="out" />
- <arg type="s" name="status" direct="out" />
+ <arg type="a{sv}" name="data" direction="out" />
</signal>
</interface>
</node>
}
#endif
+
/**
* @brief New group found callback structure
* @since_tizen 5.0
} device_find_finish_cb_t;
/**
- * @brief New my own device found callback structure
- * @since_tizen 5.0
- */
-typedef struct _mowned_device_found_cb_t {
- mdg_device_found_cb found_cb; /**< User callback to be called */
- void *user_data; /**< User data pointer */
-} mowned_device_found_cb_t;
-
-/**
- * @brief Finding my own device done callback structure
- * @since_tizen 5.0
- */
-typedef struct _mowned_device_find_finish_cb_t {
- mdg_device_find_finish_cb finish_cb; /**< User callback to be called */
- void *user_data; /**< User data pointer */
-} mowned_device_find_finish_cb_t;
-
-/**
* @brief Inviting a device done callback structure
* @since_tizen 5.0
*/
-typedef struct _device_invite_result_cb_t {
- mdg_group_invite_device_result_cb result_cb; /**< User callback to be called */
+typedef struct _device_invite_finish_cb_t {
+ mdg_group_invite_device_finish_cb finish_cb; /**< User callback to be called */
void *user_data; /**< User data pointer */
-} device_invite_result_cb_t;
+} device_invite_finish_cb_t;
/**
* @brief Ejecting the device done callback structure
* @since_tizen 5.0
*/
-typedef struct _device_eject_result_cb_t {
- mdg_group_eject_device_result_cb result_cb; /**< User callback to be called */
+typedef struct _device_eject_finish_cb_t {
+ mdg_group_eject_device_finish_cb finish_cb; /**< User callback to be called */
void *user_data; /**< User data pointer */
-} device_eject_result_cb_t;
+} device_eject_finish_cb_t;
/**
* @brief Sending data to the device done callback structure
} request_result_cb_t;
/**
- * @brief Sending device monitor result callback structure
- * @since_tizen 5.0
- */
-typedef struct _monitor_result_cb_t {
- mdg_device_monitor_result_cb cb; /**< User callback to be called */
- void *user_data; /**< User data pointer */
-} monitor_result_cb_t;
-
-/**
* @brief The mdg-manager context
* @since_tizen 5.0
*/
typedef struct _mdg_manager_s {
- GCancellable *ca; /**< Cancelable */
-
Group *group_proxy; /**< To receive signal from cmdgd */
Enabler *enabler_proxy; /**< Enbler proxy */
GDBusConnection *system_bus; /**< GDBus System Bus */
+ GSList *channel_cb_list;
group_found_cb_t group_found_cb; /**< When it called after finding a every single group */
group_find_finish_cb_t group_find_finish_cb; /**< When it called the group finging time is up */
device_found_cb_t device_found_cb; /**< When it called after finding a every single device */
device_find_finish_cb_t device_find_finish_cb; /**< When it called the device finging time is up */
- mowned_device_found_cb_t mowned_device_found_cb; /**< When it called after finding a every single my own device */
- mowned_device_find_finish_cb_t mowned_device_find_finish_cb; /**< When it called the time of finding my own devices is up */
- device_invite_result_cb_t device_invite_result_cb; /**< When it called after invinting a device done or timeout */
- device_eject_result_cb_t device_eject_result_cb; /**< When it called after ejecting the device done or timeout */
+ device_invite_finish_cb_t device_invite_finish_cb; /**< When it called after invinting a device done or timeout */
+ device_eject_finish_cb_t device_eject_finish_cb; /**< When it called after ejecting the device done or timeout */
send_data_finish_cb_t send_data_finish_cb; /**< When it called after sending the device done or timeout */
request_result_cb_t request_result_cb; /**< When it called after sending private commands or timeout */
- monitor_result_cb_t monitor_result_cb; /**< It is called after device status is changed */
} mdg_manager_s;
+#define CHECK_HANDLE_IS_VALID(handle) { \
+ if (g_slist_find (handle_list, handle) == NULL) \
+ return MDG_ERROR_UNKNOWN; \
+}
+
/**
* @brief The group structure
* @since_tizen 5.0
*/
typedef struct _mdg_group_s {
- char *uri_path; /**< URI Path for group resource */
char *device_id; /**< Device ID of the device has this group resource */
- char *group_name; /**< Group Name (Friendly name) */
char *host_addr; /**< Host address */
- char *resource_type; /**< Resource type */
+ char *group_name; /**< Group Name (Friendly name) */
mdg_group_type_e type; /**< Mine or Remote */
} mdg_group_s;
*/
typedef struct _mdg_device_s {
char *device_id; /**< Device ID */
- char *ip; /**< Device IP */
- int device_type; /**< Device Type */
+ char *addr; /**< Device IP */
int port; /**< Port Number */
- int sec_port; /**< Secure Port Number */
+ int secure_port; /**< Secure Port Number */
+ unsigned int conn_type; /**< Connection type */
char *model_name;
char *device_name;
char *platform_ver;
char *vendor_id;
char *profile;
+ bool is_invited;
+ mdg_device_type_e type; /**< Device Type */
} mdg_device_s;
+typedef enum {
+ MDG_EVENT_GROUP_FOUND = 0,
+ MDG_EVENT_GROUP_FIND_FINISH,
+ MDG_EVENT_DEVICE_FOUND,
+ MDG_EVENT_DEVICE_FIND_FINISH,
+ MDG_EVENT_INVITE_DEVICE_FINISH,
+ MDG_EVENT_EJECT_DEVICE_FINISH,
+ MDG_EVENT_REQUEST_FINISH,
+ MDG_EVENT_SEND_DATA_FINISH,
+} mdg_event_type_e;
#endif /* __TIZEN_NETWORK_COMMON_MDG_PRIVATE_H__ */
#include <mdg_debug.h>
#include <mdg_private.h>
-mdg_group_s *create_group_handle(char *uri_path, char *device_id,
- char *group_name, char *host_addr, char *resource_type, mdg_group_type_e type)
+mdg_group_s *mdg_get_group_from_variant(GVariant *va)
{
+ char *device_id = NULL;
+ char *host_addr = NULL;
+ char *group_name = NULL;
+ mdg_group_type_e type = MDG_GROUP_TYPE_LOCAL;
+ GVariantIter *iter = NULL;
+ const gchar *key;
+ GVariant *key_value = NULL;
+
mdg_group_s *group = calloc(1, sizeof(mdg_group_s));
if (NULL == group) {
- /* LCOV_EXCL_START */
- _ERR("Memory allocation failed");
- goto CREATE_GROUP_HANDLER_ERROR;
- /* LCOV_EXCL_STOP */
+ /* LCOV_EXCL_START */
+ _ERR("Memory allocation failed");
+ return NULL;
+ /* LCOV_EXCL_STOP */
+ }
+
+ g_variant_get(va, "a{sv}", &iter);
+ while (g_variant_iter_loop(iter, "{sv}", &key, &key_value)) {
+ if (g_strcmp0(key, "DeviceID") == 0)
+ device_id = (char *)g_variant_get_string(key_value, NULL);
+ else if (g_strcmp0(key, "HostAddr") == 0)
+ host_addr = (char *)g_variant_get_string(key_value, NULL);
+ else if (g_strcmp0(key, "GroupName") == 0)
+ group_name = (char *)g_variant_get_string(key_value, NULL);
+ else if (g_strcmp0(key, "Type") == 0)
+ type = g_variant_get_int32(key_value);
}
- group->uri_path = g_strdup(uri_path);
group->device_id = g_strdup(device_id);
- group->group_name = g_strdup(group_name);
group->host_addr = g_strdup(host_addr);
- group->resource_type = g_strdup(resource_type);
+ group->group_name = g_strdup(group_name);
group->type = type;
- if (!group->uri_path || !group->device_id ||
- !group->host_addr || !group->resource_type) {
- /* LCOV_EXCL_START */
- _ERR("Memory allocation failed");
- goto CREATE_GROUP_HANDLER_ERROR;
- /* LCOV_EXCL_STOP */
- }
- return group;
+ g_variant_iter_free(iter);
-CREATE_GROUP_HANDLER_ERROR:
- /* LCOV_EXCL_START */
- if (group) {
- if (group->uri_path) {
- free(group->uri_path);
- group->uri_path = NULL;
- }
- if (group->device_id) {
- free(group->device_id);
- group->device_id = NULL;
- }
- if (group->group_name) {
- free(group->group_name);
- group->group_name = NULL;
- }
- if (group->host_addr) {
- free(group->host_addr);
- group->host_addr = NULL;
- }
- if (group->resource_type) {
- free(group->resource_type);
- group->resource_type = NULL;
- }
- free(group);
- group = NULL;
- }
- return NULL;
- /* LCOV_EXCL_STOP */
+ return group;
}
-mdg_device_s *create_device_handle(char *device_id, char *ip,
- int device_type, int port, int sec_port, char *model_name, char *device_name,
- char *platform_ver, char *vendor_id, char *profile)
+mdg_device_s *mdg_get_device_from_variant(GVariant *va)
{
+ char *device_id = NULL;
+ char *addr = NULL;
+ int port;
+ int secure_port;
+ int conn_type;
+ char *model_name = NULL;
+ char *device_name = NULL;
+ char *platform_ver = NULL;
+ char *vendor_id = NULL;
+ char *profile = NULL;
+ bool is_invited;
+ int type = MDG_DEVICE_TYPE_LOCAL;
+ GVariantIter *iter = NULL;
+ const gchar *key;
+ GVariant *key_value = NULL;
+
mdg_device_s *device = calloc(1, sizeof(mdg_device_s));
if (NULL == device) {
- /* LCOV_EXCL_START */
- _ERR("Memory allocation failed");
- goto CREATE_DEVICE_HANDLER_ERROR;
- /* LCOV_EXCL_STOP */
+ /* LCOV_EXCL_START */
+ _ERR("Memory allocation failed");
+ return NULL;
+ /* LCOV_EXCL_STOP */
+ }
+
+ g_variant_get(va, "a{sv}", &iter);
+ while (g_variant_iter_loop(iter, "{sv}", &key, &key_value)) {
+ if (g_strcmp0(key, "DeviceID") == 0)
+ device_id = (char *)g_variant_get_string(key_value, NULL);
+ else if (g_strcmp0(key, "Addr") == 0)
+ addr = (char *)g_variant_get_string(key_value, NULL);
+ else if (g_strcmp0(key, "Port") == 0)
+ port = g_variant_get_int32(key_value);
+ else if (g_strcmp0(key, "SecurePort") == 0)
+ secure_port = g_variant_get_int32(key_value);
+ else if (g_strcmp0(key, "ConnType") == 0)
+ conn_type = g_variant_get_int32(key_value);
+ else if (g_strcmp0(key, "ModelName") == 0)
+ model_name = (char *)g_variant_get_string(key_value, NULL);
+ else if (g_strcmp0(key, "DeviceName") == 0)
+ device_name = (char *)g_variant_get_string(key_value, NULL);
+ else if (g_strcmp0(key, "PlatformVer") == 0)
+ platform_ver = (char *)g_variant_get_string(key_value, NULL);
+ else if (g_strcmp0(key, "VendorID") == 0)
+ vendor_id = (char *)g_variant_get_string(key_value, NULL);
+ else if (g_strcmp0(key, "Profile") == 0)
+ profile = (char *)g_variant_get_string(key_value, NULL);
+ else if (g_strcmp0(key, "IsInvited") == 0)
+ is_invited = g_variant_get_int32(key_value);
+ else if (g_strcmp0(key, "Type") == 0)
+ type = g_variant_get_int32(key_value);
}
device->device_id = g_strdup(device_id);
- device->ip = g_strdup(ip);
- device->device_type = device_type;
+ device->addr = g_strdup(addr);
device->port = port;
- device->sec_port = sec_port;
+ device->secure_port = secure_port;
+ device->conn_type = conn_type;
device->model_name = g_strdup(model_name);
device->device_name = g_strdup(device_name);
device->platform_ver = g_strdup(platform_ver);
device->vendor_id = g_strdup(vendor_id);
device->profile = g_strdup(profile);
+ device->is_invited = is_invited;
+ device->type = type;
- if (!device->device_id || !device->ip || !device->model_name || !device->device_name ||
- !device->platform_ver || !device->vendor_id || !device->profile) {
- /* LCOV_EXCL_START */
- _ERR("Memory allocation failed");
- goto CREATE_DEVICE_HANDLER_ERROR;
- /* LCOV_EXCL_STOP */
- }
+ g_variant_iter_free(iter);
return device;
-
-CREATE_DEVICE_HANDLER_ERROR:
- /* LCOV_EXCL_START */
- if (device) {
- if (device->device_id) {
- free(device->device_id);
- device->device_id = NULL;
- }
- if (device->model_name) {
- free(device->model_name);
- device->model_name = NULL;
- }
- if (device->device_name) {
- free(device->device_name);
- device->device_name = NULL;
- }
- if (device->platform_ver) {
- free(device->platform_ver);
- device->platform_ver = NULL;
- }
- if (device->vendor_id) {
- free(device->vendor_id);
- device->vendor_id = NULL;
- }
- if (device->profile) {
- free(device->profile);
- device->profile = NULL;
- }
- if (device->ip) {
- free(device->ip);
- device->ip = NULL;
- }
- free(device);
- device = NULL;
- }
- return NULL;
- /* LCOV_EXCL_STOP */
-}
-
-void destroy_device_handle(mdg_device_s *device)
-{
- if (NULL == device) {
- /* LCOV_EXCL_START */
- _ERR("Memory allocation failed");
- return;
- /* LCOV_EXCL_STOP */
- }
-
- if (device->device_id) {
- free(device->device_id);
- device->device_id = NULL;
- }
- if (device->model_name) {
- free(device->model_name);
- device->model_name = NULL;
- }
- if (device->device_name) {
- free(device->device_name);
- device->device_name = NULL;
- }
- if (device->platform_ver) {
- free(device->platform_ver);
- device->platform_ver = NULL;
- }
- if (device->vendor_id) {
- free(device->vendor_id);
- device->vendor_id = NULL;
- }
- if (device->profile) {
- free(device->profile);
- device->profile = NULL;
- }
- if (device->ip) {
- free(device->ip);
- device->ip = NULL;
- }
- free(device);
- device = NULL;
}
{
#endif
-mdg_group_s *create_group_handle(char *uri_path, char *device_id,
- char *group_name, char *host_addr, char *resource_type, mdg_group_type_e type);
-mdg_device_s *create_device_handle(char *device_id, char *ip, int device_type,
- int port, int sec_port, char *model_name, char *device_name,
- char *platform_ver, char *vendor_id, char *profile);
-void destroy_device_handle(mdg_device_s *device);
+mdg_device_s *mdg_get_device_from_variant(GVariant *va);
+mdg_group_s *mdg_get_group_from_variant(GVariant *va);
#ifdef __cplusplus
}
CASE_TO_STR(MDG_ERROR_PLUGIN_FAIL)
CASE_TO_STR(MDG_ERROR_ALREADY_IN_PROGRESS)
CASE_TO_STR(MDG_ERROR_NOT_STARTED)
- CASE_TO_STR(MDG_ERROR_ALREADY_INITIALIZED)
default :
return "MDG_ERROR_UNKNOWN";
}
const char *mdg_group_type_to_string(mdg_group_type_e e)
{
switch (e) {
- CASE_TO_STR(MDG_GROUP_TYPE_MINE)
+ CASE_TO_STR(MDG_GROUP_TYPE_LOCAL)
CASE_TO_STR(MDG_GROUP_TYPE_REMOTE)
default :
return "Unknown station type";
return TRUE;
}
+void _free_group(gpointer data)
+{
+ mdg_group_info_destroy(data);
+}
+
void _free_device(gpointer data)
{
mdg_device_info_destroy(data);
OUT:
if (found_group_list)
- g_list_free_full(found_group_list, _free_device);
+ g_list_free_full(found_group_list, _free_group);
if (found_device_list)
g_list_free_full(found_device_list, _free_device);
GList *found_group_list;
GList *found_device_list;
-GList *my_devices_list;
+GList *invited_device_list;
static char groupid[MENU_DATA_SIZE + 1] = "mygroup";
static char request_groupid[MENU_DATA_SIZE + 1] = "subgroup";
static char timeout[MENU_DATA_SIZE + 1] = "2";
static char group_idx[MENU_DATA_SIZE + 1] = "1";
-#if 0
-static char group_idx_a[MENU_DATA_SIZE + 1] = "1";
-static char group_idx_b[MENU_DATA_SIZE + 1] = "2";
-#endif
static char device_idx[MENU_DATA_SIZE + 1] = "1";
static char pin[MENU_DATA_SIZE + 1] = "12341234";
static char message[MENU_DATA_SIZE + 1] = "Hello World!!";
-static char monitor[MENU_DATA_SIZE + 1] = "1";
+static char channel_id[MENU_DATA_SIZE + 1] = "Channel1";
+//static char monitor[MENU_DATA_SIZE + 1] = "1";
static int run_group_find(MManager *mm, struct menu_data *menu);
static int run_devices_find(MManager *mm, struct menu_data *menu);
}
}
-int run_get_my_id(MManager *mm, struct menu_data *menu)
-{
- msg("Get Device ID of my device");
-
- int ret;
- char *uuid;
- ret = mdg_device_info_get_my_uuid(handle, &uuid);
-
- if (MDG_ERROR_NONE != ret) {
- msgr("Failed to Get My Device ID: [%s(0x%X)]", mdg_error_to_string(ret), ret);
- return RET_FAILURE;
- }
-
- msg(" - mdg_device_my_deviceid() ret: [0x%X] [%s]", ret, mdg_error_to_string(ret));
- msgb("[ID] : [%s]", uuid);
-
- return RET_SUCCESS;
-}
-
void _device_eject_result_cb(int result, void *user_data)
{
msgb("\rEject Device Complete [%s]", mdg_error_to_string(result));
static int run_device_eject(MManager *mm, struct menu_data *menu)
{
int ret;
- int idx = 1;
+ int idx;
mdg_group_h group = NULL;
mdg_device_h device = NULL;
static int run_device_invite(MManager *mm, struct menu_data *menu)
{
int ret;
- int idx = 1;
+ int idx;
mdg_group_h group = NULL;
mdg_device_h device = NULL;
static int run_devices_show(MManager *mm, struct menu_data *menu)
{
- char *deviceid = NULL;
- char *ip = NULL;
- mdg_device_type_e devicetype;
mdg_device_h device;
- int ret;
- int count;
- mdg_device_h *devices = NULL;
+
int i;
GList *iter = NULL;
- ret = mdg_device_get_found_devices(handle, &devices, &count);
- if (MDG_ERROR_NONE != ret) {
- msgr("Failed to Get Found Devices: [%s(0x%X)]",
- mdg_error_to_string(ret), ret);
- return RET_FAILURE;
- } else {
- if (found_device_list) {
- g_list_free_full(found_device_list, _destroy_mdg_device_info);
- found_device_list = NULL;
+ /* Get a first item */
+ i = 0;
+ iter = g_list_first(found_device_list);
+ while (NULL != iter) {
+ device = iter->data;
+ if (!device) {
+ msgr("device is null");
+ break;
}
- for (i = 0; i < count; i++)
- found_device_list = g_list_append(found_device_list, devices[i]);
+ char *model_name;
+ char *addr;
+ mdg_device_info_get_model_name(device, &model_name);
+ mdg_device_info_get_addr(device, &addr);
+
+ msgp("[%d] Model : %s, Addr : %s", i+1, model_name, addr);
+
+ mdg_device_h cloned_device;
+ char *cloned_model_name;
+ char *cloned_addr;
+
+ mdg_device_info_clone(&cloned_device, device);
+ mdg_device_info_get_model_name(cloned_device, &cloned_model_name);
+ mdg_device_info_get_addr(cloned_device, &cloned_addr);
+
+ msgp("*Cloned* [%d] Model : %s, Addr : %s", i+1, cloned_model_name, cloned_addr);
+
+ if (model_name)
+ free(model_name);
+
+ if (addr)
+ free(addr);
+
+ if (cloned_model_name)
+ free(cloned_model_name);
+
+ if (cloned_addr)
+ free(cloned_addr);
+
+ mdg_device_info_destroy(cloned_device);
+
+ /* Next item */
+ iter = g_list_next(iter);
+ i++;
}
+ return RET_SUCCESS;
+}
+
+static int run_invited_devices_show(MManager *mm, struct menu_data *menu)
+{
+ mdg_device_h device;
+
+ int i;
+ GList *iter = NULL;
+
/* Get a first item */
i = 0;
- iter = g_list_first(found_device_list);
+ iter = g_list_first(invited_device_list);
while (NULL != iter) {
device = iter->data;
if (!device) {
- msgr("device list is null");
+ msgr("device is null");
break;
}
- mdg_device_info_get_device_id(device, &deviceid);
- mdg_device_info_get_ip(device, &ip);
- mdg_device_info_get_device_type(device, &devicetype);
- msgp("[%d] deviceid: %s, IP: %s type: %s", i+1, deviceid, ip,
- __device_type_to_string(devicetype));
-
- if (deviceid) {
- free(deviceid);
- deviceid = NULL;
- }
- if (ip) {
- free(ip);
- ip = NULL;
- }
+
+ char *model_name;
+ char *addr;
+ mdg_device_info_get_model_name(device, &model_name);
+ mdg_device_info_get_addr(device, &addr);
+
+ msgp("[%d] Model : %s, Addr : %s", i+1, model_name, addr);
+
+ if (model_name)
+ free(model_name);
+
+ if (addr)
+ free(addr);
+
/* Next item */
iter = g_list_next(iter);
i++;
return RET_SUCCESS;
}
#endif
-#if 0
-static int run_group_merge(MManager *mm, struct menu_data *menu)
-{
- int ret;
- int a, b;
- mdg_group_h group_a;
- mdg_group_h group_b;
-
- msg("Merge Group");
-
- if (strlen(group_idx_a)) {
- a = (unsigned short)strtol(group_idx_a, NULL, 10);
- if (0 >= a) {
- msgp("Invalid index. set to 1");
- a = 1;
- }
- }
-
- if (found_group_list) {
- group_a = g_list_nth_data(found_group_list, a - 1);
- if (NULL == group_a) {
- msgr("Failed to g_hash_table_find");
- return RET_FAILURE;
- }
- }
-
- if (strlen(group_idx_b)) {
- b = (unsigned short)strtol(group_idx_b, NULL, 10);
- if (0 >= b) {
- msgp("Invalid index. set to 2");
- b = 1;
- }
- }
-
- if (found_group_list) {
- group_b = g_list_nth_data(found_group_list, b - 1);
- if (NULL == group_b) {
- msgr("Failed to g_hash_table_find");
- return RET_FAILURE;
- }
- }
-
-
- ret = mdg_group_merge(handle, group_a, group_b);
- if (MDG_ERROR_NONE != ret) {
- msgr("Failed to Merge Group: [%s(0x%X)]", mdg_error_to_string(ret), ret);
- return RET_FAILURE;
- }
- msg(" - mdg_group_merge() ret: [0x%X] [%s]", ret, mdg_error_to_string(ret));
-
- return RET_SUCCESS;
-}
-#endif
static int run_group_delete(MManager *mm, struct menu_data *menu)
{
int ret;
- int idx = 1;
- mdg_group_h group = NULL;
+ int idx;
+ mdg_group_h group;
msg("Delete Group");
return RET_SUCCESS;
}
-int run_device_show_found(MManager *mm, struct menu_data *menu)
-{
- int ret;
- int count;
- mdg_device_h *devices = NULL;
-
- ret = mdg_device_get_found_devices(handle, &devices, &count);
- if (MDG_ERROR_NONE != ret) {
- msgr("Failed to Get Found Devices: [%s(0x%X)]", mdg_error_to_string(ret), ret);
- return RET_FAILURE;
- }
- msg(" - mdg_device_get_found_devices() ret: [0x%X] [%s]", ret, mdg_error_to_string(ret));
-
- for (int i = 0; i < count; i++) {
- char *device_id = NULL;
- char *ip = NULL;
- mdg_device_type_e device_type;
-
- mdg_device_info_get_device_id(devices[i], &device_id);
- mdg_device_info_get_ip(devices[i], &ip);
- mdg_device_info_get_device_type(devices[i], &device_type);
-
- msgb("\n[ID] %s [IP] %s [Type] %s", device_id, ip,
- __device_type_to_string(device_type));
-
- if (device_id)
- free(device_id);
- if (ip)
- free(ip);
- }
-
- return RET_SUCCESS;
-}
-
void _device_finish_cb(int result, void *user_data)
{
msgb("\rFind Device Finished ret: [0x%X] [%s]", result, mdg_error_to_string(result));
bool _device_found_cb(mdg_device_h device, void *user_data)
{
- char *ip = NULL;
+ char *addr = NULL;
char *device_id = NULL;
char *model_name = NULL;
mdg_device_type_e device_type;
gboolean is_exist = FALSE;
mdg_device_info_get_device_id(device, &device_id);
- mdg_device_info_get_ip(device, &ip);
- mdg_device_info_get_device_type(device, &device_type);
+ mdg_device_info_get_addr(device, &addr);
mdg_device_info_get_model_name(device, &model_name);
+ mdg_device_info_get_type(device, &device_type);
iter = found_device_list;
while (iter != NULL) {
if (is_exist == FALSE) {
found_device_list = g_list_append(found_device_list, device);
- msgp("\r[ID] %s [IP] %s [Type] %s [Name] %s", device_id, ip,
+ msgp("\r[ID] %s [IP] %s [Type] %s [Name] %s", device_id, addr,
__device_type_to_string(device_type), model_name);
}
if (device_id)
free(device_id);
- if (ip)
- free(ip);
+ if (addr)
+ free(addr);
return TRUE;
}
static int run_devices_find(MManager *mm, struct menu_data *menu)
{
int ret;
- int duration = 2;
+ int duration;
msg("Find Devices");
if (strlen(timeout))
duration = (unsigned short)strtol(timeout, NULL, 10);
- ret = mdg_device_find(handle, duration, _device_found_cb, _device_finish_cb, NULL);
+ ret = mdg_device_find(handle, duration, false, _device_found_cb, _device_finish_cb, NULL);
if (MDG_ERROR_NONE != ret) {
msgr("Failed to Find Devices: [%s(0x%X)]", mdg_error_to_string(ret), ret);
return RET_FAILURE;
return RET_SUCCESS;
}
-int run_device_show_my_device(MManager *mm, struct menu_data *menu)
+int run_device_show_local_device(MManager *mm, struct menu_data *menu)
{
int ret = 0;
mdg_device_h device = NULL;
- msg("Get My Device");
+ msg("Get Local Device");
- ret = mdg_device_info_get_my_device(handle, &device);
+ ret = mdg_device_get_local_device(handle, &device);
if (MDG_ERROR_NONE != ret) {
msgr("Failed to Get My Device: [%s(0x%X)]", mdg_error_to_string(ret), ret);
return RET_FAILURE;
}
- msg(" - mdg_device_info_get_my_device() ret: [0x%X] [%s]", ret, mdg_error_to_string(ret));
+ msg(" - mdg_device_info_get_local_device() ret: [0x%X] [%s]", ret, mdg_error_to_string(ret));
if (ret == 0) {
char *device_id = NULL;
- char *ip = NULL;
- mdg_device_type_e device_type;
+ char *addr = NULL;
+ int port;
+ int secure_port;
+ char *model_name;
+ char *device_name;
+ char *platform_ver;
+ char *vendor_id;
+ char *profile;
+ bool is_invited;
+ mdg_device_type_e type;
mdg_device_info_get_device_id(device, &device_id);
- mdg_device_info_get_ip(device, &ip);
- mdg_device_info_get_device_type(device, &device_type);
-
- msgb("\n[ID] %s [IP] %s [Type] %s", device_id, ip,
- __device_type_to_string(device_type));
+ mdg_device_info_get_addr(device, &addr);
+ mdg_device_info_get_port(device, &port);
+ mdg_device_info_get_secure_port(device, &secure_port);
+ mdg_device_info_get_model_name(device, &model_name);
+ mdg_device_info_get_device_name(device, &device_name);
+ mdg_device_info_get_platform_ver(device, &platform_ver);
+ mdg_device_info_get_vendor_id(device, &vendor_id);
+ mdg_device_info_get_profile(device, &profile);
+ mdg_device_info_is_invited(device, &is_invited);
+ mdg_device_info_get_type(device, &type);
+
+ msgb("\n[ID] %s", device_id);
+ msgb("[ADDR] %s", addr);
+ msgb("[PORT] %d", port);
+ msgb("[S.PORT] %d", secure_port);
+ msgb("[Model Name] %s", model_name);
+ msgb("[Device Name] %s", device_name);
+ msgb("[Platform Ver.] %s", platform_ver);
+ msgb("[Vendor ID] %s", vendor_id);
+ msgb("[Profile] %s", profile);
+ msgb("[Is Invited] %d", is_invited);
+ msgb("[Type] %s\n", __device_type_to_string(type));
if (device_id)
free(device_id);
- if (ip)
- free(ip);
+ if (addr)
+ free(addr);
+ if (model_name)
+ free(model_name);
+ if (device_name)
+ free(device_name);
+ if (platform_ver)
+ free(platform_ver);
+ if (vendor_id)
+ free(vendor_id);
+ if (profile)
+ free(profile);
mdg_device_info_destroy(device);
device = NULL;
return RET_SUCCESS;
}
-static int run_group_leave(MManager *mm, struct menu_data *menu)
-{
- int ret;
- int idx = 1;
- mdg_group_h group = NULL;
-
- msg("Leave Group");
-
- if (strlen(group_idx)) {
- idx = (unsigned short)strtol(group_idx, NULL, 10);
- if (0 >= idx) {
- msgp("Invalid index. set to 1");
- idx = 1;
- }
- }
-
- if (found_group_list) {
- group = g_list_nth_data(found_group_list, idx - 1);
- if (NULL == group) {
- msgr("Failed to g_hash_table_find");
- return RET_FAILURE;
- }
- }
-
- ret = mdg_request_leave_group (handle, group, receive_request_result, NULL);
- if (MDG_ERROR_NONE != ret) {
- msgr("Failed to Leave Group: [%s(0x%X)]", mdg_error_to_string(ret), ret);
- return RET_FAILURE;
- }
- msg(" - mdg_request_leave_group () ret: [0x%X] [%s]", ret, mdg_error_to_string(ret));
-
- return RET_SUCCESS;
-}
-
static int run_group_show(MManager *mm, struct menu_data *menu)
{
- char *rt;
- char *uri;
- mdg_group_type_e type;
mdg_group_h group;
int i;
msgr("groups is null");
break;
}
+
+ char *device_id;
+ char *host_addr;
+ char *name;
+ mdg_group_type_e type;
+
+ mdg_group_info_get_device_id(group, &device_id);
+ mdg_group_info_get_host_addr(group, &host_addr);
+ mdg_group_info_get_name(group, &name);
mdg_group_info_get_type(group, &type);
- mdg_group_info_get_uri_path(group, &uri);
- mdg_group_info_get_resource_type(group, &rt);
- msgp("[%d] type: %s, URI: %s RT: %s", i+1, mdg_group_type_to_string(type), uri, rt);
- if (uri) {
- free(uri);
- uri = NULL;
- }
- if (rt) {
- free(rt);
- rt = NULL;
- }
- /* Next item */
- iter = g_list_next(iter);
- i++;
- }
- return RET_SUCCESS;
-}
+ msgp("[%d] type: %s, name: %s", i+1, mdg_group_type_to_string(type), name);
+ msgp(" host_addr: %s, device_id: %s\n", host_addr, device_id);
-static int run_group_join(MManager *mm, struct menu_data *menu)
-{
- int ret;
- int idx = 1;
- mdg_group_h group = NULL;
+ mdg_group_h cloned_group;
+ char *cloned_device_id;
+ char *cloned_host_addr;
+ char *cloned_name;
+ mdg_group_type_e cloned_type;
- msg("Join Group");
+ mdg_group_info_clone(&cloned_group, group);
+ mdg_group_info_get_device_id(cloned_group, &cloned_device_id);
+ mdg_group_info_get_host_addr(cloned_group, &cloned_host_addr);
+ mdg_group_info_get_name(cloned_group, &cloned_name);
+ mdg_group_info_get_type(cloned_group, &cloned_type);
- if (strlen(group_idx)) {
- idx = (unsigned short)strtol(group_idx, NULL, 10);
- if (0 >= idx) {
- msgp("Invalid index. set to 1");
- idx = 1;
- }
- }
+ msgp("*Cloned* [%d] type: %s, name: %s", i+1, mdg_group_type_to_string(cloned_type), cloned_name);
+ msgp(" host_addr: %s, device_id: %s\n", cloned_host_addr, cloned_device_id);
- if (found_group_list) {
- group = g_list_nth_data(found_group_list, idx - 1);
- if (NULL == group) {
- msgr("Failed to g_hash_table_find");
- return RET_FAILURE;
- }
- }
+ if (device_id)
+ free(device_id);
+ if (host_addr)
+ free(host_addr);
+ if (name)
+ free(name);
- ret = mdg_request_join_group(handle, group, receive_request_result, NULL);
- if (MDG_ERROR_NONE != ret) {
- msgr("Failed to Join Group: [%s(0x%X)]", mdg_error_to_string(ret), ret);
- return RET_FAILURE;
+ if (cloned_device_id)
+ free(cloned_device_id);
+ if (cloned_host_addr)
+ free(cloned_host_addr);
+ if (cloned_name)
+ free(cloned_name);
+
+ mdg_group_info_destroy(cloned_group);
+
+ /* Next item */
+ iter = g_list_next(iter);
+ i++;
}
- msg(" - mdg_request_join_group() ret: [0x%X] [%s]", ret, mdg_error_to_string(ret));
return RET_SUCCESS;
}
mdg_group_info_destroy((mdg_group_h)data);
}
-static int run_group_show_found(MManager *mm, struct menu_data *menu)
-{
- int ret;
- int count;
- mdg_group_h *groups = NULL;
-
- msg("Show Found Group(s)");
-
- ret = mdg_group_get_found_groups(handle, &groups, &count);
- if (MDG_ERROR_NONE != ret) {
- msgr("Failed to Get Found Groups: [%s(0x%X)]", mdg_error_to_string(ret), ret);
- return RET_FAILURE;
- }
- msg(" - mdg_group_get_found_groups() ret: [0x%X] [%s]", ret, mdg_error_to_string(ret));
-
- if (found_group_list) {
- g_list_free_full(found_group_list, _destroy_mdg_group_info);
- found_group_list = NULL;
- }
-
- for (int i = 0; i < count; i++) {
- mdg_group_type_e type;
- char *uri_path;
- char *group_name;
-
- mdg_group_info_get_type(groups[i], &type);
- mdg_group_info_get_uri_path(groups[i], &uri_path);
- mdg_group_info_get_name(groups[i], &group_name);
-
- if (type == MDG_GROUP_TYPE_MINE)
- msgb("%d. type : MINE, name : %s, uri : %s", i+1, group_name, uri_path);
- else
- msgb("%d. type : REMOTE, name : %s, uri : %s", i+1, group_name, uri_path);
-
- found_group_list = g_list_append(found_group_list, groups[i]);
-
- g_free(uri_path);
- g_free(group_name);
- }
-
- return RET_SUCCESS;
-}
-
bool _group_found_cb(mdg_group_type_e type, mdg_group_h group, void *user_data)
{
char *group_name;
mdg_group_info_get_name(group, &group_name);
- if (type == MDG_GROUP_TYPE_MINE)
+ if (type == MDG_GROUP_TYPE_LOCAL)
msgp("\rfound group type : MINE, name : %s", group_name);
else
msgp("\rfound group type : REMOTE, name : %s", group_name);
static int run_group_find(MManager *mm, struct menu_data *menu)
{
int ret;
- int duration = 2;
+ int duration;
msg("Find Group");
if (strlen(timeout))
return RET_SUCCESS;
}
-void _send_data_finish_cb(int result, char *resp_data, void *user_data)
+void _send_data_finish_cb(int result, void *user_data)
{
msgb("\rFind Send Data Finished = %d", result);
- if (resp_data != NULL && strlen(resp_data) > 0)
- msgp("Response from %s", resp_data);
}
static int __send_data(int idx)
if (found_device_list) {
device = g_list_nth_data(found_device_list, idx - 1);
if (NULL == device) {
- msgr("Find my device first");
+ msgr("Find local device first");
return RET_FAILURE;
}
}
mdg_device_info_get_device_id(device, &deviceid);
- mdg_device_info_get_ip(device, &address);
- msgp("Sent to [ID] %s [IP] %s", deviceid, address);
+ mdg_device_info_get_addr(device, &address);
+ msgp("Sent to [ID] %s [ADDR] %s", deviceid, address);
if (deviceid) {
free(deviceid);
deviceid = NULL;
address = NULL;
}
- ret = mdg_device_send_data(handle, device, (unsigned char *) message,
+ ret = mdg_device_send_data(handle, device, channel_id, (unsigned char *)message,
strlen(message), _send_data_finish_cb, NULL);
if (MDG_ERROR_NONE != ret)
msgr("Failed to Send Data: [ID] %s [IP] %s", deviceid, address);
return __send_data(idx);
}
-static int run_send_data_all(MManager *mm, struct menu_data *menu)
-{
- int count = 0;
-
- count = g_list_length(found_device_list);
-
- if (0 >= count) {
- msgr("No Device");
- return RET_SUCCESS;
- }
-
- for (int i = 1; i <= count; i++)
- __send_data(i);
-
- return RET_SUCCESS;
-}
-
-void _mowned_device_finish_cb(int result, void *user_data)
+void _invited_device_finish_cb(int result, void *user_data)
{
msgb("\rFind My Owned Devices Finished ret: [0x%X] [%s]", result,
mdg_error_to_string(result));
}
-bool _mowned_device_found_cb(mdg_device_h device, void *user_data)
+bool _invited_device_found_cb(mdg_device_h device, void *user_data)
{
- char *ip = NULL;
+ char *addr = NULL;
char *device_id = NULL;
mdg_device_type_e device_type;
mdg_device_info_get_device_id(device, &device_id);
- mdg_device_info_get_ip(device, &ip);
- mdg_device_info_get_device_type(device, &device_type);
+ mdg_device_info_get_addr(device, &addr);
+ mdg_device_info_get_type(device, &device_type);
- msgp("\r[ID] %s [IP] %s [Type] %s", device_id, ip,
+ msgp("\r[ID] %s [IP] %s [Type] %s", device_id, addr,
__device_type_to_string(device_type));
if (device_id)
free(device_id);
- if (ip)
- free(ip);
+ if (addr)
+ free(addr);
- my_devices_list = g_list_append(my_devices_list, device);
+ invited_device_list = g_list_append(invited_device_list, device);
return TRUE;
}
-static int run_devices_find_mowned_device(MManager *mm, struct menu_data *menu)
+static int run_devices_find_invited_device(MManager *mm, struct menu_data *menu)
{
int ret;
- int duration = 2;
+ int duration;
msg("Find My Owned Devices");
if (strlen(timeout))
duration = (unsigned short)strtol(timeout, NULL, 10);
- ret = mdg_device_find_mowned_device(handle, duration, _mowned_device_found_cb,
- _mowned_device_finish_cb, NULL);
+ ret = mdg_device_find(handle, duration, true, _invited_device_found_cb,
+ _invited_device_finish_cb, NULL);
if (MDG_ERROR_NONE != ret) {
msgr("Failed to Find My Owned Devices: [%s(0x%X)]",
mdg_error_to_string(ret), ret);
return RET_FAILURE;
}
- msg(" - mdg_device_find_mowned_device() ret: [0x%X] [%s]",
- ret, mdg_error_to_string(ret));
-
- if (my_devices_list) {
- g_list_free_full(my_devices_list, _destroy_mdg_device_info);
- my_devices_list = NULL;
- }
-
- return RET_SUCCESS;
-}
-
-int run_device_show_mowned_device(MManager *mm, struct menu_data *menu)
-{
- int ret;
- int count;
- mdg_device_h *devices = NULL;
-
- ret = mdg_device_get_found_mowned_devices(handle, &devices, &count);
- if (MDG_ERROR_NONE != ret) {
- msgr("Failed to Get Found Mowned Devices: [%s(0x%X)]",
- mdg_error_to_string(ret), ret);
- return RET_FAILURE;
- }
- msg(" - mdg_device_get_found_mowned_devices() ret: [0x%X] [%s]", ret,
- mdg_error_to_string(ret));
- for (int i = 0; i < count; i++) {
- char *device_id = NULL;
- char *ip = NULL;
- mdg_device_type_e device_type;
-
- mdg_device_info_get_device_id(devices[i], &device_id);
- mdg_device_info_get_ip(devices[i], &ip);
- mdg_device_info_get_device_type(devices[i], &device_type);
-
- msgb("\n[ID] %s [IP] %s [Type] %s", device_id, ip,
- __device_type_to_string(device_type));
+ msg(" - mdg_device_find_invited_device() ret: [0x%X] [%s]",
+ ret, mdg_error_to_string(ret));
- if (device_id)
- free(device_id);
- if (ip)
- free(ip);
+ if (invited_device_list) {
+ g_list_free_full(invited_device_list, _destroy_mdg_device_info);
+ invited_device_list = NULL;
}
return RET_SUCCESS;
static int run_request_create_group(MManager *mm, struct menu_data *menu)
{
int ret = 0;
- int dev_idx = 1;
int dev_count = 0;
mdg_device_h device = NULL;
return RET_SUCCESS;
}
+ int dev_idx;
if (device_idx != NULL && strlen(device_idx)) {
dev_idx = (unsigned short)strtol(device_idx, NULL, 10);
if (0 >= dev_idx) {
static int run_request_invite(MManager *mm, struct menu_data *menu)
{
int ret = 0;
- int grp_idx = 1;
- int dev_idx = 1;
int grp_count = 0;
int dev_count = 0;
mdg_device_h device = NULL;
return RET_SUCCESS;
}
+ int grp_idx;
if (group_idx != NULL && strlen(group_idx)) {
grp_idx = (unsigned short)strtol(group_idx, NULL, 10);
if (0 >= grp_idx) {
}
}
+ int dev_idx;
if (device_idx != NULL && strlen(device_idx)) {
dev_idx = (unsigned short)strtol(device_idx, NULL, 10);
if (0 >= dev_idx) {
return RET_SUCCESS;
}
-static int run_request_delete_group(MManager *mm, struct menu_data *menu)
+void __channel_cb(int result, mdg_device_h device, char *channel_id,
+ unsigned char *arg, int len, void *user_data)
{
- int ret = 0;
- int grp_count = 0;
- mdg_group_h group = NULL;
-
- grp_count = g_list_length(found_group_list);
-
- if (0 >= grp_count) {
- msgr("No Device");
- return RET_SUCCESS;
- }
-
- int grp_idx;
- if (group_idx != NULL && strlen(group_idx)) {
- grp_idx = (unsigned short)strtol(group_idx, NULL, 10);
- if (0 >= grp_idx) {
- msgp("Invalid index. set to 1");
- grp_idx = 1;
- }
- }
+ msg("[%s] channel callback is called by remote send message", channel_id);
+ msg("result is %d", result);
+}
- if (found_group_list) {
- group = g_list_nth_data(found_group_list, grp_idx - 1);
- if (NULL == group) {
- msgr("Failed to g_hash_table_find");
- return RET_FAILURE;
- }
- }
+static int run_regist_channel(MManager *mm, struct menu_data *menu)
+{
+ int ret = 0;
- ret = mdg_request_delete_group(handle, group, receive_request_result, NULL);
- if (MDG_ERROR_NONE != ret) {
- msgr("Failed to Request Delete Group: [%s(0x%X)]",
- mdg_error_to_string(ret), ret);
- return RET_FAILURE;
- }
+ ret = mdg_device_regist_channel(handle, channel_id, __channel_cb, NULL);
- msg(" - mdg_request_delete_group() ret: [0x%X] [%s]",
- ret, mdg_error_to_string(ret));
+ msg(" - mdg_device_regist_channel() ret: [0x%X] [%s]", ret, mdg_error_to_string(ret));
return RET_SUCCESS;
}
-static void device_monitor_result(char *uuid, char *group_name,
- mdg_device_status_e status, void *user_data)
+static int run_unregist_channel(MManager *mm, struct menu_data *menu)
{
- msgp("device monitor result uuid %s group_name %s status %s", uuid,
- group_name, status == MDG_DEVICE_ADDED ? "ADDED" : "REMOVED");
-}
+ int ret = 0;
-static int run_start_device_monitor(MManager *mm, struct menu_data *menu)
-{
- int ret;
+ ret = mdg_device_unregist_channel(handle, channel_id);
+
+ msg(" - mdg_unregist_channel() ret: [0x%X] [%s]", ret, mdg_error_to_string(ret));
- if (g_strcmp0(monitor, "1") == 0) {
- msg(" - Start device monitor");
- ret = mdg_device_monitor_start(handle, device_monitor_result,
- NULL);
- if (MDG_ERROR_NONE != ret) {
- msgr("Failed to Start Monitor: [%s(0x%X)]",
- mdg_error_to_string(ret), ret);
- return RET_FAILURE;
- }
- } else {
- msg(" - Stop device monitor");
- ret = mdg_device_monitor_stop(handle);
- if (MDG_ERROR_NONE != ret) {
- msgr("Failed to Stop Monitor: [%s(0x%X)]",
- mdg_error_to_string(ret), ret);
- return RET_FAILURE;
- }
- }
return RET_SUCCESS;
}
-
static struct menu_data menu_group_create[] = {
{ "0", "Group Name", NULL, NULL, groupid },
{ "1", "Run", NULL, run_group_create, NULL },
{ NULL, NULL, },
};
-static struct menu_data menu_group_join[] = {
- { "0", "Show Found Group(s)", NULL, run_group_show, NULL },
- { "1", "Index", NULL, NULL, group_idx },
- { "2", "Run", NULL, run_group_join, NULL },
- { NULL, NULL, },
-};
-
-static struct menu_data menu_group_leave[] = {
- { "0", "Show Found Group(s)", NULL, run_group_show, NULL },
- { "1", "Index", NULL, NULL, group_idx },
- { "2", "Run", NULL, run_group_leave, NULL },
- { NULL, NULL, },
-};
-
static struct menu_data menu_group_delete[] = {
{ "0", "Show Found Group(s)", NULL, run_group_show, NULL },
{ "1", "Index", NULL, NULL, group_idx },
{ "2", "Run", NULL, run_group_delete, NULL },
{ NULL, NULL, },
};
-#if 0
-static struct menu_data menu_group_merge[] = {
- { "0", "Show Found Group(s)", NULL, run_group_show, NULL },
- { "1", "A Index", NULL, NULL, group_idx_a },
- { "2", "B Index", NULL, NULL, group_idx_b },
- { "3", "Run", NULL, run_group_merge, NULL },
- { NULL, NULL, },
-};
-#endif
+
static struct menu_data menu_devices_find[] = {
{ "0", "Timeout", NULL, NULL, timeout },
{ "1", "Run", NULL, run_devices_find, NULL },
};
static struct menu_data menu_send_data[] = {
- { "0", "Show My Owned Device(s)", NULL, run_device_show_mowned_device, NULL },
+ { "0", "Show My Owned Device(s)", NULL, run_invited_devices_show, NULL },
{ "1", "Message", NULL, NULL, message },
- { "2", "Device Index", NULL, NULL, device_idx },
- { "3", "Send (Unicast)", NULL, run_send_data, NULL },
- { "4", "Send (Broadcast)", NULL, run_send_data_all, NULL },
+ { "2", "Channel Name", NULL, NULL, channel_id },
+ { "3", "Device Index", NULL, NULL, device_idx },
+ { "4", "Send", NULL, run_send_data, NULL },
{ NULL, NULL, },
};
-static struct menu_data menu_devices_find_mownd_device[] = {
+static struct menu_data menu_devices_find_invited_device[] = {
{ "0", "Timeout", NULL, NULL, timeout },
- { "1", "Run", NULL, run_devices_find_mowned_device, NULL },
+ { "1", "Run", NULL, run_devices_find_invited_device, NULL },
{ NULL, NULL, },
};
{ NULL, NULL, },
};
-static struct menu_data menu_request_delete_group[] = {
- { "0", "Show Found Group(s)", NULL, run_group_show, NULL },
- { "1", "Group Index", NULL, NULL, group_idx },
- { "2", "Run", NULL, run_request_delete_group, NULL },
+static struct menu_data menu_regist_channel[] = {
+ { "0", "Channel ID", NULL, NULL, channel_id },
+ { "1", "Run", NULL, run_regist_channel, NULL },
{ NULL, NULL, },
};
-static struct menu_data menu_monitor[] = {
- { "1", "Input 1 to Start and 2 to Stop Monitor", NULL, NULL, monitor },
- { "2", "Start/Stop Device Monitor", NULL, run_start_device_monitor, NULL },
+static struct menu_data menu_unregist_channel[] = {
+ { "0", "Channel ID", NULL, NULL, channel_id },
+ { "1", "Run", NULL, run_unregist_channel, NULL },
{ NULL, NULL, },
};
struct menu_data menu_mdg_manager[] = {
- { "0", "Show My Device ID", NULL, run_get_my_id, NULL },
- { "1", "Show My Device", NULL, run_device_show_my_device, NULL },
- { "2", "Create Group", menu_group_create, NULL, NULL },
- { "3", "Find Group(s)", menu_group_find, NULL, NULL },
- { "4", "Show Found Group(s)", NULL, run_group_show_found , NULL },
- { "5", "Join Group (Not yet developed)", menu_group_join, NULL, NULL },
- { "6", "Leave Group (Not yet developed)", menu_group_leave, NULL, NULL },
- { "7", "Delete Group", menu_group_delete, NULL, NULL },
- { "8", "Find Device(s)", menu_devices_find, NULL, NULL },
- { "9", "Show Found Device(s)", NULL, run_device_show_found, NULL },
- { "10", "Invite Device", menu_group_invite_device, NULL, NULL },
- { "11", "Eject Device", menu_group_eject_device, NULL, NULL },
- { "12", "Find My Owned Device(s)", menu_devices_find_mownd_device, NULL, NULL },
- { "13", "Show My Owned Device(s)", NULL, run_device_show_mowned_device, NULL},
- { "14", "Send Message", menu_send_data, NULL, NULL },
- { "15", "Request Create Group", menu_request_create_group, NULL, NULL },
- { "16", "Request Invite", menu_request_invite, NULL, NULL },
- { "17", "Request Eject", menu_request_eject, NULL, NULL },
- { "18", "Request Delete Group (Not yet developed)", menu_request_delete_group,
- NULL, NULL },
- { "19", "Start/Stop Device Monitor", menu_monitor, NULL, NULL },
- { NULL, NULL, },
+ { "1", "Show Local Device", NULL, run_device_show_local_device, NULL }, // O
+ { "2", "Create Group", menu_group_create, NULL, NULL }, // 0
+ { "3", "Find Group(s)", menu_group_find, NULL, NULL }, // 0
+ { "4", "Show Group(s)", NULL, run_group_show, NULL }, // 0
+ { "5", "Delete Group", menu_group_delete, NULL, NULL }, // 0
+ { "6", "Find Device(s)", menu_devices_find, NULL, NULL }, // 0
+ { "7", "Show Device(s)", NULL, run_devices_show, NULL }, // 0
+ { "8", "Invite Device", menu_group_invite_device, NULL, NULL }, // 0
+ { "9", "Eject Device", menu_group_eject_device, NULL, NULL }, // 0
+ { "10", "Find Invited Device(s)", menu_devices_find_invited_device, NULL, NULL }, // 0
+ { "11", "Show Invited Device(s)", NULL, run_invited_devices_show, NULL }, // 0
+ { "12", "Request Create Group", menu_request_create_group, NULL, NULL },
+ { "13", "Request Invite", menu_request_invite, NULL, NULL },
+ { "14", "Request Eject", menu_request_eject, NULL, NULL },
+ { "15", "Regist Channel", menu_regist_channel, NULL, NULL },
+ { "16", "Unregist Channel", menu_unregist_channel, NULL, NULL },
+ { "17", "Get Channel(s)", NULL, run_invited_devices_show, NULL },
+ { "18", "Send Message", menu_send_data, NULL, NULL }, // 0
};
+++ /dev/null
-/*
- * 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 <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#include <glib.h>
-#include <sys/time.h>
-
-#include <mdg.h>
-
-#define BUFFER_LEN 100
-#define TEST_CASE_MAX 10
-
-#define PRT(format, args...) printf("%s:%d() "format, __FUNCTION__, __LINE__, ##args)
-#define TC_PRT(format, args...) PRT(format"\n", ##args)
-
-#define BEGIN() TC_PRT("BEGIN");
-#define END() TC_PRT("END");
-
-GMainLoop *main_loop = NULL;
-
-typedef struct {
- const char *tc_name;
- int tc_code;
- int (*tc_func)(void);
-} tc_table_t;
-
-GList *found_group_list;
-GList *found_device_list;
-
-mdg_h handle = NULL;
-
-#define CASE_TO_STR(x) case x: return #x;
-static const char* __device_type_to_string(mdg_device_type_e type)
-{
- switch (type) {
- /* CHECK: List all enum values here */
- CASE_TO_STR(MDG_DEVICE_TYPE_LOCAL)
- CASE_TO_STR(MDG_DEVICE_TYPE_REMOTE)
- default :
- return "MDG_DEVICE_TYPE_ERROR";
- }
-}
-
-static bool test_get_user_int(const char *msg, int *num)
-{
- if (msg == NULL || num == NULL)
- return false;
-
- int rv;
- char buf[32] = { 0, };
- printf("%s\n", msg);
- rv = read(0, buf, 32);
-
- if (rv < 0 || *buf == 0 || *buf == '\n' || *buf == '\r')
- return false;
-
- *num = atoi(buf);
- return true;
-}
-
-static bool test_get_user_string(const char *msg, char *buf, int buf_size)
-{
- if (msg == NULL || buf == NULL || buf_size < 2)
- return false;
-
- int rv;
- printf("%s\n", msg);
- memset(buf, 0, buf_size);
- rv = read(0, buf, buf_size - 1);
-
- if (rv < 0 || buf[0] == '\0' || buf[0] == '\n' || buf[0] == '\r') {
- buf[0] = '\0';
- return false;
- }
-
- if (rv >= 0)
- buf[rv] = '\0';
-
- return true;
-}
-
-int mdg_initialize_test(void)
-{
- int ret = 0;
-
- BEGIN();
-
- ret = mdg_initialize(&handle);
-
- if (ret == 0)
- TC_PRT("Initialize successful");
- else
- TC_PRT("Initialize failed, ret [%d]", ret);
-
- END();
- return ret;
-}
-
-int mdg_group_create_test(void)
-{
- int ret = 0;
- char input_str[50] = {0, };
- mdg_h handle = NULL;
-
- BEGIN();
-
- if (test_get_user_string("Input group name(ex - GROUP123)"
- " - (Enter for skip) :", input_str, 50)) {
- g_strstrip(input_str);
- } else {
- TC_PRT("Invalid Input !!![%s]", input_str);
- END();
- return -1;
- }
-
- ret = mdg_group_create(handle, input_str);
-
- if (ret == 0)
- TC_PRT("Group create successful");
- else
- TC_PRT("Group create failed, ret [%d]", ret);
-
- END();
- return ret;
-}
-
-bool _group_found_cb(mdg_group_type_e type, mdg_group_h group, void *user_data)
-{
- char *uri_path;
-
- mdg_group_info_get_uri_path(group, &uri_path);
-
- TC_PRT("found group type : %d, uri : %s", type, uri_path);
-
- found_group_list = g_list_append(found_group_list, group);
-}
-
-void _group_finish_cb(int result, void *user_data)
-{
- TC_PRT("find operation finished");
-}
-
-int mdg_group_find_test(void)
-{
- int ret = 0;
- int input_int = 0;
-
- BEGIN();
- found_group_list = NULL;
-
- if (!test_get_user_int("==> Input timeout value (sec)"
- " - (Enter for skip) :", &input_int)) {
- input_int = 5;
- TC_PRT("default timeout value [%d]", input_int);
- }
-
- mdg_group_find(handle, input_int, _group_found_cb, _group_finish_cb, NULL);
-
- if (ret == 0)
- TC_PRT("group find successful");
- else
- TC_PRT("group find failed, ret [%d]", ret);
-
- END();
- return ret;
-}
-
-int mdg_group_get_found_groups_test(void)
-{
- int ret = 0;
- int count;
- mdg_group_h *groups;
-
- BEGIN();
-
- found_group_list = NULL;
-
- ret = mdg_group_get_found_groups(handle, &groups, &count);
-
- if (ret == 0)
- TC_PRT("group find successful");
- else
- TC_PRT("group find failed, ret [%d]", ret);
-
- TC_PRT("Found group count : %d", count);
-
- for (int i = 0; i < count; i++) {
- mdg_group_type_e type;
- char *uri_path;
- mdg_group_info_get_type(groups[i], &type);
- mdg_group_info_get_uri_path(groups[i], &uri_path);
- TC_PRT("%d. type : %d, uri path : %s", i+1, type, uri_path);
- found_group_list = g_list_append(found_group_list, groups[i]);
- }
-
- END();
- return ret;
-}
-
-bool _device_found_cb(mdg_device_h device, void *user_data)
-{
- char *device_id;
- char *ip;
- mdg_device_type_e device_type;
-
- mdg_device_info_get_device_id(device, &device_id);
- mdg_device_info_get_ip(device, &ip);
- mdg_device_info_get_device_type(device, &device_type);
-
- TC_PRT("found device device_id : %s, ip : %s, device_type : %s", device_id, ip,
- __device_type_to_string(device_type));
-
- found_device_list = g_list_append(found_device_list, device);
-}
-
-int mdg_device_find_test(void)
-{
- int ret = 0;
- int input_int = 0;
-
- BEGIN();
- found_device_list = NULL;
-
- if (!test_get_user_int("==> Input timeout value (sec)"
- " - (Enter for skip) :", &input_int)) {
- input_int = 5;
- TC_PRT("default timeout value [%d]", input_int);
- }
-
- mdg_device_find(handle, input_int, _device_found_cb, _group_finish_cb, NULL);
-
- if (ret == 0)
- TC_PRT("device find successful");
- else
- TC_PRT("device find failed, ret [%d]", ret);
-
- END();
- return ret;
-}
-
-int mdg_device_get_found_devices_test(void)
-{
- int ret = 0;
- int count = 0;
- mdg_device_h *devices;
-
- BEGIN();
-
- found_device_list = NULL;
-
- ret = mdg_device_get_found_devices(hadnle, &devices, &count);
-
- if (ret == 0)
- TC_PRT("device find successful");
- else
- TC_PRT("device find failed, ret [%d]", ret);
-
- TC_PRT("Found device count : ", count);
-
- for (int i = 0; i < count; i++) {
- char *uuid;
- char *ip;
- mdg_device_type_e device_type;
-
- mdg_device_info_get_device_id(devices[i], &uuid);
- mdg_device_info_get_ip(devices[i], &ip);
- mdg_device_info_get_device_type(devices[i], &device_type);
-
- TC_PRT("%d. uuid : %s, ip : %s, device_type : %s", i+1, uuid, ip,
- __device_type_to_string(device_type));
- found_device_list = g_list_append(found_device_list, devices[i]);
- }
-
- END();
- return ret;
-}
-
-void _device_invite_result_cb(int result, void *user_data)
-{
- TC_PRT("Invite complete !!!! ret : %d", result);
-}
-
-int mdg_device_invite_test(void)
-{
- int ret = 0;
- BEGIN();
-
- /* using stored group list and device list */
- if (g_list_length(found_device_list) > 0 && g_list_length(found_group_list) > 0) {
- TC_PRT("Invite Test Start");
- mdg_group_h group = (mdg_group_h)(found_group_list[0].data);
- mdg_device_h device = (mdg_device_h)(found_device_list[0].data);
-
- mdg_group_invite_device(handle, group, device, "12341234", _device_invite_result_cb, NULL);
-
- } else {
- TC_PRT("not exist found group or device list");
- }
-
- END();
- return ret;
-}
-
-void _device_eject_result_cb(int result, void *user_data)
-{
- TC_PRT("eject complete !!!! ret : %d", result);
-}
-
-int mdg_device_eject_test(void)
-{
- int ret = 0;
- BEGIN();
-
- /* using stored group list and device list */
- if (g_list_length(found_device_list) > 0 && g_list_length(found_group_list) > 0) {
- TC_PRT("Invite Test Start");
- mdg_group_h group = (mdg_group_h)(found_group_list[0].data);
- mdg_device_h device = (mdg_device_h)(found_device_list[0].data);
-
- /* using stored group list and device list */
- mdg_group_eject_device(handle, group, device, _device_eject_result_cb, NULL);
- } else {
- TC_PRT("not exist found group or device list");
- }
-
-
- END();
- return ret;
-}
-
-//send_data_callback : if the remote device not invited, then callback is called include result failed.
-//send_data_callback : if the remote device invited, then callback result successful.
-
-int mdg_send_data_to_remote_device_test(void)
-{
- int ret = 0;
- BEGIN();
-
- if (g_list_length(found_device_list) > 0) {
- mdg_device_h device = (mdg_device_h)(found_device_list[0].data);
- ret = mdg_device_send_data(handle, device, "123", NULL, NULL);
- } else {
- TC_PRT("not exist found device list");
- }
-
- END();
- return ret;
-}
-
-int mdg_deinitialize_test(void)
-{
- int ret = 0;
-
- BEGIN();
-
- ret = mdg_deinitialize(handle);
-
- if (ret == 0)
- TC_PRT("Initialize successful");
- else
- TC_PRT("Initialize failed, ret [%d]", ret);
-
- END();
- return ret;
-}
-
-tc_table_t tc_table[] = {
- /* manager api */
- {"mdg_initialize_test", 1, mdg_initialize_test},
- {"mdg_group_create_test", 2, mdg_group_create_test},
- {"mdg_group_find_test", 3, mdg_group_find_test},
- {"mdg_group_get_found_groups_test", 4, mdg_group_get_found_groups_test},
- {"mdg_device_find_test", 5, mdg_device_find_test},
- {"mdg_device_get_found_devices_test", 6, mdg_device_get_found_devices_test},
- {"mdg_device_invite_test", 7, mdg_device_invite_test},
- {"mdg_device_eject_test", 8, mdg_device_eject_test},
- {"mdg_send_data_to_remote_device_test", 9, mdg_send_data_to_remote_device_test},
- {"mdg_deinitialize_test", TEST_CASE_MAX, mdg_deinitialize_test},
-
- /*-----------*/
- {"Finish", 0x0000, NULL},
- {NULL, 0x00ff, NULL},
-};
-
-static void tc_usage_print(void)
-{
- int i = 0;
-
- while (tc_table[i].tc_name) {
- if (tc_table[i].tc_code != 0x00ff)
- printf("Key [%2d] : usage %s\n", tc_table[i].tc_code, tc_table[i].tc_name);
- else
- printf("Key [%2d] : usage %s\n\n", 0x00ff, tc_table[i].tc_name);
-
- i++;
- }
-}
-
-static int test_input_callback(void *data)
-{
- long test_id = (long)data;
- int ret = 0;
-
- if ((test_id >= 1) && (test_id <= TEST_CASE_MAX)) {
- TC_PRT("test_input_callback test_id : %ld", test_id);
-
- if (tc_table[test_id-1].tc_func != NULL) {
- ret = tc_table[test_id-1].tc_func();
-
- if (ret != 0)
- TC_PRT(">>>>> Test Error Returned !!! : %d", ret);
- }
- }
-
- return 0;
-}
-
-static int test_terminate(void)
-{
- int ret = 0;
-
- TC_PRT("Finished");
-
- mdg_deinitialize_test();
- g_main_loop_quit(main_loop);
-
- return ret;
-}
-
-static gboolean key_event_cb(GIOChannel *chan, GIOCondition cond, gpointer data)
-{
- char buf[BUFFER_LEN] = {0,};
- long test_id;
- int rv = 0;
-
- memset(buf, 0, sizeof(buf));
-
- rv = read(0, buf, 100);
-
- if (rv < 0 || buf[0] == '0') {
- test_terminate();
- exit(1);
- }
-
- if (*buf == '\n' || *buf == '\r')
- tc_usage_print();
-
- test_id = atoi(buf);
-
- test_input_callback((void *)test_id);
-
- return TRUE;
-}
-
-
-int main(int argc, char ** argv)
-{
- GIOChannel *key_io;
-
- main_loop = g_main_loop_new(NULL, FALSE);
- key_io = g_io_channel_unix_new(0);
-
- printf("Test Thread created...\n");
-
- g_io_add_watch(key_io, (G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL), key_event_cb, NULL);
- g_main_loop_run(main_loop);
-
- g_io_channel_unref(key_io);
- g_main_loop_unref(main_loop);
-
- return 0;
-}
projects / platform / core / api / multi-device-group.git / commitdiff