[Datasync] Google code style

[Verification] Related TCT should pass

Change-Id: If1ad8c97e0cd2227caef826fa3bcfb54b8bac0f5
Signed-off-by: Ryszard Matuszyk <r.matuszyk@samsung.com>

diff --git a/src/datasync/datasync_extension.cc b/src/datasync/datasync_extension.cc
index 67340bd..6388419 100644 (file)
--- a/src/datasync/datasync_extension.cc
+++ b/src/datasync/datasync_extension.cc
@@ -16,8 +16,8 @@ DatasyncExtension::DatasyncExtension() {
   SetExtensionName("tizen.datasync");
   SetJavaScriptAPI(kSource_datasync_api);
 
-  const char* entry_points[] = {"tizen.SyncInfo", "tizen.SyncProfileInfo", "tizen.SyncServiceInfo",
-                                NULL};
+  const char* entry_points[] = {"tizen.SyncInfo", "tizen.SyncProfileInfo",
+                                "tizen.SyncServiceInfo", NULL};
   SetExtraJSEntryPoints(entry_points);
 }
 
@@ -28,7 +28,9 @@ DataSyncManager& DatasyncExtension::manager() {
   return DataSyncManager::Instance();
 }
 
-common::Instance* DatasyncExtension::CreateInstance() { return new DatasyncInstance; }
+common::Instance* DatasyncExtension::CreateInstance() {
+  return new DatasyncInstance;
+}
 
 // entry point
 common::Extension* CreateExtension() { return new DatasyncExtension; }

diff --git a/src/datasync/datasync_instance.cc b/src/datasync/datasync_instance.cc
index e040ff1..25f11ac 100644 (file)
--- a/src/datasync/datasync_instance.cc
+++ b/src/datasync/datasync_instance.cc
@@ -16,7 +16,8 @@ namespace datasync {
 
 namespace {
 // The privileges that required in Datasynchronization API
-const std::string kPrivilegeDatasynchronization = "http://tizen.org/privilege/datasync";
+const std::string kPrivilegeDatasynchronization =
+    "http://tizen.org/privilege/datasync";
 
 }  // namespace
 
@@ -29,18 +30,26 @@ DatasyncInstance &DatasyncInstance::GetInstance() {
 
 DatasyncInstance::DatasyncInstance() {
   using namespace std::placeholders;
-#define REGISTER_SYNC(c, x) RegisterSyncHandler(c, std::bind(&DatasyncInstance::x, this, _1, _2));
-  REGISTER_SYNC("DataSynchronizationManager_add", DataSynchronizationManagerAdd);
-  REGISTER_SYNC("DataSynchronizationManager_update", DataSynchronizationManagerUpdate);
-  REGISTER_SYNC("DataSynchronizationManager_remove", DataSynchronizationManagerRemove);
+#define REGISTER_SYNC(c, x) \
+  RegisterSyncHandler(c, std::bind(&DatasyncInstance::x, this, _1, _2));
+  REGISTER_SYNC("DataSynchronizationManager_add",
+                DataSynchronizationManagerAdd);
+  REGISTER_SYNC("DataSynchronizationManager_update",
+                DataSynchronizationManagerUpdate);
+  REGISTER_SYNC("DataSynchronizationManager_remove",
+                DataSynchronizationManagerRemove);
   REGISTER_SYNC("DataSynchronizationManager_getMaxProfilesNum",
                 DataSynchronizationManagerGetMaxProfilesNum);
   REGISTER_SYNC("DataSynchronizationManager_getProfilesNum",
                 DataSynchronizationManagerGetProfilesNum);
-  REGISTER_SYNC("DataSynchronizationManager_get", DataSynchronizationManagerGet);
-  REGISTER_SYNC("DataSynchronizationManager_getAll", DataSynchronizationManagerGetAll);
-  REGISTER_SYNC("DataSynchronizationManager_startSync", DataSynchronizationManagerStartSync);
-  REGISTER_SYNC("DataSynchronizationManager_stopSync", DataSynchronizationManagerStopSync);
+  REGISTER_SYNC("DataSynchronizationManager_get",
+                DataSynchronizationManagerGet);
+  REGISTER_SYNC("DataSynchronizationManager_getAll",
+                DataSynchronizationManagerGetAll);
+  REGISTER_SYNC("DataSynchronizationManager_startSync",
+                DataSynchronizationManagerStartSync);
+  REGISTER_SYNC("DataSynchronizationManager_stopSync",
+                DataSynchronizationManagerStopSync);
   REGISTER_SYNC("DataSynchronizationManager_getLastSyncStatistics",
                 DataSynchronizationManagerGetLastSyncStatistics);
 #undef REGISTER_SYNC
@@ -48,10 +57,11 @@ DatasyncInstance::DatasyncInstance() {
 
 DatasyncInstance::~DatasyncInstance() {}
 
-void DatasyncInstance::DataSynchronizationManagerGetMaxProfilesNum(const picojson::value &args,
-                                                                   picojson::object &out) {
-  ReportSuccess(
-      picojson::value(static_cast<double>(DataSyncManager::Instance().GetMaxProfilesNum())), out);
+void DatasyncInstance::DataSynchronizationManagerGetMaxProfilesNum(
+    const picojson::value &args, picojson::object &out) {
+  ReportSuccess(picojson::value(static_cast<double>(
+                    DataSyncManager::Instance().GetMaxProfilesNum())),
+                out);
 }
 
 void DatasyncInstance::DataSynchronizationManagerGetProfilesNum(
@@ -92,12 +102,12 @@ void DatasyncInstance::DataSynchronizationManagerGetAll(
     ReportError(status, &out);
 }
 
-void DatasyncInstance::DataSynchronizationManagerGetLastSyncStatistics(const picojson::value &args,
-                                                                       picojson::object &out) {
+void DatasyncInstance::DataSynchronizationManagerGetLastSyncStatistics(
+    const picojson::value &args, picojson::object &out) {
   picojson::value result = picojson::value(picojson::array());
 
-  DataSyncManager::Instance().GetLastSyncStatistics(args.get("profileId").get<std::string>(),
-                                                    result.get<picojson::array>());
+  DataSyncManager::Instance().GetLastSyncStatistics(
+      args.get("profileId").get<std::string>(), result.get<picojson::array>());
 
   ReportSuccess(result, out);
 }

diff --git a/src/datasync/datasync_instance.h b/src/datasync/datasync_instance.h
index 8733630..130e882 100644 (file)
--- a/src/datasync/datasync_instance.h
+++ b/src/datasync/datasync_instance.h
@@ -29,18 +29,26 @@ class DatasyncInstance : public common::ParsedInstance {
   // with result
   void DataSynchronizationManagerGetMaxProfilesNum(const picojson::value& args,
                                                    picojson::object& out);
-  void DataSynchronizationManagerGetProfilesNum(const picojson::value& args, picojson::object& out);
-  void DataSynchronizationManagerGet(const picojson::value& args, picojson::object& out);
-  void DataSynchronizationManagerGetAll(const picojson::value& args, picojson::object& out);
-  void DataSynchronizationManagerGetLastSyncStatistics(const picojson::value& args,
-                                                       picojson::object& out);
+  void DataSynchronizationManagerGetProfilesNum(const picojson::value& args,
+                                                picojson::object& out);
+  void DataSynchronizationManagerGet(const picojson::value& args,
+                                     picojson::object& out);
+  void DataSynchronizationManagerGetAll(const picojson::value& args,
+                                        picojson::object& out);
+  void DataSynchronizationManagerGetLastSyncStatistics(
+      const picojson::value& args, picojson::object& out);
 
   // undefined result
-  void DataSynchronizationManagerAdd(const picojson::value& args, picojson::object& out);
-  void DataSynchronizationManagerUpdate(const picojson::value& args, picojson::object& out);
-  void DataSynchronizationManagerRemove(const picojson::value& args, picojson::object& out);
-  void DataSynchronizationManagerStartSync(const picojson::value& args, picojson::object& out);
-  void DataSynchronizationManagerStopSync(const picojson::value& args, picojson::object& out);
+  void DataSynchronizationManagerAdd(const picojson::value& args,
+                                     picojson::object& out);
+  void DataSynchronizationManagerUpdate(const picojson::value& args,
+                                        picojson::object& out);
+  void DataSynchronizationManagerRemove(const picojson::value& args,
+                                        picojson::object& out);
+  void DataSynchronizationManagerStartSync(const picojson::value& args,
+                                           picojson::object& out);
+  void DataSynchronizationManagerStopSync(const picojson::value& args,
+                                          picojson::object& out);
 };
 
 }  // namespace datasync

diff --git a/src/datasync/datasync_manager.cc b/src/datasync/datasync_manager.cc
index 1e614b5..faa6e01 100644 (file)
--- a/src/datasync/datasync_manager.cc
+++ b/src/datasync/datasync_manager.cc
@@ -133,16 +133,20 @@ DataSyncManager::~DataSyncManager() {
   // sync-agent should fix it's deinitialization
 }
 
-PlatformResult DataSyncManager::Item(ds_profile_h* profile_h, const picojson::object& args) {
+PlatformResult DataSyncManager::Item(ds_profile_h* profile_h,
+                                     const picojson::object& args) {
   sync_agent_ds_error_e ret;
 
   std::string profile_name = FromJson<std::string>(args, "profileName").c_str();
-  ret = sync_agent_ds_set_profile_name(profile_h, const_cast<char*>(profile_name.c_str()));
+  ret = sync_agent_ds_set_profile_name(profile_h,
+                                       const_cast<char*>(profile_name.c_str()));
   if (SYNC_AGENT_DS_SUCCESS != ret) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform error while settting a profile name");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while settting a profile name");
   }
 
-  const picojson::object& sync_info = FromJson<picojson::object>(args, "syncInfo");
+  const picojson::object& sync_info =
+      FromJson<picojson::object>(args, "syncInfo");
   std::string url = FromJson<std::string>(sync_info, "url").c_str();
   std::string id = FromJson<std::string>(sync_info, "id").c_str();
   std::string password = FromJson<std::string>(sync_info, "password").c_str();
@@ -150,7 +154,8 @@ PlatformResult DataSyncManager::Item(ds_profile_h* profile_h, const picojson::ob
                                       const_cast<char*>(id.c_str()),
                                       const_cast<char*>(password.c_str()));
   if (SYNC_AGENT_DS_SUCCESS != ret) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform error while settting a server info");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while settting a server info");
   }
 
   int sync_mode;
@@ -169,19 +174,23 @@ PlatformResult DataSyncManager::Item(ds_profile_h* profile_h, const picojson::ob
                              &sync_interval);
   if (status.IsError()) return status;
 
-  LoggerD("syncMode: %d, syncType: %d, syncInterval: %d", sync_mode, sync_type, sync_interval);
+  LoggerD("syncMode: %d, syncType: %d, syncInterval: %d", sync_mode, sync_type,
+          sync_interval);
 
-  ret = sync_agent_ds_set_sync_info(profile_h, static_cast<sync_agent_ds_sync_mode_e>(sync_mode),
-                                    static_cast<sync_agent_ds_sync_type_e>(sync_type),
-                                    static_cast<sync_agent_ds_sync_interval_e>(sync_interval));
+  ret = sync_agent_ds_set_sync_info(
+      profile_h, static_cast<sync_agent_ds_sync_mode_e>(sync_mode),
+      static_cast<sync_agent_ds_sync_type_e>(sync_type),
+      static_cast<sync_agent_ds_sync_interval_e>(sync_interval));
   if (SYNC_AGENT_DS_SUCCESS != ret) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform error while settting a sync info");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while settting a sync info");
   }
 
   // Set the sync categories.
   if (IsNull(args, "serviceInfo")) return PlatformResult(ErrorCode::NO_ERROR);
 
-  const picojson::array& service_info = FromJson<picojson::array>(args, "serviceInfo");
+  const picojson::array& service_info =
+      FromJson<picojson::array>(args, "serviceInfo");
 
   for (auto& item : service_info) {
     const picojson::object& obj = JsonCast<picojson::object>(item);
@@ -205,37 +214,47 @@ PlatformResult DataSyncManager::Item(ds_profile_h* profile_h, const picojson::ob
     if (!IsNull(obj, "id")) id = FromJson<std::string>(obj, "id");
 
     std::string password = "";
-    if (!IsNull(obj, "password")) password = FromJson<std::string>(obj, "password");
+    if (!IsNull(obj, "password"))
+      password = FromJson<std::string>(obj, "password");
 
-    LoggerI("serviceType: %d, tgtURI: %s, enable: %d", service_type, tgt_uri.c_str(), enable);
+    LoggerI("serviceType: %d, tgtURI: %s, enable: %d", service_type,
+            tgt_uri.c_str(), enable);
 
     ret = sync_agent_ds_set_sync_service_info(
-        profile_h, static_cast<sync_agent_ds_service_type_e>(service_type), enable,
-        static_cast<sync_agent_ds_src_uri_e>(src_uri), const_cast<char*>(tgt_uri.c_str()),
+        profile_h, static_cast<sync_agent_ds_service_type_e>(service_type),
+        enable, static_cast<sync_agent_ds_src_uri_e>(src_uri),
+        const_cast<char*>(tgt_uri.c_str()),
         0 == id.size() ? nullptr : const_cast<char*>(id.c_str()),
         0 == password.size() ? nullptr : const_cast<char*>(password.c_str()));
     if (SYNC_AGENT_DS_SUCCESS != ret) {
-      return PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform error while settting a sync service info");
+      return PlatformResult(
+          ErrorCode::UNKNOWN_ERR,
+          "Platform error while settting a sync service info");
     }
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
-PlatformResult DataSyncManager::Item(const std::string& id, ds_profile_h* profile_h, picojson::object& out) {
+PlatformResult DataSyncManager::Item(const std::string& id,
+                                     ds_profile_h* profile_h,
+                                     picojson::object& out) {
   out["profileId"] = picojson::value(id);
 
   char* profile_name = nullptr;
-  sync_agent_ds_error_e ret = sync_agent_ds_get_profile_name(profile_h, &profile_name);
+  sync_agent_ds_error_e ret =
+      sync_agent_ds_get_profile_name(profile_h, &profile_name);
   if (SYNC_AGENT_DS_SUCCESS != ret) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform error while gettting a profile name");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while gettting a profile name");
   }
   out["profileName"] = picojson::value(profile_name);
 
   sync_agent_ds_server_info server_info = {nullptr};
   ret = sync_agent_ds_get_server_info(profile_h, &server_info);
   if (SYNC_AGENT_DS_SUCCESS != ret) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform error while gettting a server info");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while gettting a server info");
   }
   picojson::value sync_info_val = picojson::value(picojson::object());
   picojson::object& sync_info_obj = sync_info_val.get<picojson::object>();
@@ -246,11 +265,13 @@ PlatformResult DataSyncManager::Item(const std::string& id, ds_profile_h* profil
   sync_agent_ds_sync_info sync_info;
   ret = sync_agent_ds_get_sync_info(profile_h, &sync_info);
   if (SYNC_AGENT_DS_SUCCESS != ret) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform error while gettting a sync info");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while gettting a sync info");
   }
 
   std::string mode;
-  PlatformResult status = PlatformEnumToStr(kSyncMode, sync_info.sync_mode, &mode);
+  PlatformResult status =
+      PlatformEnumToStr(kSyncMode, sync_info.sync_mode, &mode);
   if (status.IsError()) return status;
   sync_info_obj["mode"] = picojson::value(mode);
 
@@ -266,13 +287,14 @@ PlatformResult DataSyncManager::Item(const std::string& id, ds_profile_h* profil
 
   out["syncInfo"] = sync_info_val;
 
-  LoggerD("Sync mode: %d, type: %d, interval: %d", sync_info.sync_mode, sync_info.sync_type,
-          sync_info.interval);
+  LoggerD("Sync mode: %d, type: %d, interval: %d", sync_info.sync_mode,
+          sync_info.sync_type, sync_info.interval);
 
   GList* category_list = nullptr;
   ret = sync_agent_ds_get_sync_service_info(profile_h, &category_list);
   if (SYNC_AGENT_DS_SUCCESS != ret) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform error while gettting sync categories");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while gettting sync categories");
   }
   int category_count = g_list_length(category_list);
   LoggerD("category_count: %d", category_count);
@@ -284,17 +306,19 @@ PlatformResult DataSyncManager::Item(const std::string& id, ds_profile_h* profil
 
   sync_agent_ds_service_info* category_info = nullptr;
   while (category_count--) {
-    category_info =
-        static_cast<sync_agent_ds_service_info*>(g_list_nth_data(category_list, category_count));
+    category_info = static_cast<sync_agent_ds_service_info*>(
+        g_list_nth_data(category_list, category_count));
     if (SYNC_AGENT_CALENDAR < category_info->service_type) {
-      LoggerD("Skip unsupported sync service type: %d", category_info->service_type);
+      LoggerD("Skip unsupported sync service type: %d",
+              category_info->service_type);
       continue;
     }
 
     picojson::value item = picojson::value(picojson::object());
     picojson::object& item_obj = item.get<picojson::object>();
 
-    item_obj["enable"] = picojson::value(static_cast<bool>(category_info->enabled));
+    item_obj["enable"] =
+        picojson::value(static_cast<bool>(category_info->enabled));
     if (category_info->id) {
       item_obj["id"] = picojson::value(category_info->id);
     }
@@ -322,7 +346,8 @@ PlatformResult DataSyncManager::Item(const std::string& id, ds_profile_h* profil
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
-PlatformResult DataSyncManager::Add(const picojson::object& args, int *profile_id) {
+PlatformResult DataSyncManager::Add(const picojson::object& args,
+                                    int* profile_id) {
   assert(profile_id);
   ds_profile_h profile_h = nullptr;
 
@@ -332,12 +357,14 @@ PlatformResult DataSyncManager::Add(const picojson::object& args, int *profile_i
   LoggerD("numProfiles: %d", num_profiles);
 
   if (MAX_PROFILES_NUM == num_profiles) {
-    return PlatformResult(ErrorCode::QUOTA_EXCEEDED_ERR, "There are already maximum number of profiles!");
+    return PlatformResult(ErrorCode::QUOTA_EXCEEDED_ERR,
+                          "There are already maximum number of profiles!");
   }
 
   sync_agent_ds_error_e ret = sync_agent_ds_create_profile_info(&profile_h);
   if (SYNC_AGENT_DS_SUCCESS != ret) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform error while creating a profile");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while creating a profile");
   }
 
   status = Item(&profile_h, args);
@@ -345,7 +372,8 @@ PlatformResult DataSyncManager::Add(const picojson::object& args, int *profile_i
 
   ret = sync_agent_ds_add_profile(profile_h, profile_id);
   if (SYNC_AGENT_DS_SUCCESS != ret) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform error while adding a profile");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while adding a profile");
   }
 
   LoggerD("profileId from platform: %d", *profile_id);
@@ -361,7 +389,8 @@ PlatformResult DataSyncManager::Update(const picojson::object& args) {
 
   sync_agent_ds_error_e ret = sync_agent_ds_get_profile(profile_id, &profile_h);
   if (SYNC_AGENT_DS_SUCCESS != ret) {
-    return PlatformResult(ErrorCode::NOT_FOUND_ERR, "Platform error while getting a profile");
+    return PlatformResult(ErrorCode::NOT_FOUND_ERR,
+                          "Platform error while getting a profile");
   }
 
   PlatformResult status = Item(&profile_h, args);
@@ -369,7 +398,8 @@ PlatformResult DataSyncManager::Update(const picojson::object& args) {
 
   ret = sync_agent_ds_update_profile(profile_h);
   if (SYNC_AGENT_DS_SUCCESS != ret && SYNC_AGENT_DS_SYNCHRONISING != ret) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform error while updating a profile");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while updating a profile");
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -383,12 +413,14 @@ PlatformResult DataSyncManager::Remove(const std::string& id) {
 
   sync_agent_ds_error_e ret = sync_agent_ds_get_profile(profile_id, &profile_h);
   if (SYNC_AGENT_DS_SUCCESS != ret) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform error while getting a profile");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while getting a profile");
   }
 
   ret = sync_agent_ds_delete_profile(profile_h);
   if (SYNC_AGENT_DS_SUCCESS != ret && SYNC_AGENT_DS_SYNCHRONISING != ret) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform error while deleting a profile");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while deleting a profile");
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -431,7 +463,8 @@ PlatformResult DataSyncManager::GetAll(picojson::array& out) {
 
   sync_agent_ds_error_e ret = sync_agent_ds_get_all_profile(&profile_list);
   if (SYNC_AGENT_DS_SUCCESS != ret) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform error while getting all profiles");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while getting all profiles");
   }
 
   ds_profile_h profile_h = nullptr;
@@ -444,7 +477,8 @@ PlatformResult DataSyncManager::GetAll(picojson::array& out) {
 
     ret = sync_agent_ds_get_profile_id(profile_h, &profile_id);
     if (SYNC_AGENT_DS_SUCCESS != ret) {
-      return PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform error while gettting a profile id");
+      return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                            "Platform error while gettting a profile id");
     }
 
     picojson::value profile = picojson::value(picojson::object());
@@ -470,25 +504,30 @@ PlatformResult DataSyncManager::StartSync(const picojson::object& args) {
 
   sync_agent_event_error_e err = sync_agent_set_noti_callback(
       SYNC_AGENT_DS_SYNC_SESSION,
-      [](sync_agent_event_data_s* d,
-         void* ud) { return static_cast<DataSyncManager*>(ud)->StateChangedCallback(d); },
+      [](sync_agent_event_data_s* d, void* ud) {
+        return static_cast<DataSyncManager*>(ud)->StateChangedCallback(d);
+      },
       static_cast<void*>(this));
   if (err != SYNC_AGENT_EVENT_SUCCESS) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform error while setting state changed cb");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while setting state changed cb");
   }
 
-  err = sync_agent_set_noti_callback(
-      SYNC_AGENT_DS_SYNC_PROCESS, [](sync_agent_event_data_s* d, void* ud) {
-                                    return static_cast<DataSyncManager*>(ud)->ProgressCallback(d);
-                                  },
-      static_cast<void*>(this));
+  err = sync_agent_set_noti_callback(SYNC_AGENT_DS_SYNC_PROCESS,
+                                     [](sync_agent_event_data_s* d, void* ud) {
+                                       return static_cast<DataSyncManager*>(ud)
+                                           ->ProgressCallback(d);
+                                     },
+                                     static_cast<void*>(this));
   if (err != SYNC_AGENT_EVENT_SUCCESS) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform error while setting progress cb");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while setting progress cb");
   }
 
   sync_agent_ds_error_e ret = sync_agent_ds_start_sync(profile_h);
   if (SYNC_AGENT_DS_SUCCESS != ret && SYNC_AGENT_DS_SYNCHRONISING != ret) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform error while starting a profile");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while starting a profile");
   }
 
   callbacks_[id] = listener_id;
@@ -504,12 +543,14 @@ PlatformResult DataSyncManager::StopSync(const std::string& id) {
 
   sync_agent_ds_error_e ret = sync_agent_ds_get_profile(profile_id, &profile_h);
   if (SYNC_AGENT_DS_SUCCESS != ret) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform error while getting a profile");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while getting a profile");
   }
 
   ret = sync_agent_ds_stop_sync(profile_h);
   if (SYNC_AGENT_DS_SUCCESS != ret) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform error while stopping a profile");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while stopping a profile");
   }
 
   callbacks_.erase(id);
@@ -522,7 +563,8 @@ DataSyncManager& DataSyncManager::Instance() {
   return manager;
 }
 
-PlatformResult DataSyncManager::GetLastSyncStatistics(const std::string& id, picojson::array& out) {
+PlatformResult DataSyncManager::GetLastSyncStatistics(const std::string& id,
+                                                      picojson::array& out) {
   ds_profile_h profile_h = nullptr;
   GList* statistics_list = nullptr;
 
@@ -531,12 +573,14 @@ PlatformResult DataSyncManager::GetLastSyncStatistics(const std::string& id, pic
 
   sync_agent_ds_error_e ret = sync_agent_ds_get_profile(profile_id, &profile_h);
   if (SYNC_AGENT_DS_SUCCESS != ret) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform error while getting a profile");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while getting a profile");
   }
 
   ret = sync_agent_ds_get_sync_statistics(profile_h, &statistics_list);
   if (SYNC_AGENT_DS_SUCCESS != ret) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform error while gettting sync statistics");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while gettting sync statistics");
   }
 
   int statistics_count = g_list_length(statistics_list);
@@ -544,7 +588,8 @@ PlatformResult DataSyncManager::GetLastSyncStatistics(const std::string& id, pic
   sync_agent_ds_statistics_info* statistics = nullptr;
 
   for (int i = 0; i < statistics_count; i++) {
-    statistics = static_cast<sync_agent_ds_statistics_info*>(g_list_nth_data(statistics_list, i));
+    statistics = static_cast<sync_agent_ds_statistics_info*>(
+        g_list_nth_data(statistics_list, i));
 
     picojson::value item = picojson::value(picojson::object());
     picojson::object& item_obj = item.get<picojson::object>();
@@ -553,15 +598,15 @@ PlatformResult DataSyncManager::GetLastSyncStatistics(const std::string& id, pic
     if (0 == i) {
       LoggerD("Statistics for contact.");
 
-      PlatformResult status = PlatformEnumToStr(kSyncServiceType, SYNC_AGENT_CONTACT,
-                                 &service_type);
+      PlatformResult status = PlatformEnumToStr(
+          kSyncServiceType, SYNC_AGENT_CONTACT, &service_type);
       if (status.IsError()) return status;
       item_obj["serviceType"] = picojson::value(service_type);
     } else if (1 == i) {
       LoggerD("Statistics for event.");
 
-      PlatformResult status = PlatformEnumToStr(kSyncServiceType, SYNC_AGENT_CALENDAR,
-                                 &service_type);
+      PlatformResult status = PlatformEnumToStr(
+          kSyncServiceType, SYNC_AGENT_CALENDAR, &service_type);
       if (status.IsError()) return status;
       item_obj["serviceType"] = picojson::value(service_type);
     } else {
@@ -575,35 +620,38 @@ PlatformResult DataSyncManager::GetLastSyncStatistics(const std::string& id, pic
     if (!statistics->dbsynced) continue;
 
     std::string db_synced = statistics->dbsynced;
-    std::transform(db_synced.begin(), db_synced.end(), db_synced.begin(), ::toupper);
+    std::transform(db_synced.begin(), db_synced.end(), db_synced.begin(),
+                   ::toupper);
 
     item_obj["syncStatus"] = picojson::value(db_synced);
     item_obj["clientToServerTotal"] =
         picojson::value(static_cast<double>(statistics->client2server_total));
     item_obj["clientToServerAdded"] =
         picojson::value(static_cast<double>(statistics->client2server_nrofadd));
-    item_obj["clientToServerUpdated"] =
-        picojson::value(static_cast<double>(statistics->client2server_nrofreplace));
-    item_obj["clientToServerRemoved"] =
-        picojson::value(static_cast<double>(statistics->client2server_nrofdelete));
+    item_obj["clientToServerUpdated"] = picojson::value(
+        static_cast<double>(statistics->client2server_nrofreplace));
+    item_obj["clientToServerRemoved"] = picojson::value(
+        static_cast<double>(statistics->client2server_nrofdelete));
     item_obj["serverToClientTotal"] =
         picojson::value(static_cast<double>(statistics->server2client_total));
     item_obj["serverToClientAdded"] =
         picojson::value(static_cast<double>(statistics->server2client_nrofadd));
-    item_obj["serverToClientUpdated"] =
-        picojson::value(static_cast<double>(statistics->server2client_nrofreplace));
-    item_obj["serverToClientRemoved"] =
-        picojson::value(static_cast<double>(statistics->server2client_nrofdelete));
-    item_obj["lastSyncTime"] = picojson::value(static_cast<double>(statistics->last_session_time));
+    item_obj["serverToClientUpdated"] = picojson::value(
+        static_cast<double>(statistics->server2client_nrofreplace));
+    item_obj["serverToClientRemoved"] = picojson::value(
+        static_cast<double>(statistics->server2client_nrofdelete));
+    item_obj["lastSyncTime"] =
+        picojson::value(static_cast<double>(statistics->last_session_time));
 
-    LoggerD("ClientToServerTotal: %d, ServerToClientTotal: %d", statistics->client2server_total,
-            statistics->server2client_total);
+    LoggerD("ClientToServerTotal: %d, ServerToClientTotal: %d",
+            statistics->client2server_total, statistics->server2client_total);
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
-PlatformResult DataSyncManager::GetProfileId(sync_agent_event_data_s* request, std::string& profile_id) {
+PlatformResult DataSyncManager::GetProfileId(sync_agent_event_data_s* request,
+                                             std::string& profile_id) {
   char* profile_dir_name = nullptr;
 
   sync_agent_get_event_data_param(request, &profile_dir_name);
@@ -622,9 +670,11 @@ PlatformResult DataSyncManager::GetProfileId(sync_agent_event_data_s* request, s
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
-void DataSyncManager::Failed(picojson::object& response_obj, picojson::object& answer_obj,
+void DataSyncManager::Failed(picojson::object& response_obj,
+                             picojson::object& answer_obj,
                              const common::ErrorCode& code,
-                             const std::string& name, const std::string& message) {
+                             const std::string& name,
+                             const std::string& message) {
   LoggerE("%s", message.c_str());
   response_obj["callback_name"] = picojson::value("onfailed");
 
@@ -638,8 +688,10 @@ void DataSyncManager::Failed(picojson::object& response_obj, picojson::object& a
   answer_obj["error"] = error;
 }
 
-void DataSyncManager::PrepareResponseObj(const std::string& profile_id, picojson::value& response,
-                                         picojson::object& response_obj, picojson::value& answer,
+void DataSyncManager::PrepareResponseObj(const std::string& profile_id,
+                                         picojson::value& response,
+                                         picojson::object& response_obj,
+                                         picojson::value& answer,
                                          picojson::object& answer_obj) {
   response = picojson::value(picojson::object());
   response_obj = response.get<picojson::object>();
@@ -678,15 +730,18 @@ int DataSyncManager::StateChangedCallback(sync_agent_event_data_s* request) {
     callbacks_.erase(it);
 
     if (!progress) {
-      Failed(response_obj, answer_obj, ErrorCode::UNKNOWN_ERR, "Exception", "nullptr status");
+      Failed(response_obj, answer_obj, ErrorCode::UNKNOWN_ERR, "Exception",
+             "nullptr status");
     } else if (0 == strncmp(progress, "DONE", 4)) {
       response_obj["callback_name"] = picojson::value("oncompleted");
     } else if (0 == strncmp(progress, "CANCEL", 6)) {
       response_obj["callback_name"] = picojson::value("onstopped");
     } else if (0 == strncmp(progress, "ERROR", 5)) {
-      Failed(response_obj, answer_obj, ErrorCode::UNKNOWN_ERR, "Exception", "Datasync failed");
+      Failed(response_obj, answer_obj, ErrorCode::UNKNOWN_ERR, "Exception",
+             "Datasync failed");
     } else {
-      Failed(response_obj, answer_obj, ErrorCode::UNKNOWN_ERR, "Exception", "Undefined status");
+      Failed(response_obj, answer_obj, ErrorCode::UNKNOWN_ERR, "Exception",
+             "Undefined status");
     }
   }
 
@@ -703,13 +758,13 @@ int DataSyncManager::ProgressCallback(sync_agent_event_data_s* request) {
   LoggerD("DataSync progress called.");
 
   int uri;
-  int is_from_server, total_per_operation, synced_per_operation, total_per_db, synced_per_db;
+  int is_from_server, total_per_operation, synced_per_operation, total_per_db,
+      synced_per_db;
   std::string profile_id;
 
   LoggerD("Get progress info.");
   sync_agent_get_event_data_param(request, &uri);
 
-
   PlatformResult status = GetProfileId(request, profile_id);
   if (status.IsError()) return static_cast<int>(status.error_code());
 
@@ -722,9 +777,11 @@ int DataSyncManager::ProgressCallback(sync_agent_event_data_s* request) {
   sync_agent_get_event_data_param(request, &synced_per_db);
 
   LoggerI(
-      "isFromServer: %d, totalPerOperation: %d, syncedPerOperation: %d, totalPerDb: %d, "
+      "isFromServer: %d, totalPerOperation: %d, syncedPerOperation: %d, "
+      "totalPerDb: %d, "
       "syncedPerDb %d",
-      is_from_server, total_per_operation, synced_per_operation, total_per_db, synced_per_db);
+      is_from_server, total_per_operation, synced_per_operation, total_per_db,
+      synced_per_db);
 
   // prepare response object
   picojson::value response;
@@ -735,20 +792,25 @@ int DataSyncManager::ProgressCallback(sync_agent_event_data_s* request) {
 
   auto it = callbacks_.find(profile_id);
   if (it != callbacks_.end()) {
-
-    if (SYNC_AGENT_SRC_URI_CONTACT == uri || SYNC_AGENT_SRC_URI_CALENDAR == uri) {
+    if (SYNC_AGENT_SRC_URI_CONTACT == uri ||
+        SYNC_AGENT_SRC_URI_CALENDAR == uri) {
       response_obj["callback_name"] = picojson::value("onprogress");
 
       std::string service_type;
-      PlatformResult status = PlatformEnumToStr(kSyncServiceTypeToSrcUri, uri, &service_type);
+      PlatformResult status =
+          PlatformEnumToStr(kSyncServiceTypeToSrcUri, uri, &service_type);
       if (status.IsError()) return static_cast<int>(status.error_code());
       answer_obj["serviceType"] = picojson::value(service_type);
 
-      answer_obj["isFromServer"] = picojson::value(static_cast<double>(is_from_server));
-      answer_obj["totalPerService"] = picojson::value(static_cast<double>(total_per_db));
-      answer_obj["syncedPerService"] = picojson::value(static_cast<double>(synced_per_db));
+      answer_obj["isFromServer"] =
+          picojson::value(static_cast<double>(is_from_server));
+      answer_obj["totalPerService"] =
+          picojson::value(static_cast<double>(total_per_db));
+      answer_obj["syncedPerService"] =
+          picojson::value(static_cast<double>(synced_per_db));
     } else {
-      Failed(response_obj, answer_obj, ErrorCode::UNKNOWN_ERR, "Exception", "Wrong service type");
+      Failed(response_obj, answer_obj, ErrorCode::UNKNOWN_ERR, "Exception",
+             "Wrong service type");
     }
   }
 

diff --git a/src/datasync/datasync_manager.h b/src/datasync/datasync_manager.h
index 7cc4a33..4765b93 100644 (file)
--- a/src/datasync/datasync_manager.h
+++ b/src/datasync/datasync_manager.h
@@ -46,7 +46,7 @@ class DataSyncManager {
 
   static common::PlatformResult StrToPlatformEnum(const std::string& field,
                                                   const std::string& value,
-                                                  int *platform_enum);
+                                                  int* platform_enum);
   static common::PlatformResult PlatformEnumToStr(const std::string& field,
                                                   const int value,
                                                   std::string* platform_str);
@@ -65,8 +65,10 @@ class DataSyncManager {
   void Failed(picojson::object& response_obj, picojson::object& answer_obj,
               const common::ErrorCode& code, const std::string& name,
               const std::string& message);
-  inline void PrepareResponseObj(const std::string& profile_id, picojson::value& response,
-                                 picojson::object& response_obj, picojson::value& answer,
+  inline void PrepareResponseObj(const std::string& profile_id,
+                                 picojson::value& response,
+                                 picojson::object& response_obj,
+                                 picojson::value& answer,
                                  picojson::object& answer_obj);
 
   std::map<std::string, std::string> callbacks_;