[Convergence] Fixed clientInfo in callback of start method

[Feature] Fixed filling clientInfo when calling start callback of
  client service (both for service found on other device with startDiscovery
  and for local service created with constructor)

Change-Id: If2d0e1808df46a8e41415a98e680c86ed0bedf59
Signed-off-by: Piotr Kosko <p.kosko@samsung.com>

diff --git a/src/convergence/convergence_api.js b/src/convergence/convergence_api.js
index 708fbc06b7850dcacb6c48dcf134350f5169b0ab..3d4650db12c46d9c32127fc73cbf66e6b7ff1d53 100644 (file)
--- a/src/convergence/convergence_api.js
+++ b/src/convergence/convergence_api.js
@@ -714,8 +714,9 @@ native_.addListener('APP_COMMUNICATION_SERVICE_LISTENER', function(result) {
       native_.callIfPossible(s._connectCallback, s);
       break;
     case 'onStart':
+      var clientInfo = (result.clientInfo ? new ClientInfo(result.clientInfo) : null);
       native_.callIfPossible(s._startCallback,
-        new ChannelInfo(result.channel.uri, result.channel.id), null);
+        new ChannelInfo(result.channel.uri, result.channel.id), clientInfo);
       break;
     case 'onPublish':
       native_.callIfPossible(s._sendCallback,

diff --git a/src/convergence/convergence_app_communication_service.cc b/src/convergence/convergence_app_communication_service.cc
index 4272e4eeb6aef44b6ec6bc7cdcf4cc7ed6679cbf..2b71890b5b86b76918384c2aaf5461815fefdc23 100644 (file)
--- a/src/convergence/convergence_app_communication_service.cc
+++ b/src/convergence/convergence_app_communication_service.cc
@@ -37,6 +37,7 @@ using common::TizenSuccess;
 
 namespace {
 static const std::string kChannel = "channel";
+static const std::string kClientInfo = "clientInfo";
 } // namespace
 
 ConvergenceAppCommunicationService::ConvergenceAppCommunicationService()
@@ -72,7 +73,7 @@ common::TizenResult ConvergenceAppCommunicationService::Start(
     return LogAndCreateTizenError(AbortError, "Service with specified type does not exist");
   }
 
-  UpdateListener(cur_listener_id);
+  UpdateListener(cur_listener_id, REMOTE_SERVICE_START);
 
   const int error = conv_service_start(service_handle, channel->GetHandle(), nullptr);
   if (CONV_ERROR_NONE != error) {
@@ -185,8 +186,11 @@ void ConvergenceAppCommunicationService::ServiceListenerCb(conv_service_h servic
   param[kChannel] = ConvergenceChannel::ToJson(channel_handle);
   param[kServiceResultType] = picojson::value(result_type);
 
-  if ((kServiceResultTypeOnStart == result_type)
-   || (kServiceResultTypeOnPublish == result_type)
+  if (kServiceResultTypeOnStart == result_type) {
+    if (callbackParam->client_info_) {
+      param[kClientInfo] = callbackParam->client_info_->ToJson();
+    }
+  } else if ((kServiceResultTypeOnPublish == result_type)
    || (kServiceResultTypeOnStop == result_type)) {
     // The service doesn't send any callback with thie response
   } else if (kServiceResultTypeOnMessage == result_type) {
@@ -194,10 +198,20 @@ void ConvergenceAppCommunicationService::ServiceListenerCb(conv_service_h servic
       ConvergencePayloadArray::ExtractPayloadString(result, "from")); // Define the string as a constant
     param[kPayload] = ConvergencePayloadArray::ToJson(result);
   } else if (kServiceResultTypeOnConnect == result_type) {
-    //param["clientInfo"] = ConvergenceClientInfo(result).ToJson();
-    //callbackParam->plugin_->ReplyAsync(kAppCommunicationClientServiceConnectCallback,
-    //  callbackParam->callback_id_, true, param);
-    return;
+    // just filling client_info_ member in CallbackParam
+    if (!callbackParam->client_info_) {
+      callbackParam->client_info_ = new ConvergenceClientInfo(result);
+    }
+    if (LOCAL_SERVICE_START != callbackParam->type_) {
+      // for non-local services just set clientInfo and not trigger callback
+      return;
+    } else {
+      // but trigger this callback for local services and pretend that this is onStart signal
+      param[kServiceResultType] = picojson::value(kServiceResultTypeOnStart);
+      if (callbackParam->client_info_) {
+        param[kClientInfo] = callbackParam->client_info_->ToJson();
+      }
+    }
   } else if (kServiceResultTypeOnClientConnect == result_type) {
     // TODO the service doesn't send any callback with thie response
     return; // TODO
@@ -217,7 +231,8 @@ void ConvergenceAppCommunicationService::ServiceListenerCb(conv_service_h servic
     callbackParam->callback_id_, true, param);
 }
 
-void ConvergenceAppCommunicationService::UpdateListener(const int cur_listener_id) {
+void ConvergenceAppCommunicationService::UpdateListener(const int cur_listener_id,
+                                                        ServiceRequestType type) {
   ScopeLogger();
 
   // TODO make sure that callback is not called twice for the same listener
@@ -255,7 +270,7 @@ void ConvergenceAppCommunicationService::UpdateListener(const int cur_listener_i
     free(sver);
   }
 
-  CallbackParam *param = new CallbackParam(convergence_plugin_, cur_listener_id);
+  CallbackParam *param = new CallbackParam(convergence_plugin_, cur_listener_id, type);
   const int error = conv_service_set_listener_cb(service_handle, ServiceListenerCb, param);
 
   if (CONV_ERROR_NONE != error) {
@@ -348,24 +363,24 @@ common::TizenResult ConvergenceAppCommunicationServerService::Start(
   const int cur_listener_id) {
   ScopeLogger();
 
+  LoggerI("Starting service [0x%x] with handle [0x%x]", this, service_handle_);
+  std::unique_ptr<ConvergenceChannel> ch_ptr(channel); // auto release memory in case of error
 
-  /* By implementation, the local App Communication Service doesn't send
-   * the callback confirming that the Start is successful.
-   * So we are sending this callback manually
-   */
-  picojson::object param;
-  param[kServiceListenerStatus] = picojson::value(kServiceListenerStatusOk);
+  conv_service_h service_handle = FindServiceHandle();
+  if (!service_handle) {
+    return LogAndCreateTizenError(AbortError, "Service with specified type does not exist");
+  }
 
-  param[kChannel] = ConvergenceChannel::ToJson(channel->GetHandle()); // Define string as constant
-  param[kServiceResultType] = picojson::value(kServiceResultTypeOnStart);
+  UpdateListener(cur_listener_id, LOCAL_SERVICE_START);
 
-  common::TizenResult result = ConvergenceAppCommunicationService::Start(channel, cur_listener_id);
-  if (!result) {
-    return result;
+  const int error = conv_service_start(service_handle, channel->GetHandle(), nullptr);
+  if (CONV_ERROR_NONE != error) {
+    return LogAndCreateTizenError(AbortError, "conv_service_start [fail]");
   }
 
-  convergence_plugin_->ReplyAsync(kAppCommunicationListenerCallback, cur_listener_id, true, param);
-  return result;
+  opened_channels.push_back(ch_ptr.release());
+
+  return TizenSuccess();
 }
 
 common::TizenResult ConvergenceAppCommunicationServerService::Stop(

diff --git a/src/convergence/convergence_app_communication_service.h b/src/convergence/convergence_app_communication_service.h
index 382188673c1fe17f58a600cdc7c42d4b56757e31..10ec5d9fb1f943343415071610e9a53183c8f20d 100644 (file)
--- a/src/convergence/convergence_app_communication_service.h
+++ b/src/convergence/convergence_app_communication_service.h
@@ -55,12 +55,12 @@ class ConvergenceAppCommunicationService : public ConvergenceService {
   common::TizenResult SetListener(const int cur_listener_id);
   common::TizenResult RemoveListener();
  private:
-  void UpdateListener(const int cur_listener_id);
   static void ServiceListenerCb(conv_service_h service_handle,
    conv_channel_h channel_handle,
    conv_error_e error, conv_payload_h result, void* user_data);
 
  protected:
+  void UpdateListener(const int cur_listener_id, ServiceRequestType type = UNKNOWN_REQUEST_TYPE);
   std::vector<CallbackParam *> callback_param_gc_;
 };
 

diff --git a/src/convergence/convergence_client_info.cc b/src/convergence/convergence_client_info.cc
index 6dece11e716d9ab28f6e9e482d116f730d3cca61..b75c2e73cd429b6019e22fadaabbbd3b111e279e 100644 (file)
--- a/src/convergence/convergence_client_info.cc
+++ b/src/convergence/convergence_client_info.cc
@@ -76,7 +76,7 @@ picojson::value ConvergenceClientInfo::ToJson() const {
   ScopeLogger();
   picojson::object clientInfo;
   clientInfo["isHost"] = picojson::value(static_cast<double>(isHost_));
-  clientInfo["connectionTime"] = picojson::value(static_cast<double>(connectionTime_));
+  clientInfo["connectTime"] = picojson::value(static_cast<double>(connectionTime_));
   clientInfo["clientId"] = picojson::value(clientId_);
   return picojson::value(clientInfo);
 }

diff --git a/src/convergence/convergence_utils.h b/src/convergence/convergence_utils.h
index 50e04904154a2d15eb9fc2b8be6bf52ad2a7f8a2..2d17d8ae9c7a8f9f0b407b778f96d9ca7276a2f2 100644 (file)
--- a/src/convergence/convergence_utils.h
+++ b/src/convergence/convergence_utils.h
@@ -24,6 +24,7 @@
 #include <unordered_map>
 
 #include "common/tizen_result.h"
+#include "convergence_client_info.h"
 
 namespace extension {
 namespace convergence {
@@ -62,12 +63,23 @@ static const std::string kServiceListenerStatusError = "listener_error";
 static const std::string kServiceListenerError = "error";
 } // namespace
 
+enum ServiceRequestType {
+  LOCAL_SERVICE_START,
+  REMOTE_SERVICE_START,
+  UNKNOWN_REQUEST_TYPE
+};
+
 struct CallbackParam {
- CallbackParam(ConvergenceInstance *plg, int cbId)
-   : plugin_(plg), callback_id_(cbId), remote_method_() {}
+ CallbackParam(ConvergenceInstance *plg,  int cbId, ServiceRequestType type = UNKNOWN_REQUEST_TYPE)
+   : plugin_(plg), callback_id_(cbId), remote_method_(), client_info_(nullptr), type_(type) {}
+ ~CallbackParam() {
+   delete client_info_;
+ }
  ConvergenceInstance *plugin_;
  int callback_id_;
  std::string remote_method_;
+ ConvergenceClientInfo* client_info_;
+ ServiceRequestType type_;
 };