* @see mdg_group_info_get_resource_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_clone(mdg_group_h *dst,
* @see mdg_group_info_get_resource_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_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_resource_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_type(mdg_group_h group, mdg_group_type_e *type);
* @see mdg_group_info_get_type()
* @see mdg_group_info_get_resource_type()
* @see mdg_group_info_get_uri_path()
- * @see mdg_group_info_get_host_addr()
*
*/
int mdg_group_info_get_name(mdg_group_h group, char **name);
unsigned char *data, int len,
mdg_device_send_data_finish_cb finish_cb, void *user_data);
-typedef void (*mdg_send_file_progress_cb)(const char *file_path, long send_size,
- long total_size, int percent, void *user_data);
-typedef void (*mdg_send_file_finish_cb)(int result, mdg_device_h device, void *user_data);
-
-int mdg_device_send_file(mdg_h handle, mdg_device_h device, char *file_path,
- mdg_send_file_progress_cb progress_cb, mdg_send_file_finish_cb finish_cb, void *user_data);
-
/**
* @}
*/
--- /dev/null
+/*
+ * Network Configuration Module
+ *
+ * Copyright (c) 2017 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.
+ *
+ */
+#ifndef __TIZEN_NETWORK_MULTI_DEVICE_GROUP_MDG_INTERNAL_H__
+#define __TIZEN_NETWORK_MULTI_DEVICE_GROUP_MDG_INTERNAL_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* File transfer for Client Side */
+typedef void (*mdg_send_file_progress_cb)(const char *file_path, long send_size,
+ long total_size, int percent, void *user_data);
+typedef void (*mdg_send_file_finish_cb)(int result, mdg_device_h device, void *user_data);
+
+int mdg_device_send_file(mdg_h handle, mdg_device_h device, char *file_path,
+ mdg_send_file_progress_cb progress_cb, mdg_send_file_finish_cb finish_cb, void *user_data);
+
+/* File transfer for Server Side */
+typedef void (*mdg_receive_file_cb)(int result, char *device_id,
+ const char *file_path, void *user_data);
+
+int mdg_set_receive_file_cb(mdg_h handle, mdg_receive_file_cb receive_cb, void *user_data);
+int mdg_unset_receive_file_cb(mdg_h handle);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __TIZEN_NETWORK_MULTI_DEVICE_GROUP_MDG_H__ */
+
_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->addr,
- dev->secure_port, channel_id, params, &ret, NULL, &error);
+ group_call_send_data_sync(_handle->group_proxy, dev->device_id,
+ channel_id, params, &ret, NULL, &error);
if (error) {
_ERR("Failed DBus call [%s]", error->message);
g_error_free(error);
_handle->send_file_cb.device = cloned_device;
_handle->send_file_cb.user_data = user_data;
- group_call_send_file_sync(_handle->group_proxy, dev->device_id, dev->addr,
- dev->secure_port, file_path, &ret, NULL, &error);
+ group_call_send_file_sync(_handle->group_proxy, dev->device_id, file_path, &ret, NULL, &error);
if (error) {
_ERR("Failed DBus call [%s]", error->message);
g_error_free(error);
return ret;
}
+EXPORT_API int mdg_set_receive_file_cb(mdg_h handle,
+ mdg_receive_file_cb receive_cb, void *user_data)
+{
+ 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);
+ CHECK_HANDLE_IS_VALID(handle);
+
+ _handle->receive_file_cb.receive_cb = receive_cb;
+ _handle->receive_file_cb.user_data = user_data;
+
+ return ret;
+}
+
+EXPORT_API int mdg_unset_receive_file_cb(mdg_h handle)
+{
+ 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);
+ CHECK_HANDLE_IS_VALID(handle);
+
+ _handle->receive_file_cb.receive_cb = NULL;
+ _handle->receive_file_cb.user_data = NULL;
+
+ return ret;
+}
+
EXPORT_API int mdg_device_get_local_device(mdg_h handle,
mdg_device_h *device)
{
if (src->device_id)
dst->device_id = g_strdup(src->device_id);
- if (src->host_addr)
- dst->host_addr = g_strdup(src->host_addr);
-
if (src->group_name)
dst->group_name = g_strdup(src->group_name);
g_free(group->device_id);
group->device_id = NULL;
}
- if (group->host_addr) {
- g_free(group->host_addr);
- group->host_addr = NULL;
- }
if (group->group_name) {
g_free(group->group_name);
group->group_name = NULL;
return ret;
}
-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);
-
- *host_addr = g_strdup(((mdg_group_s *)group)->host_addr);
-
- return ret;
-}
-
EXPORT_API int mdg_group_info_get_type(mdg_group_h group,
mdg_group_type_e *type)
{
if (src->device_id)
dst->device_id = g_strdup(src->device_id);
- if (src->addr)
- dst->addr = g_strdup(src->addr);
-
- dst->port = src->port;
- dst->secure_port = src->secure_port;
- dst->conn_type = src->conn_type;
-
if (src->model_name)
dst->model_name = g_strdup(src->model_name);
device->device_id = NULL;
}
- if (device->addr) {
- g_free(device->addr);
- device->addr = NULL;
- }
-
if (device->model_name) {
g_free(device->model_name);
device->model_name = NULL;
return ret;
}
-EXPORT_API int mdg_device_info_get_addr(
- mdg_device_h device, char **addr)
-{
- int ret = MDG_ERROR_NONE;
-
- CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
-
- *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_secure_port(
- mdg_device_h device, int *secure_port)
-{
- int ret = MDG_ERROR_NONE;
-
- CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
-
- *secure_port = (((mdg_device_s *)device)->secure_port);
-
- return ret;
-}
-
EXPORT_API int mdg_device_info_get_model_name(
mdg_device_h device, char **model_name)
{
_DBG("Device id : %s", dev->device_id);
- group_call_request_create_group_sync(_handle->group_proxy, dev->device_id, dev->addr,
- dev->secure_port, group_name, &ret, NULL, &error);
+ group_call_request_create_group_sync(_handle->group_proxy, dev->device_id,
+ group_name, &ret, NULL, &error);
return ret;
}
_DBG("%s", grp->group_name);
_DBG("%s", dev->device_id);
- group_call_request_invite(_handle->group_proxy, grp->device_id, dev->addr,
- dev->secure_port, grp->group_name, dev->device_id, PIN, NULL, NULL, &error);
+ group_call_request_invite(_handle->group_proxy, grp->device_id,
+ grp->group_name, dev->device_id, PIN, NULL, NULL, &error);
if (error) {
_ERR("Failed DBus call [%s]", error->message);
g_error_free(error);
_DBG("%s", grp->group_name);
_DBG("%s", dev->device_id);
- group_call_request_eject(_handle->group_proxy, grp->device_id, dev->addr,
- dev->secure_port, grp->group_name, dev->device_id, NULL, NULL, &error);
+ group_call_request_eject(_handle->group_proxy, grp->device_id,
+ grp->group_name, dev->device_id, NULL, NULL, &error);
if (error) {
_ERR("Failed DBus call [%s]", error->message);
g_error_free(error);
_DBG("%s", dev->device_id);
- group_call_request_channel_list(_handle->group_proxy, dev->device_id, dev->addr,
- dev->secure_port, NULL, NULL, &error);
+ group_call_request_channel_list(_handle->group_proxy, dev->device_id, NULL, NULL, &error);
if (error) {
_ERR("Failed DBus call [%s]", error->message);
g_error_free(error);
}
break;
}
+ case MDG_EVENT_RECEIVE_FILE:
+ {
+ if (handle->receive_file_cb.receive_cb) {
+ char *device_id;
+ char *file_path;
+ mdg_get_receive_file_from_variant(va, &device_id, &file_path);
+ handle->receive_file_cb.receive_cb(ret, device_id, file_path,
+ handle->receive_file_cb.user_data);
+ } else {
+ _ERR("The callback not exists");
+ }
+ }
default:
_ERR("Unknown Event");
break;
</method>
<method name="SendData">
<arg type="s" name="uuid" direction="in" />
- <arg type="s" name="addr" direction="in"/>
- <arg type="i" name="port" direction="in"/>
<arg type="s" name="channel_id" direction="in"/>
<arg type="(iay)" name="data" direction="in"/>
<arg type="i" name="result" direction="out" />
</method>
<method name="SendFile">
<arg type="s" name="uuid" direction="in" />
- <arg type="s" name="addr" direction="in"/>
- <arg type="i" name="port" direction="in"/>
<arg type="s" name="file_path" direction="in"/>
<arg type="i" name="result" direction="out" />
</method>
<method name="RequestCreateGroup">
<arg type="s" name="uuid" direction="in" />
- <arg type="s" name="addr" direction="in"/>
- <arg type="i" name="port" direction="in"/>
<arg type="s" name="group_name" direction="in" />
<arg type="i" name="result" direction="out" />
</method>
<method name="RequestInvite">
<arg type="s" name="uuid" direction="in" />
- <arg type="s" name="addr" direction="in"/>
- <arg type="i" name="port" direction="in"/>
<arg type="s" name="group_name" direction="in" />
<arg type="s" name="target_uuid" direction="in" />
<arg type="s" name="pin" direction="in" />
</method>
<method name="RequestEject">
<arg type="s" name="uuid" direction="in" />
- <arg type="s" name="addr" direction="in"/>
- <arg type="i" name="port" direction="in"/>
<arg type="s" name="group_name" direction="in" />
<arg type="s" name="target_uuid" direction="in" />
<arg type="i" name="result" direction="out" />
</method>
<method name="RequestChannelList">
<arg type="s" name="uuid" direction="in" />
- <arg type="s" name="addr" direction="in"/>
- <arg type="i" name="port" direction="in"/>
<arg type="i" name="result" direction="out" />
</method>
<!-- Signal (D-Bus) definitions -->
#include <glib.h>
#include <gio/gio.h>
#include <mdg.h>
+#include <mdg_internal.h>
#include <mdg_gdbus.h>
#include <mdg_debug.h>
-
#include <system_info.h>
#define MDG_FEATURE "http://tizen.org/feature/network.mdg"
void *user_data; /**< User data pointer */
} send_file_cb_t;
+typedef struct _receive_file_cb_t {
+ mdg_receive_file_cb receive_cb; /**< User callback to be called */
+ void *user_data; /**< User data pointer */
+} receive_file_cb_t;
+
/**
* @brief Sending internal commands to the device done callback structure
* @since_tizen 5.0
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 */
send_file_cb_t send_file_cb; /**< When it called after sending the device done or timeout */
+ receive_file_cb_t receive_file_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 */
request_channel_list_finish_cb_t request_channel_list_finish_cb; /**< When it called after sending private commands or timeout */
} mdg_manager_s;
*/
typedef struct _mdg_group_s {
char *device_id; /**< Device ID of the device has this group resource */
- char *host_addr; /**< Host address */
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 *addr; /**< Device IP */
- int port; /**< Port Number */
- int secure_port; /**< Secure Port Number */
- unsigned int conn_type; /**< Connection type */
char *model_name;
char *device_name;
char *platform_ver;
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;
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)
}
group->device_id = g_strdup(device_id);
- group->host_addr = g_strdup(host_addr);
group->group_name = g_strdup(group_name);
group->type = type;
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;
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->device_id = g_strdup(device_id);
- device->addr = g_strdup(addr);
- device->port = 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);
g_variant_iter_free(iter);
}
+void mdg_get_receive_file_from_variant(GVariant *va, char **device_id, char **file_path)
+{
+ GVariantIter *iter = NULL;
+ const gchar *key;
+ GVariant *key_value = NULL;
+
+ 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);
+ if (g_strcmp0(key, "FilePath") == 0)
+ *file_path = (char *)g_variant_get_string(key_value, NULL);
+ }
+
+ g_variant_iter_free(iter);
+}
+
GVariant *mdg_create_variant_device(mdg_device_s *device)
{
GVariant *va;
g_variant_builder_add(builder, "{sv}", "DeviceID",
g_variant_new_string(device->device_id));
- g_variant_builder_add(builder, "{sv}", "Port",
- g_variant_new_int32(device->port));
- g_variant_builder_add(builder, "{sv}", "Addr",
- g_variant_new_string(device->addr));
- g_variant_builder_add(builder, "{sv}", "ConnType",
- g_variant_new_int32(device->conn_type));
- g_variant_builder_add(builder, "{sv}", "SecurePort",
- g_variant_new_int32(device->secure_port));
g_variant_builder_add(builder, "{sv}", "ModelName",
g_variant_new_string(device->model_name));
g_variant_builder_add(builder, "{sv}", "DeviceName",
void mdg_get_channel_from_variant(GVariant *va, char **device_id, char **channel_id);
void mdg_get_data_from_variant(GVariant *va, char **device_id, char **channel_id,
unsigned char **data, int *data_len);
+void mdg_get_receive_file_from_variant(GVariant *va, char **device_id, char **file_path);
void mdg_get_progress_from_variant(GVariant *va, char **file_path,
long *send_size, long *total_size, int *percent);
#define __COMMON_H__
#include <mdg.h>
+#include <mdg_internal.h>
__BEGIN_DECLS
}
}
+static void _destroy_mdg_device_info(gpointer data)
+{
+ mdg_device_info_destroy((mdg_device_h)data);
+}
+
void receive_request_result(char *cmd, char *device_id, unsigned char *arg,
int len, int ret, void *user_data)
{
bool __group_foreach_cb(mdg_device_h device, void *user_data)
{
- char *addr;
char *device_id;
- mdg_device_info_get_addr(device, &addr);
mdg_device_info_get_device_id(device, &device_id);
- msgb("\rDevice is [%s], ADDR [%s]", device_id, addr);
+ msgb("\rDevice is [%s]", device_id);
+
+ found_invited_device_list = g_list_append(found_invited_device_list, device);
return true;
}
}
}
+ if (found_invited_device_list) {
+ g_list_free_full(found_device_list, _destroy_mdg_device_info);
+ found_invited_device_list = NULL;
+ }
+
ret = mdg_group_foreach_device(handle, group, __group_foreach_cb, NULL);
if (MDG_ERROR_NONE != ret) {
msgr("Failed to foreach device: [%s(0x%X)]", mdg_error_to_string(ret), ret);
return RET_SUCCESS;
}
-static void _destroy_mdg_device_info(gpointer data)
-{
- mdg_device_info_destroy((mdg_device_h)data);
-}
static int run_devices_show(MManager *mm, struct menu_data *menu)
{
}
char *model_name;
- char *addr;
+ char *device_id;
mdg_device_info_get_model_name(device, &model_name);
- mdg_device_info_get_addr(device, &addr);
+ mdg_device_info_get_device_id(device, &device_id);
- msgp("[%d] Model : %s, Addr : %s", i+1, model_name, addr);
+ msgp("[%d] Model : %s, Device ID : %s", i+1, model_name, device_id);
mdg_device_h cloned_device;
char *cloned_model_name;
- char *cloned_addr;
+ char *cloned_device_id;
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);
+ mdg_device_info_get_device_id(cloned_device, &cloned_device_id);
- msgp("*Cloned* [%d] Model : %s, Addr : %s", i+1, cloned_model_name, cloned_addr);
+ msgp("*Cloned* [%d] Model : %s, Device ID : %s", i+1, cloned_model_name, cloned_device_id);
if (model_name)
free(model_name);
- if (addr)
- free(addr);
+ if (device_id)
+ free(device_id);
if (cloned_model_name)
free(cloned_model_name);
- if (cloned_addr)
- free(cloned_addr);
+ if (cloned_device_id)
+ free(cloned_device_id);
mdg_device_info_destroy(cloned_device);
}
char *model_name;
- char *addr;
+ char *device_id;
+
+ mdg_device_info_get_device_id(device, &device_id);
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);
+ msgp("[%d] Device : %s, Model : %s", i+1, device_id, model_name);
if (model_name)
free(model_name);
- if (addr)
- free(addr);
+ if (device_id)
+ free(device_id);
/* Next item */
iter = g_list_next(iter);
gboolean is_exist = FALSE;
mdg_device_info_get_device_id(device, &device_id);
- mdg_device_info_get_addr(device, &addr);
mdg_device_info_get_model_name(device, &model_name);
mdg_device_info_get_type(device, &device_type);
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, addr,
+ msgp("\r[ID] %s [Type] %s [Name] %s", device_id,
__device_type_to_string(device_type), model_name);
}
return RET_SUCCESS;
}
+void __receive_file_cb(int result, char *device_id, const char *file_path, void *user_data)
+{
+ msgb("The %s is stored by %s", file_path, device_id);
+}
+
int run_device_show_local_device(MManager *mm, struct menu_data *menu)
{
int ret = 0;
if (ret == 0) {
char *device_id = NULL;
- char *addr = NULL;
- int port;
- int secure_port;
char *model_name;
char *device_name;
char *platform_ver;
mdg_device_type_e type;
mdg_device_info_get_device_id(device, &device_id);
- 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_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);
if (device_id)
free(device_id);
- if (addr)
- free(addr);
- if (model_name)
- free(model_name);
if (device_name)
free(device_name);
if (platform_ver)
device = NULL;
}
+
+ mdg_set_receive_file_cb(handle, __receive_file_cb, NULL);
+
return RET_SUCCESS;
}
}
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);
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);
+ msgp(" device_id: %s\n", device_id);
mdg_group_h cloned_group;
char *cloned_device_id;
- char *cloned_host_addr;
char *cloned_name;
mdg_group_type_e cloned_type;
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);
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);
+ msgp(" device_id: %s\n", cloned_device_id);
if (device_id)
free(device_id);
- if (host_addr)
- free(host_addr);
if (name)
free(name);
if (cloned_device_id)
free(cloned_device_id);
- if (cloned_host_addr)
- free(cloned_host_addr);
if (cloned_name)
free(cloned_name);
}
mdg_device_info_get_device_id(device, &deviceid);
- mdg_device_info_get_addr(device, &address);
- msgp("Sent to [ID] %s [ADDR] %s [CHANNEL ID] %s", deviceid, address, channel->channel_id);
+ msgp("Sent to [ID] %s [CHANNEL ID] %s", deviceid, channel->channel_id);
if (deviceid) {
free(deviceid);
deviceid = NULL;
}
void __send_file_finish_cb(int result, mdg_device_h device, void *user_data)
{
- char *addr;
+ char *device_id;
- mdg_device_info_get_addr(device, &addr);
+ mdg_device_info_get_device_id(device, &device_id);
- msgp("Send file to %s Finished [%s]", addr, mdg_error_to_string(result));
+ msgp("Send file to %s Finished [%s]", device_id, mdg_error_to_string(result));
}
static int __send_file(int devidx)
}
mdg_device_info_get_device_id(device, &deviceid);
- mdg_device_info_get_addr(device, &address);
- msgp("Sent to [ID] %s [ADDR] %s", deviceid, address);
+ msgp("Sent to [ID] %s", deviceid);
if (deviceid) {
free(deviceid);
deviceid = NULL;
bool _invited_device_found_cb(mdg_device_h device, void *user_data)
{
- 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_addr(device, &addr);
mdg_device_info_get_type(device, &device_type);
- msgp("\r[ID] %s [IP] %s [Type] %s", device_id, addr,
- __device_type_to_string(device_type));
+ msgp("\r[ID] %s [Type] %s", device_id, __device_type_to_string(device_type));
if (device_id)
free(device_id);
- if (addr)
- free(addr);
found_invited_device_list = g_list_append(found_invited_device_list, device);
projects / platform / core / api / multi-device-group.git / commitdiff