Adjust to latest mdg API

Change-Id: If6eaf16271574480d28fb2ac089919cd1075086b
Signed-off-by: Sangyoon Jang <jeremy.jang@samsung.com>

diff --git a/src/common/mdg_manager.cc b/src/common/mdg_manager.cc
index 19934f74eda6db89aaf0b3a10363ff1c2cb2aaa0..d64aa2b81edf226b6aa2f511469c58081e5be983 100644 (file)
--- a/src/common/mdg_manager.cc
+++ b/src/common/mdg_manager.cc
@@ -24,6 +24,7 @@ namespace {
 
 const int kRequestTimeout = 5;
 const char kGroupName[] = "capmgrgroup";
+const char kChannelId[] = "capmgrchannel";
 const char kPIN[] = "12341234";
 const std::map<int, std::string> kMDGErrorString = {
   {MDG_ERROR_NONE, "MDG_ERROR_NONE"},
@@ -42,7 +43,6 @@ const std::map<int, std::string> kMDGErrorString = {
   {MDG_ERROR_PLUGIN_FAIL, "MDG_ERROR_PLUGIN_FAIL"},
   {MDG_ERROR_ALREADY_IN_PROGRESS, "MDG_ERROR_ALREADY_IN_PROGRESS"},
   {MDG_ERROR_NOT_STARTED, "MDG_ERROR_NOT_STARTED"},
-  {MDG_ERROR_ALREADY_INITIALIZED, "MDG_ERROR_ALREADY_INITIALIZED"},
 };
 const char kSendDataCmd[] = "MDGD_REQ_SEND_DATA";
 
@@ -54,10 +54,9 @@ std::string MDGErrorToString(int error) {
     return it->second;
 }
 
-void SendDataFinishCb(int result, char *resp_data, void* user_data) {
+void SendDataFinishCb(int result, void* user_data) {
   LOG(INFO) << "SendDataFinishCb called."
-            << "result: " << result
-            << ", resp_data: " << resp_data;
+            << "result: " << result;
 }
 
 }  // namespace
@@ -87,14 +86,6 @@ bool MDGManager::Initialize() {
     return false;
   }
 
-  ret = mdg_device_monitor_start(mdg_handle_, &MDGManager::DeviceMonitorCb,
-      this);
-  if (ret != MDG_ERROR_NONE) {
-    LOG(ERROR) << "Failed to start device monitoring: "
-               << MDGErrorToString(ret);
-    return false;
-  }
-
   return true;
 }
 
@@ -127,13 +118,6 @@ void MDGManager::RequestCb(char* cmd, char* device_id, unsigned char* arg,
   }
 }
 
-void MDGManager::DeviceMonitorCb(char* uuid, char* group_name,
-    mdg_device_status_e status, void* user_data) {
-  LOG(INFO) << "Device monitored! uuid: " << uuid
-            << ", group_name: " << group_name
-            << ", status: " << status;
-}
-
 bool MDGManager::GroupFoundCb(mdg_group_type_e type, mdg_group_h group,
     void* user_data) {
   char* group_name;
@@ -150,8 +134,8 @@ bool MDGManager::GroupFoundCb(mdg_group_type_e type, mdg_group_h group,
     return false;
   }
 
-  if (type == MDG_GROUP_TYPE_MINE)
-    LOG(INFO) << "Found group type MINE: " << group_name;
+  if (type == MDG_GROUP_TYPE_LOCAL)
+    LOG(INFO) << "Found group type LOCAL: " << group_name;
   else
     LOG(INFO) << "Found group type REMOTE: " << group_name
               << " (" << group_addr << ")";
@@ -185,8 +169,8 @@ void MDGManager::GroupFinishCb(int result, void* user_data) {
     ret = mdg_group_info_get_type(group, &group_type);
     if (ret != MDG_ERROR_NONE)
       continue;
-    // if group is mine, we don't need to join
-    if (group_type == MDG_GROUP_TYPE_MINE) {
+    // if group is local, we don't need to join
+    if (group_type == MDG_GROUP_TYPE_LOCAL) {
       LOG(INFO) << "Found my group. I'm the owner device";
       return;
     }
@@ -200,19 +184,19 @@ void MDGManager::GroupFinishCb(int result, void* user_data) {
     // request join group (request invite)
     mdg_device_h owner_device = nullptr;
     for (auto& device : GListRange<mdg_device_h>(mdgmgr->device_list_)) {
-      char* device_ip;
-      int ret = mdg_device_info_get_ip(device, &device_ip);
+      char* device_addr;
+      int ret = mdg_device_info_get_addr(device, &device_addr);
       if (ret != MDG_ERROR_NONE)
         continue;
       // request to group owner only
       // to compare ipv6 address only, discard first 8 chars of gruop_addr:
       // format of group_addr: coap://[fe80::ae5a:14ff:fe24:b84e%25wlan0]:38720
-      if (!strncmp(group_addr + 8, device_ip, 25)) {
+      if (!strncmp(group_addr + 8, device_addr, 25)) {
         owner_device = device;
-        free(device_ip);
+        free(device_addr);
         break;
       }
-      free(device_ip);
+      free(device_addr);
     }
     free(group_addr);
 
@@ -232,28 +216,21 @@ void MDGManager::GroupFinishCb(int result, void* user_data) {
   LOG(INFO) << "Group not found. Create one";
   ret = mdg_group_create(mdgmgr->mdg_handle_, const_cast<char*>(kGroupName));
   if (ret != MDG_ERROR_NONE)
-    LOG(ERROR) << "Failed to create group: " << ret;
+    LOG(ERROR) << "Failed to create group: " << MDGErrorToString(ret);
 }
 
 bool MDGManager::DeviceFoundCb(mdg_device_h device, void* user_data) {
-  mdg_device_type_e device_type;
   char* device_id;
-  char* device_ip;
+  char* device_addr;
   char* model_name;
 
-  int ret = mdg_device_info_get_device_type(device, &device_type);
-  if (ret != MDG_ERROR_NONE) {
-    LOG(ERROR) << "Failed to get device id: " << MDGErrorToString(ret);
-    return true;
-  }
-
-  ret = mdg_device_info_get_device_id(device, &device_id);
+  int ret = mdg_device_info_get_device_id(device, &device_id);
   if (ret != MDG_ERROR_NONE) {
     LOG(ERROR) << "Failed to get device id: " << MDGErrorToString(ret);
     return true;
   }
 
-  ret = mdg_device_info_get_ip(device, &device_ip);
+  ret = mdg_device_info_get_addr(device, &device_addr);
   if (ret != MDG_ERROR_NONE) {
     LOG(ERROR) << "Failed to get device id: " << MDGErrorToString(ret);
     free(device_id);
@@ -263,22 +240,30 @@ bool MDGManager::DeviceFoundCb(mdg_device_h device, void* user_data) {
   ret = mdg_device_info_get_model_name(device, &model_name);
   if (ret != MDG_ERROR_NONE) {
     LOG(ERROR) << "Failed to get device id: " << MDGErrorToString(ret);
-    free(device_ip);
+    free(device_addr);
     free(device_id);
     return true;
   }
 
   LOG(INFO) << "Found device. "
             << "device_id: " << device_id
-            << ", device_ip: " << device_ip
+            << ", device_addr: " << device_addr
             << ", model_name: " << model_name;
 
   // need to check dup;
   MDGManager* mdgmgr = static_cast<MDGManager*>(user_data);
-  mdgmgr->device_list_ = g_list_append(mdgmgr->device_list_, device);
+  mdg_device_h dev_clone = nullptr;
+  ret = mdg_device_info_clone(&dev_clone, device);
+  if (ret != MDG_ERROR_NONE) {
+    LOG(ERROR) << "Failed to clone device info: " << MDGErrorToString(ret);
+    free(device_addr);
+    free(device_id);
+    return true;
+  }
+  mdgmgr->device_list_ = g_list_append(mdgmgr->device_list_, dev_clone);
 
   free(model_name);
-  free(device_ip);
+  free(device_addr);
   free(device_id);
 
   return true;
@@ -316,6 +301,7 @@ bool MDGManager::SendData(Command cmd, const std::string& data) {
   memcpy(p, data.c_str(), data.size());
   for (auto& device : GListRange<mdg_device_h>(device_list_)) {
     int ret = mdg_device_send_data(mdg_handle_, device,
+        const_cast<char*>(kChannelId),
         buf, datasize, SendDataFinishCb, this);
     if (ret != MDG_ERROR_NONE)
       LOG(ERROR) << "Failed to send data: " << MDGErrorToString(ret);
@@ -327,7 +313,7 @@ bool MDGManager::SendData(Command cmd, const std::string& data) {
 }
 
 void MDGManager::FindDevices() {
-  int ret = mdg_device_find(mdg_handle_, kRequestTimeout,
+  int ret = mdg_device_find(mdg_handle_, kRequestTimeout, false,
       &MDGManager::DeviceFoundCb, &MDGManager::DeviceFinishCb, this);
   if (ret != MDG_ERROR_NONE)
     LOG(ERROR) << "Failed to find device: " << MDGErrorToString(ret);

diff --git a/src/common/mdg_manager.h b/src/common/mdg_manager.h
index 32ff34b076bec915eade5270b97db3028c6d6f00..45f172f6f3c04417b309ea8438902ceab1f96a4f 100644 (file)
--- a/src/common/mdg_manager.h
+++ b/src/common/mdg_manager.h
@@ -41,8 +41,6 @@ class MDGManager : public ConnectionManager {
 
   static void RequestCb(char* cmd, char* device_id, unsigned char* arg,
       int len, int ret, void* user_data);
-  static void DeviceMonitorCb(char* uuid, char* group_name,
-      mdg_device_status_e status, void* user_data);
   static bool GroupFoundCb(mdg_group_type_e type, mdg_group_h group,
       void* user_data);
   static void GroupFinishCb(int result, void* user_data);