3 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
5 * Licensed under the Apache License, Version 2.0 (the License);
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
21 * @brief This file is the source file of implementation of functions which process sync request, auto configure etc..
26 #include <sync_agent.h>
27 #include <plugin/plugin_slp_device.h>
29 #include "service-engine/se_sync.h"
30 #include "service-engine/se_storage.h"
31 #include "service-engine/se_common.h"
32 #include "service-engine/se_notification.h"
33 #include "service-adapter/sa_common_interface.h"
34 #include "common/common_util.h"
35 #include "common/common_define_internal.h"
37 #ifndef OMADS_AGENT_LOG
39 #define LOG_TAG "OMA_DS_SE"
42 static se_error_type_e _session_process(int account_id, alert_type_e server_sync_type, sync_progress_e process, sync_error_e error);
43 static se_error_type_e __process_update(int account_id, alert_type_e server_sync_type, sync_progress_status_e progress_status, operation_type_e operation_type, int content_type, bool is_from_server, bool need_to_save, sync_result_s * sync_result);
44 static se_error_type_e _write_sync_data(int account_id, alert_type_e alert_type, sync_session_result_e sync_session_result, int last_session_time, int only_from_client);
45 static se_error_type_e ___write_sync_resource_info(int account_id, int content_type, int last_session_time, int only_from_client, sync_result_s * client_sync_result, sync_result_s * server_sync_result);
47 static se_error_type_e __init_datastore_info_array(int account_id);
48 static se_error_type_e ___set_datastore_info_array(int account_id, char *config_key, service_type_e content_type);
49 static se_error_type_e ___generate_datastore_info(int account_id, service_type_e content_type, datastore_s ** datastore);
50 static se_error_type_e __init_datastore_info(int account_id, service_type_e content_type, datastore_s ** datastore);
51 static se_error_type_e ___set_datastore_config(int account_id, int content_type, datastore_s ** datastore);
52 static se_error_type_e __get_sync_type(int account_id, alert_type_e * sync_type);
54 static se_error_type_e __on_synchronising_account(int account_id);
55 static se_error_type_e _off_synchronising_account(int account_id);
57 static se_error_type_e __on_resume_flag(int account_id);
58 static se_error_type_e _off_resume_flag(int account_id);
60 static se_error_type_e _assemble_changed_datastores(int account_id, alert_type_e server_sync_type, sync_obj_s ** sync_obj);
61 static se_error_type_e _prepare_pre_sync(int account_id, char *sync_mode, san_package_s * san_package, alert_type_e * sync_type);
62 static se_error_type_e __set_config_based_on_sync_mode(int account_id, char *sync_mode, san_package_s * san_package);
63 static se_error_type_e _execute_pre_sync(int account_id, int session_time, pre_sync_return_obj_s * pre_sync_return_obj, alert_type_e * server_sync_type);
64 static se_error_type_e __execute_pre_sync_set_server_id(int account_id, char *dev_id);
65 static se_error_type_e __execute_pre_sync_datastore(int account_id, int session_time, GList * datastore_info, alert_type_e * server_sync_type);
66 static se_error_type_e _execute_sync(int account_id, alert_type_e client_sync_type, alert_type_e server_sync_type, sync_obj_s ** sync_obj, sync_return_obj_s ** sync_return_obj);
67 static se_error_type_e __execute_sync_arrange_changelog(int account_id, alert_type_e sync_type, GList * status);
68 static se_error_type_e __execute_sync_status(int account_id, alert_type_e server_sync_type, sync_obj_s ** sync_obj, sync_return_obj_s ** sync_return_obj);
69 static se_error_type_e __execute_sync_change(int account_id, alert_type_e server_sync_type, sync_obj_s ** sync_obj, sync_return_obj_s ** sync_return_obj);
70 static se_error_type_e _update_sync_result(int account_id);
72 static command_result_e ___convert_return_status(sync_agent_da_return_e da_err);
73 static char *__convert_cttype_str(int itemTypeId);
74 static int ___convert_sync_type_value(char *sync_type_str);
75 static char *__convert_sync_type_str(alert_type_e sync_type);
76 static char *___convert_sync_progress_status_str(sync_progress_status_e progress_status);
77 static char *___convert_operation_type_str(operation_type_e operation_type);
78 static char *_convert_sync_progress_str(sync_progress_e process);
79 static char *_convert_sync_error_str(sync_error_e error);
80 static se_error_type_e _check_low_battery();
81 static se_error_type_e _open_services();
82 static se_error_type_e _close_services();
84 static inline long myclock()
88 return (tv.tv_sec * 1000 + tv.tv_usec / 1000);
91 static se_error_type_e _session_process(int account_id, alert_type_e server_sync_type, sync_progress_e process, sync_error_e error)
95 char *profileDirName = NULL;
96 se_error_type_e err = SE_INTERNAL_OK;
99 result = get_config(account_id, DEFINE_CONFIG_KEY_PROFILE_DIR_NAME, &profileDirName);
100 if (result == false) {
101 _DEBUG_ERROR("failed in get_Config");
102 err = SE_INTERNAL_DA_ERROR;
106 if (profileDirName != NULL) {
107 err = session_process(profileDirName, server_sync_type, process, error);
108 if (err != SE_INTERNAL_OK) {
109 _DEBUG_ERROR("failed to send noti");
115 if (profileDirName != NULL)
116 free(profileDirName);
123 static se_error_type_e __process_update(int account_id, alert_type_e server_sync_type, sync_progress_status_e progress_status, operation_type_e operation_type, int content_type, bool is_from_server, bool need_to_save, sync_result_s * sync_result)
127 _DEBUG_VERBOSE("account_id =%d, progress_status = %d, operation_type = %d, content_type = %d, isFromServer = %d, needToSave = %d ", account_id, progress_status, operation_type, content_type, is_from_server, need_to_save);
128 _DEBUG_VERBOSE("numberOfChange = %d, received_count = %d, syncCount = %d", sync_result->number_of_change, sync_result->received_count, sync_result->add_count + sync_result->replace_count + sync_result->delete_count);
130 se_error_type_e err = SE_INTERNAL_OK;
131 char *profileDirName = NULL;
133 char *sync_type = NULL;
134 char *operation = NULL;
135 char *progress = NULL;
138 result = get_config(account_id, DEFINE_CONFIG_KEY_PROFILE_DIR_NAME, &profileDirName);
139 if (result == false) {
140 _DEBUG_ERROR("failed in get_Config");
141 err = SE_INTERNAL_DA_ERROR;
145 /* do not need to send update noti to ui */
146 if (profileDirName == NULL) {
147 _DEBUG_VERBOSE("profileDirName is NULL");
151 if (need_to_save == true) {
152 err = write_sync_statistics(account_id, content_type, is_from_server, sync_result);
153 if (err != SE_INTERNAL_OK) {
154 _DEBUG_ERROR("failed in writeSyncStatistics");
159 sync_type = __convert_sync_type_str(server_sync_type);
161 progress = ___convert_sync_progress_status_str(progress_status);
163 operation = ___convert_operation_type_str(operation_type);
165 if (sync_type == NULL || progress == NULL || operation == NULL) {
166 err = SE_INTERNAL_NOT_DEFINED;
170 if (datastoreinfo_per_content_type[content_type] != NULL) {
171 if (datastoreinfo_per_content_type[content_type]->source != NULL)
172 uri = strdup(datastoreinfo_per_content_type[content_type]->source);
175 err = send_noti_process_update(profileDirName, sync_type, uri, progress, operation, is_from_server, 0, 0, sync_result->number_of_change, sync_result->add_count + sync_result->replace_count + sync_result->delete_count);
176 if (err != SE_INTERNAL_OK) {
177 _DEBUG_ERROR("failed in send_noti_process_update");
183 if (profileDirName != NULL)
184 free(profileDirName);
193 static se_error_type_e _write_sync_data(int account_id, alert_type_e alert_type, sync_session_result_e sync_session_result, int last_session_time, int only_from_client)
197 se_error_type_e err = SE_INTERNAL_OK;
199 err = write_profile_data(account_id, alert_type, sync_session_result, last_session_time, only_from_client);
200 if (err != SE_INTERNAL_OK) {
201 _DEBUG_ERROR("failed in writeProfileData");
211 static se_error_type_e ___write_sync_resource_info(int account_id, int content_type, int last_session_time, int only_from_client, sync_result_s * client_sync_result, sync_result_s * server_sync_result)
215 se_error_type_e err = SE_INTERNAL_OK;
217 err = write_sync_resource_info(account_id, content_type, last_session_time, only_from_client, client_sync_result, server_sync_result);
218 if (err != SE_INTERNAL_OK) {
219 _DEBUG_ERROR("failed in write_sync_resource_info");
229 static se_error_type_e __init_datastore_info_array(int account_id)
233 se_error_type_e err = SE_INTERNAL_OK;
235 err = ___set_datastore_info_array(account_id, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_CONTACTS, TYPE_CONTACT);
236 if (err != SE_INTERNAL_OK) {
237 _DEBUG_ERROR("failed in set_datastoreinfo_array");
241 err = ___set_datastore_info_array(account_id, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_CALENDAR, TYPE_CALENDAR);
242 if (err != SE_INTERNAL_OK) {
243 _DEBUG_ERROR("failed in set_datastoreinfo_array");
247 err = ___set_datastore_info_array(account_id, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_MEMO, TYPE_MEMO);
248 if (err != SE_INTERNAL_OK) {
249 _DEBUG_ERROR("failed in set_datastoreinfo_array");
253 err = ___set_datastore_info_array(account_id, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_CALLLOG, TYPE_CALLLOG);
254 if (err != SE_INTERNAL_OK) {
255 _DEBUG_ERROR("failed in set_datastoreinfo_array");
265 static se_error_type_e ___set_datastore_info_array(int account_id, char *config_key, service_type_e content_type)
269 se_error_type_e err = SE_INTERNAL_OK;
271 datastore_s *datastore_info = NULL;
275 result = get_config(account_id, config_key, &value);
276 if (result == true) {
277 if (strcmp(value, "1") == 0) {
278 err = ___generate_datastore_info(account_id, content_type, &datastore_info);
279 if (err != SE_INTERNAL_OK) {
280 _DEBUG_ERROR("failed to create or init datastore_info");
281 datastoreinfo_per_content_type[content_type] = NULL;
284 datastoreinfo_per_content_type[content_type] = datastore_info;
288 datastoreinfo_per_content_type[content_type] = NULL;
299 static se_error_type_e ___generate_datastore_info(int account_id, service_type_e content_type, datastore_s ** datastore)
302 _DEBUG_VERBOSE("content_type=[%d]\n", content_type);
304 se_error_type_e err = SE_INTERNAL_OK;
305 char *clientLastAnchor = NULL;
306 char *clientNextAnchor = NULL;
307 char *serverLastAnchor = NULL;
309 sync_agent_da_return_e da_err = SYNC_AGENT_DA_ERRORS;
311 sync_result_s *pSyncResult = NULL;
312 datastore_s *temp_datastore = NULL;
313 err = ___set_datastore_config(account_id, content_type, &temp_datastore);
314 if (err != SE_INTERNAL_OK) {
315 _DEBUG_ERROR("failed in set_datastore_config");
319 GList *anchor_list = NULL;
320 sync_agent_da_get_last_anchor_list_query_s query;
321 query.option = SYNC_AGENT_DA_GET_LAST_ANCHOR_LIST_OPTION_ITEM_TYPE_ID;
322 query.account_id = account_id;
323 query.item_type_id = temp_datastore->datastore_id;
325 da_err = sync_agent_get_last_anchor_list(&query, &anchor_list);
326 if (da_err != SYNC_AGENT_DA_SUCCESS) {
327 _DEBUG_ERROR("failed in sync_agent_get_last_anchor_list !!");
331 if (g_list_length(anchor_list) > 0) {
332 GList *last_anchor_info = g_list_nth(anchor_list, g_list_length(anchor_list) - 1);
333 clientLastAnchor = ((sync_agent_da_last_anchor_s *) (last_anchor_info->data))->last_anchor_client;
334 serverLastAnchor = ((sync_agent_da_last_anchor_s *) (last_anchor_info->data))->last_anchor_server;
336 sync_agent_da_last_anchor_s lastAnchor_daci;
338 lastAnchor_daci.account_id = account_id;
339 lastAnchor_daci.data_store_id = temp_datastore->datastore_id;
340 lastAnchor_daci.last_anchor_server = NULL;
341 lastAnchor_daci.last_anchor_client = NULL;
342 lastAnchor_daci.access_name = "Engine";
344 da_err = sync_agent_add_last_anchor(&lastAnchor_daci);
345 if (da_err != SYNC_AGENT_DA_SUCCESS) {
346 _DEBUG_ERROR("da_add_last_anchor_internal is failed %d", da_err);
347 err = SE_INTERNAL_DA_ERROR;
352 clientNextAnchor = g_strdup_printf("%ld", time(NULL));
354 _DEBUG_VERBOSE("clientLastAnchor = %s\n", clientLastAnchor);
355 _DEBUG_VERBOSE("serverLastAnchor = %s\n", serverLastAnchor);
356 _DEBUG_VERBOSE("clientNextAnchor = %s\n", clientNextAnchor);
358 /*slow sync if managed anchor info not exist.. (first sync) */
359 if (clientLastAnchor == NULL)
360 set_datastore_client_anchor(temp_datastore, clientNextAnchor, clientNextAnchor);
362 set_datastore_client_anchor(temp_datastore, clientLastAnchor, clientNextAnchor);
364 set_datastore_server_anchor(temp_datastore, serverLastAnchor, NULL);
366 pSyncResult = create_sync_result();
367 if (pSyncResult == NULL) {
368 _DEBUG_ERROR("create_syncResult is failed");
369 err = SE_INTERNAL_NO_MEMORY;
372 temp_datastore->client_sync_result = pSyncResult;
374 pSyncResult = create_sync_result();
375 if (pSyncResult == NULL) {
376 _DEBUG_ERROR("create_syncResult is failed");
377 err = SE_INTERNAL_NO_MEMORY;
380 temp_datastore->server_sync_result = pSyncResult;
382 *datastore = temp_datastore;
383 temp_datastore = NULL;
387 if (clientNextAnchor != NULL)
388 free(clientNextAnchor);
390 if (temp_datastore != NULL)
391 free_datastore(temp_datastore);
397 static se_error_type_e __init_datastore_info(int account_id, service_type_e content_type, datastore_s ** datastore)
401 se_error_type_e err = SE_INTERNAL_OK;
402 char *sourceDatastore = NULL;
404 datastore_s *temp_datastore = NULL;
405 sync_result_s *pSyncResult = NULL;
408 switch (content_type) {
410 snprintf(key, sizeof(key), "%s_%s", DEFINE_CONFIG_KEY_PROFILE_CATEGORY_CONTACTS, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_SOURCE);
413 snprintf(key, sizeof(key), "%s_%s", DEFINE_CONFIG_KEY_PROFILE_CATEGORY_CALENDAR, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_SOURCE);
416 snprintf(key, sizeof(key), "%s_%s", DEFINE_CONFIG_KEY_PROFILE_CATEGORY_MEMO, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_SOURCE);
419 snprintf(key, sizeof(key), "%s_%s", DEFINE_CONFIG_KEY_PROFILE_CATEGORY_CALLLOG, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_SOURCE);
422 _DEBUG_VERBOSE("unknown content type = %d", content_type);
426 _DEBUG_ERROR("content_type = %d", content_type);
427 _DEBUG_ERROR("key = %s", key);
428 result = get_config(account_id, key, &sourceDatastore);
429 if (result == false) {
430 _DEBUG_ERROR("failed in get_Config");
431 err = SE_INTERNAL_DA_ERROR;
435 temp_datastore = create_datastore(NULL, sourceDatastore);
436 if (temp_datastore == NULL) {
437 _DEBUG_ERROR("failed to create_Datastore");
438 err = SE_INTERNAL_NO_MEMORY;
442 pSyncResult = create_sync_result();
443 if (pSyncResult == NULL) {
444 _DEBUG_ERROR("create_syncResult is failed");
445 err = SE_INTERNAL_NO_MEMORY;
448 temp_datastore->client_sync_result = pSyncResult;
450 pSyncResult = create_sync_result();
451 if (pSyncResult == NULL) {
452 _DEBUG_ERROR("create_syncResult is failed");
453 err = SE_INTERNAL_NO_MEMORY;
456 temp_datastore->server_sync_result = pSyncResult;
458 *datastore = temp_datastore;
459 temp_datastore = NULL;
462 if (sourceDatastore != NULL)
463 free(sourceDatastore);
465 if (temp_datastore != NULL)
466 free_datastore(temp_datastore);
472 static se_error_type_e ___set_datastore_config(int account_id, int content_type, datastore_s ** datastore)
476 datastore_s *temp_datastore = NULL;
477 se_error_type_e err = SE_INTERNAL_OK;
478 sync_agent_da_return_e da_err = SYNC_AGENT_DA_SUCCESS;
480 char *contentType = NULL;
482 char sourceDatastore_key[128];
483 char targetDatastore_key[128];
487 char *sourceDatastore = NULL;
488 char *targetDatastore = NULL;
489 char *sync_type = NULL;
493 alert_type_e alert_type = ALERT_UNKNOWN;
495 GList *config_list = NULL;
497 sync_agent_da_config_s *config_data = NULL;
499 int folder_type_id = 0;
500 switch (content_type) {
504 contentType = DEFINE_CONFIG_KEY_PROFILE_CATEGORY_CONTACTS;
510 contentType = DEFINE_CONFIG_KEY_PROFILE_CATEGORY_CALENDAR;
516 contentType = DEFINE_CONFIG_KEY_PROFILE_CATEGORY_MEMO;
522 contentType = DEFINE_CONFIG_KEY_PROFILE_CATEGORY_CALLLOG;
526 _DEBUG_VERBOSE("unknown content type = %d", content_type);
527 err = SE_INTERNAL_ERROR;
531 snprintf(sourceDatastore_key, sizeof(sourceDatastore_key), "%s_%s", contentType, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_SOURCE);
532 snprintf(targetDatastore_key, sizeof(targetDatastore_key), "%s_%s", contentType, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_TARGET);
533 snprintf(id_key, sizeof(id_key), "%s_%s", contentType, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_ID);
534 snprintf(pw_key, sizeof(id_key), "%s_%s", contentType, DEFINE_CONFIG_KEY_PROFILE_CATEGORY_PASSWORD);
536 da_err = sync_agent_get_config_list(account_id, &config_list);
537 if (da_err != SYNC_AGENT_DA_SUCCESS) {
538 err = SE_INTERNAL_DA_ERROR;
542 for (iter = config_list; iter != NULL; iter = g_list_next(iter)) {
543 config_data = (sync_agent_da_config_s *) iter->data;
545 if (config_data != NULL) {
546 if (config_data->key != NULL) {
547 if (strcmp(config_data->key, sourceDatastore_key) == 0) {
548 if (config_data->value != NULL)
549 sourceDatastore = strdup(config_data->value);
552 if (strcmp(config_data->key, targetDatastore_key) == 0) {
553 if (config_data->value != NULL)
554 targetDatastore = strdup(config_data->value);
557 if (strcmp(config_data->key, DEFINE_CONFIG_KEY_PROFILE_CLIENT_SYNC_TYPE) == 0) {
558 if (config_data->value != NULL)
559 sync_type = strdup(config_data->value);
562 if (strcmp(config_data->key, id_key) == 0) {
563 if (config_data->value != NULL)
564 id = strdup(config_data->value);
567 if (strcmp(config_data->key, pw_key) == 0) {
568 if (config_data->value != NULL)
569 pw = strdup(config_data->value);
575 if (sync_type != NULL) {
576 alert_type = ___convert_sync_type_value(sync_type);
578 _DEBUG_ERROR("sync_type is NULL !");
579 err = SE_INTERNAL_ERROR;
583 _DEBUG_VERBOSE("get_Config result sourceDatastore= %s ", sourceDatastore);
584 _DEBUG_VERBOSE("get_Config result targetDatastore= %s ", targetDatastore);
585 _DEBUG_VERBOSE("get_Config result alert_type= %s ", sync_type);
586 _DEBUG_VERBOSE("get_Config result id= %s ", id);
587 _DEBUG_VERBOSE("get_Config result pw= %s ", pw);
589 temp_datastore = create_datastore(targetDatastore, sourceDatastore);
590 if (temp_datastore == NULL) {
591 _DEBUG_ERROR("temp_datastore is NULL");
592 err = SE_INTERNAL_ERROR;
596 set_datastore_content_type_info(temp_datastore, content_type, folder_type_id);
597 set_datastore_account_info(temp_datastore, id, pw);
598 set_datastore_client_sync_type(temp_datastore, alert_type);
600 *datastore = temp_datastore;
601 temp_datastore = NULL;
605 if (sourceDatastore != NULL)
606 free(sourceDatastore);
608 if (targetDatastore != NULL)
609 free(targetDatastore);
611 if (sync_type != NULL)
624 static se_error_type_e __get_sync_type(int account_id, alert_type_e * alert_type)
628 se_error_type_e err = SE_INTERNAL_OK;
629 char *sync_type = NULL;
631 bool result = get_config(account_id, DEFINE_CONFIG_KEY_PROFILE_CLIENT_SYNC_TYPE, &sync_type);
632 if (result == false) {
633 _DEBUG_ERROR("failed in get_Config");
634 err = SE_INTERNAL_DA_ERROR;
638 *alert_type = ___convert_sync_type_value(sync_type);
642 if (sync_type != NULL)
649 static se_error_type_e __on_synchronising_account(int account_id)
653 se_error_type_e err = SE_INTERNAL_OK;
655 bool result = set_config_str(account_id, DEFINE_CONFIG_KEY_PROFILE_SYNCHRONISING, "1", "string", "SE");
656 if (result == false) {
657 _DEBUG_ERROR("failed in set_Config");
658 err = SE_INTERNAL_DA_ERROR;
668 static se_error_type_e _off_synchronising_account(int account_id)
672 se_error_type_e err = SE_INTERNAL_OK;
674 bool result = set_config_str(account_id, DEFINE_CONFIG_KEY_PROFILE_SYNCHRONISING, "0", "string", "SE");
675 if (result == false) {
676 _DEBUG_ERROR("failed in set_Config");
677 err = SE_INTERNAL_DA_ERROR;
687 static se_error_type_e __on_resume_flag(int account_id)
691 se_error_type_e err = SE_INTERNAL_OK;
693 bool result = set_config_str(account_id, DEFINE_CONFIG_KEY_PROFILE_RESUME, "1", "string", "SE");
694 if (result == false) {
695 _DEBUG_ERROR("failed in set_Config");
696 err = SE_INTERNAL_DA_ERROR;
706 static se_error_type_e _off_resume_flag(int account_id)
710 se_error_type_e err = SE_INTERNAL_OK;
712 bool result = set_config_str(account_id, DEFINE_CONFIG_KEY_PROFILE_RESUME, "0", "string", "SE");
713 if (result == false) {
714 _DEBUG_ERROR("failed in set_Config");
715 err = SE_INTERNAL_DA_ERROR;
725 static se_error_type_e _assemble_changed_datastores(int account_id, alert_type_e server_sync_type, sync_obj_s ** sync_obj)
729 se_error_type_e err = SE_INTERNAL_OK;
730 changed_datastore_s *pChangedDatastore = NULL;
731 sync_agent_da_return_e da_err = SYNC_AGENT_DA_SUCCESS;
734 for (content_type = 0; content_type < TYPE_SERVICE_COUNT; content_type++) {
735 if (datastoreinfo_per_content_type[content_type] != NULL) {
736 if (!datastoreinfo_per_content_type[content_type]->client_sync_type)
739 if (datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_SLOW_SYNC
740 || datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_REFRESH_FROM_CLIENT || datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_REFRESH_FROM_CLIENT_BY_SERVER) {
742 if (content_type == TYPE_CALLLOG) {
743 _DEBUG_TRACE("sync_agent_refresh_item_tbl_from_service for call log");
744 sync_agent_refresh_item_tbl_from_service(account_id, datastoreinfo_per_content_type[content_type]->datastore_id);
747 GList *item_list = NULL;
748 sync_agent_da_get_item_list_query_s query;
749 query.option = SYNC_AGENT_DA_GET_ITEM_LIST_OPTION_ACCOUNT_ID;
750 query.item_type_id = datastoreinfo_per_content_type[content_type]->datastore_id;
752 da_err = sync_agent_get_item_list(account_id, &query, &item_list);
753 if (da_err != SYNC_AGENT_DA_SUCCESS) {
754 _DEBUG_ERROR("failed in sync_agent_get_item_list !!");
757 pChangedDatastore = create_changed_datastore(datastoreinfo_per_content_type[content_type]->source, datastoreinfo_per_content_type[content_type]->target, 1, g_list_length(item_list));
759 if (pChangedDatastore == NULL) {
760 sync_agent_free_item_list(item_list);
761 _DEBUG_ERROR("failed in create_ChangedDatastore");
762 err = SE_INTERNAL_NO_MEMORY;
766 if (g_list_length(item_list) > 0) {
768 sync_agent_da_item_s *iter_data;
769 for (iter = item_list; iter != NULL; iter = g_list_next(iter)) {
771 iter_data = (sync_agent_da_item_s *) (iter->data);
772 if (iter_data != NULL) {
773 char *cttype = __convert_cttype_str(iter_data->data_store_id);
774 changed_item_s *pChanged = create_changed_item(CHANGE_ADD, iter_data->item_id);
775 if (pChanged == NULL) {
776 sync_agent_free_item_list(item_list);
777 _DEBUG_ERROR("failed in create_ChangedDatastore");
778 err = SE_INTERNAL_NO_MEMORY;
782 set_changed_item_content_type(pChanged, cttype);
783 set_changed_item_index_of_datastore(pChanged, content_type);
785 add_changed_datastore_changed_item(pChangedDatastore, pChanged);
787 _DEBUG_ERROR("iter_data is NULL !!");
788 sync_agent_free_item_list(item_list);
789 err = SE_INTERNAL_NO_MEMORY;
794 sync_agent_free_item_list(item_list);
797 GList *item_id_list = NULL;
799 sync_agent_da_get_item_id_list_query_s item_id_query = {0,};
800 item_id_query.option = SYNC_AGENT_DA_GET_ITEM_ID_LIST_OPTION_OPERATION_ID_N_ITEM_TYPE_ID;
801 item_id_query.account_id = account_id;
802 item_id_query.item_type_id = datastoreinfo_per_content_type[content_type]->datastore_id;
803 item_id_query.operation_id = SYNC_AGENT_DA_CHANGE_OPERATION_DELETE;
805 da_err = sync_agent_get_item_id_list(&item_id_query, &item_id_list);
806 if (da_err != SYNC_AGENT_DA_SUCCESS) {
807 _DEBUG_ERROR("failed in sync_agent_get_item_id_list !!");
808 err = SE_INTERNAL_DA_ERROR;
812 GList *item_id_iter = NULL;
815 if (g_list_length(item_id_list) > 0) {
816 for (item_id_iter = item_id_list; item_id_iter != NULL; item_id_iter = g_list_next(item_id_iter)) {
818 item_id = (char *)(item_id_iter->data);
820 da_err = sync_agent_delete_item(item_id, 1);
821 if (da_err != SYNC_AGENT_DA_SUCCESS) {
822 _DEBUG_ERROR("failed in sync_agent_delete_item !!");
823 sync_agent_free_item_id_list(item_id_list);
824 err = SE_INTERNAL_DA_ERROR;
830 sync_agent_free_item_id_list(item_id_list);
832 /*delete changelog data by account id and datastore id */
833 sync_agent_da_delete_changelog_query_s delete_ch_query = {0,};
834 delete_ch_query.option = SYNC_AGENT_DA_DELETE_CHANGELOG_OPTION_ITEM_TYPE_ID;
835 delete_ch_query.item_type_id = datastoreinfo_per_content_type[content_type]->datastore_id;
837 da_err = sync_agent_delete_changelog(account_id, &delete_ch_query);
838 if (da_err != SYNC_AGENT_DA_SUCCESS) {
839 _DEBUG_ERROR("failed in sync_agent_delete_changelog !!");
840 err = SE_INTERNAL_DA_ERROR;
843 } else if (datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_TWO_WAY
844 || datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_TWO_WAY_BY_SERVER
845 || datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_ONE_WAY_FROM_CLIENT || datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_ONE_WAY_FROM_CLIENT_BY_SERVER) {
846 _DEBUG_TRACE("server sync type is ALERT_TYPE [%d]", datastoreinfo_per_content_type[content_type]->server_sync_type);
848 /*on resume flag into agent DB */
849 err = __on_resume_flag(account_id);
850 if (err != SE_INTERNAL_OK) {
851 _DEBUG_ERROR("failed in __on_resume_flag");
855 if (content_type == TYPE_CALLLOG) {
856 _DEBUG_TRACE("sync_agent_construct_item_tbl_from_service for call log");
857 sync_agent_construct_item_tbl_from_service(account_id, content_type);
861 GList *item_info_list = NULL;
862 sync_agent_da_get_changelog_list_query_s get_ch_query;
863 get_ch_query.option = SYNC_AGENT_DA_GET_CHANGELOG_LIST_OPTION_ITEM_TYPE_ID;
864 get_ch_query.account_id = account_id;
865 get_ch_query.item_type_id = datastoreinfo_per_content_type[content_type]->datastore_id;
867 da_err = sync_agent_get_changelog_list(&get_ch_query, &item_info_list);
868 if (da_err != SYNC_AGENT_DA_SUCCESS) {
869 _DEBUG_ERROR("failed in sync_agent_get_changelog_list !!");
870 err = SE_INTERNAL_NO_MEMORY;
874 pChangedDatastore = create_changed_datastore(datastoreinfo_per_content_type[content_type]->source, datastoreinfo_per_content_type[content_type]->target, 1, g_list_length(item_info_list));
876 if (pChangedDatastore == NULL) {
877 sync_agent_free_changelog_list(item_info_list);
878 _DEBUG_ERROR("failed in create_ChangedDatastore");
879 err = SE_INTERNAL_NO_MEMORY;
883 /*gathering changelog info */
884 if (g_list_length(item_info_list) > 0) {
885 char *cttype = __convert_cttype_str(datastoreinfo_per_content_type[content_type]->datastore_id);
887 GList *item_info_iter = NULL;
888 sync_agent_da_item_changelog_s *iter_data;
890 for (item_info_iter = item_info_list; item_info_iter != NULL; item_info_iter = g_list_next(item_info_iter)) {
892 iter_data = (sync_agent_da_item_changelog_s *) (item_info_iter->data);
894 if (iter_data != NULL) {
895 changed_item_s *pChanged = create_changed_item(iter_data->operation_id - 300, iter_data->item_id);
896 if (pChanged == NULL) {
897 sync_agent_free_changelog_list(item_info_list);
898 _DEBUG_ERROR("failed in create_ChangedDatastore");
899 err = SE_INTERNAL_NO_MEMORY;
903 set_changed_item_content_type(pChanged, cttype);
904 set_changed_item_index_of_datastore(pChanged, content_type);
905 add_changed_datastore_changed_item(pChangedDatastore, pChanged);
907 sync_agent_free_changelog_list(item_info_list);
908 _DEBUG_ERROR("iter_data is NULL !!");
909 err = SE_INTERNAL_NO_MEMORY;
914 int *itemTypeIdList = (int *)calloc(1, sizeof(int));
915 if (itemTypeIdList == NULL) {
916 _DEBUG_ERROR("failed in da_set_item_changelog_wait_status_internal");
917 err = SE_INTERNAL_NO_MEMORY;
921 itemTypeIdList[0] = datastoreinfo_per_content_type[content_type]->datastore_id;
923 sync_agent_da_update_changelog_query_s query;
924 query.option = SYNC_AGENT_DA_UPDATE_CHANGELOG_OPTION_WAIT_STATUS;
925 query.folder_id_list = NULL;
926 query.folder_id_count = 0;
927 query.item_type_id_list = itemTypeIdList;
928 query.item_type_id_count = 1;
930 da_err = sync_agent_update_changelog(account_id, &query);
932 sync_agent_free_changelog_list(item_info_list);
934 if (itemTypeIdList != NULL)
935 free(itemTypeIdList);
936 if (da_err != SYNC_AGENT_DA_SUCCESS) {
937 _DEBUG_ERROR("failed in sync_agent_update_changelog !!");
938 err = SE_INTERNAL_DA_ERROR;
942 } else if (datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_ONE_WAY_FROM_SERVER
943 || datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_ONE_WAY_FROM_SERVER_BY_SERVER
944 || datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_REFRESH_FROM_SERVER || datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_REFRESH_FROM_SERVER_BY_SERVER) {
946 if (datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_ONE_WAY_FROM_SERVER) {
947 /*on resume flag into agent DB */
948 err = __on_resume_flag(account_id);
949 if (err != SE_INTERNAL_OK) {
950 _DEBUG_ERROR("failed in __on_resume_flag");
955 /*MUST create empty changedDatastore.. */
956 pChangedDatastore = create_changed_datastore(datastoreinfo_per_content_type[content_type]->source, datastoreinfo_per_content_type[content_type]->target, 1, 0);
957 if (pChangedDatastore == NULL) {
958 _DEBUG_ERROR("pChangedDatastore is NULL");
959 err = SE_INTERNAL_NO_MEMORY;
963 if (datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_REFRESH_FROM_SERVER || datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_REFRESH_FROM_SERVER_BY_SERVER) {
965 /*_DEBUG_TRACE("sync_agent_refresh_item_tbl_from_service");
966 sync_agent_refresh_item_tbl_from_service(account_id, datastoreinfo_per_content_type[content_type]->plugin_type);*/
968 /* Delete All item (include changelog), before adapting server item data… */
969 _DEBUG_TRACE("sync_agent_begin_service = %d", datastoreinfo_per_content_type[content_type]->datastore_id);
970 sync_agent_begin_service(datastoreinfo_per_content_type[content_type]->datastore_id);
971 sync_agent_begin_transaction();
973 /*delete service item data */
974 sync_agent_da_delete_service_item_query_s query;
975 query.content_type = datastoreinfo_per_content_type[content_type]->datastore_id;
976 query.account_id = account_id;
978 da_err = sync_agent_query_delete_service_items(&query);
979 if (da_err != SYNC_AGENT_DA_SUCCESS) {
981 sync_agent_end_service(datastoreinfo_per_content_type[content_type]->datastore_id, 0);
982 sync_agent_end_transaction(SYNC_AGENT_DA_TRANSACTION_ROLLBACK);
984 _DEBUG_ERROR("failed in sync_agent_query_delete_service_items()");
985 err = SE_INTERNAL_DA_ERROR;
989 _DEBUG_TRACE("da_get_item_by_account_id_internal");
990 /*get all item by account id */
991 GList *item_list = NULL;
992 sync_agent_da_get_item_list_query_s get_item_query;
993 get_item_query.option = SYNC_AGENT_DA_GET_ITEM_LIST_OPTION_ACCOUNT_ID;
994 get_item_query.item_type_id = datastoreinfo_per_content_type[content_type]->datastore_id;
996 da_err = sync_agent_get_item_list(account_id, &get_item_query, &item_list);
997 if (da_err != SYNC_AGENT_DA_SUCCESS) {
998 _DEBUG_ERROR("failed in sync_agent_get_item_list !!");
1000 _DEBUG_TRACE("item_cnt = %d", g_list_length(item_list));
1002 GList *item_iter = NULL;
1003 sync_agent_da_item_s *item_iter_data;
1004 for (item_iter = item_list; item_iter != NULL; item_iter = g_list_next(item_iter)) {
1005 item_iter_data = NULL;
1006 item_iter_data = (sync_agent_da_item_s *) (item_iter->data);
1008 GList *mapping_list = NULL;
1009 sync_agent_da_get_item_list_query_s mapping_query;
1010 mapping_query.option = SYNC_AGENT_DA_GET_ITEM_LIST_OPTION_SERVICE_ID_MAPPING;
1011 mapping_query.item_id = item_iter_data->item_id;
1013 da_err = sync_agent_get_item_list(account_id, &mapping_query, &mapping_list);
1014 if (da_err != SYNC_AGENT_DA_SUCCESS) {
1015 _DEBUG_ERROR("failed in sync_agent_get_item_list !!");
1018 _DEBUG_TRACE("acc_cnt = %d", g_list_length(mapping_list));
1020 GList *mapping_iter = NULL;
1021 sync_agent_da_item_s *mapping_iter_data;
1023 for (mapping_iter = mapping_list; mapping_iter != NULL; mapping_iter = g_list_next(mapping_iter)) {
1024 mapping_iter_data = NULL;
1025 mapping_iter_data = (sync_agent_da_item_s *) (mapping_iter->data);
1026 da_err = sync_agent_delete_item(mapping_iter_data->item_id, 1);
1027 if (da_err != SYNC_AGENT_DA_SUCCESS) {
1028 _DEBUG_ERROR("failed in sync_agent_delete_item !!");
1032 sync_agent_free_item_list(mapping_list);
1035 /*delete changelog data by account id and datastore id */
1036 _DEBUG_TRACE("da_delete_item_changelog_by_item_type_id_internal = %d", datastoreinfo_per_content_type[content_type]->datastore_id);
1038 sync_agent_da_delete_changelog_query_s delete_ch_query;
1039 delete_ch_query.option = SYNC_AGENT_DA_DELETE_CHANGELOG_OPTION_ITEM_TYPE_ID;
1040 delete_ch_query.item_type_id = datastoreinfo_per_content_type[content_type]->datastore_id;
1042 da_err = sync_agent_delete_changelog(account_id, &delete_ch_query);
1043 if (da_err != SYNC_AGENT_DA_SUCCESS) {
1045 sync_agent_free_item_list(item_list);
1047 sync_agent_end_service(datastoreinfo_per_content_type[content_type]->datastore_id, 0);
1048 sync_agent_end_transaction(SYNC_AGENT_DA_TRANSACTION_ROLLBACK);
1050 _DEBUG_ERROR("failed in sync_agent_delete_changelog !!");
1051 err = SE_INTERNAL_DA_ERROR;
1055 /*delete item from item_tbl */
1056 _DEBUG_TRACE("da_delete_item_by_item_type_id_internal = %d", datastoreinfo_per_content_type[content_type]->datastore_id);
1057 sync_agent_da_delete_item_query_s delete_item_query;
1058 delete_item_query.option = SYNC_AGENT_DA_DELETE_ITEM_OPTION_ITEM_TYPE_ID;
1059 delete_item_query.account_id = account_id;
1060 delete_item_query.item_type_id = datastoreinfo_per_content_type[content_type]->datastore_id;
1062 da_err = sync_agent_query_delete_item(&delete_item_query);
1063 if (da_err != SYNC_AGENT_DA_SUCCESS) {
1064 sync_agent_free_item_list(item_list);
1066 sync_agent_end_service(datastoreinfo_per_content_type[content_type]->datastore_id, 0);
1067 sync_agent_end_transaction(SYNC_AGENT_DA_TRANSACTION_ROLLBACK);
1069 _DEBUG_ERROR("failed in sync_agent_query_delete_item !!");
1070 err = SE_INTERNAL_DA_ERROR;
1074 _DEBUG_TRACE("sync_agent_end_service = %d", datastoreinfo_per_content_type[content_type]->datastore_id);
1075 sync_agent_end_service(datastoreinfo_per_content_type[content_type]->datastore_id, 1);
1076 sync_agent_end_transaction(SYNC_AGENT_DA_TRANSACTION_COMMIT);
1077 sync_agent_free_item_list(item_list);
1080 if (datastoreinfo_per_content_type[content_type]->client_sync_type) {
1081 (*sync_obj)->changed_datastore = g_list_append((*sync_obj)->changed_datastore, pChangedDatastore);
1084 if (pChangedDatastore != NULL) {
1085 set_number_of_change(datastoreinfo_per_content_type[content_type]->client_sync_result, pChangedDatastore->number_of_changes);
1087 _DEBUG_ERROR("pChangedDatastore is NULL !");
1090 operation_type_e operation_type;
1091 if (datastoreinfo_per_content_type[content_type]->client_sync_result->number_of_change == 0)
1092 operation_type = OPERATION_NOOP;
1094 operation_type = OPERATION_ADD;
1095 err = __process_update(account_id, server_sync_type, SYNC_PROGRESS_SUCCESS, operation_type, content_type, false, false, datastoreinfo_per_content_type[content_type]->client_sync_result);
1096 if (err != SE_INTERNAL_OK) {
1097 _DEBUG_ERROR("Failed in process_update");
1109 if (pChangedDatastore != NULL) {
1110 free_changed_datastore(pChangedDatastore);
1111 pChangedDatastore = NULL;
1118 static se_error_type_e _prepare_pre_sync(int account_id, char *sync_mode, san_package_s * san_package, alert_type_e * sync_type)
1122 se_error_type_e err = SE_INTERNAL_OK;
1124 /*set synchronising flag into agent DB */
1125 err = __on_synchronising_account(account_id);
1126 if (err != SE_INTERNAL_OK) {
1127 _DEBUG_ERROR("failed in __on_synchronising_account");
1132 err = __get_sync_type(account_id, sync_type);
1133 if (err != SE_INTERNAL_OK) {
1134 _DEBUG_ERROR("failed in __get_sync_type");
1138 /*init datastore_info_array */
1139 err = __init_datastore_info_array(account_id);
1140 if (err != SE_INTERNAL_OK) {
1141 _DEBUG_ERROR("failed in __init_datastore_info_array");
1145 /*set config based on sync mode */
1146 err = __set_config_based_on_sync_mode(account_id, sync_mode, san_package);
1147 if (err != SE_INTERNAL_OK) {
1148 _DEBUG_ERROR("failed in __set_config_based_on_sync_mode");
1158 static se_error_type_e __set_config_based_on_sync_mode(int account_id, char *sync_mode, san_package_s * san_package)
1162 se_error_type_e err = SE_INTERNAL_OK;
1165 if (strcmp(sync_mode, DEFINE_SYNC_MODE_PUSH) == 0) {
1166 if (san_package != NULL) {
1167 int count = san_package->cnt_sync_alerts;
1168 _DEBUG_TRACE("count = %d", count);
1170 for (i = 0; i < count; i++) {
1171 for (content_type = 0; content_type < TYPE_SERVICE_COUNT; content_type++) {
1173 if (datastoreinfo_per_content_type[content_type] != NULL) {
1174 _DEBUG_TRACE("datastoreinfo_per_content_type[content_type]->target = %s", datastoreinfo_per_content_type[content_type]->target);
1175 if (datastoreinfo_per_content_type[content_type]->target == NULL)
1178 if (strcmp(san_package->sync_alerts[i].server_uri, datastoreinfo_per_content_type[content_type]->target) == 0) {
1179 datastoreinfo_per_content_type[content_type]->client_sync_type = san_package->sync_alerts[i].sync_type;
1180 _DEBUG_TRACE("san_package->syncAlerts[i].sync_type = %d", san_package->sync_alerts[i].sync_type);
1182 datastoreinfo_per_content_type[content_type]->client_sync_type = ALERT_UNKNOWN;
1193 static se_error_type_e _execute_pre_sync(int account_id, int session_time, pre_sync_return_obj_s * pre_sync_return_obj, alert_type_e * server_sync_type)
1197 se_error_type_e err = SE_INTERNAL_OK;
1199 /*if there is no alert command from server check it and goto fail_part */
1200 if (g_list_length(pre_sync_return_obj->datastore_info) == 0) {
1201 _DEBUG_TRACE("alert command list from server is empty");
1202 err = SE_INTERNAL_MISCONFIGURATION;
1206 err = __execute_pre_sync_set_server_id(account_id, pre_sync_return_obj->dev_id);
1207 if (err != SE_INTERNAL_OK) {
1208 _DEBUG_ERROR("failed in __set_server_id");
1212 err = __execute_pre_sync_datastore(account_id, session_time, pre_sync_return_obj->datastore_info, server_sync_type);
1213 if (err != SE_INTERNAL_OK) {
1214 _DEBUG_ERROR("failed in __process_datastore");
1225 static se_error_type_e __execute_pre_sync_set_server_id(int account_id, char *dev_id)
1229 se_error_type_e err = SE_INTERNAL_OK;
1233 if (dev_id != NULL) {
1234 result = get_config(account_id, DEFINE_CONFIG_KEY_PROFILE_SERVER_ID, &value);
1235 if (result == true) {
1236 if (value != NULL) {
1237 if (strcmp(value, dev_id) == 0) {
1240 result = set_config_str(account_id, DEFINE_CONFIG_KEY_PROFILE_SERVER_ID, dev_id, "string", "SE");
1241 if (result == false) {
1242 _DEBUG_ERROR("failed in set_Config");
1243 err = SE_INTERNAL_DA_ERROR;
1248 result = set_config_str(account_id, DEFINE_CONFIG_KEY_PROFILE_SERVER_ID, dev_id, "string", "SE");
1249 if (result == false) {
1250 _DEBUG_ERROR("failed in set_Config");
1251 err = SE_INTERNAL_DA_ERROR;
1256 _DEBUG_ERROR("failed in get_Config");
1257 err = SE_INTERNAL_DA_ERROR;
1263 if (value != NULL) {
1272 static se_error_type_e __execute_pre_sync_datastore(int account_id, int session_time, GList * datastore_info, alert_type_e * server_sync_type)
1276 se_error_type_e err = SE_INTERNAL_OK;
1279 bool changeSyncType = false;
1280 alert_type_e sync_type = ALERT_UNKNOWN;
1283 GList *serverDatastore_iter = NULL;
1284 datastore_info_s *serverDatastoreInfo = NULL;
1285 bool existInServerDatastore;
1286 for (content_type = 0; content_type < TYPE_SERVICE_COUNT; content_type++) {
1287 existInServerDatastore = false;
1289 if (datastoreinfo_per_content_type[content_type] != NULL) {
1290 if (datastoreinfo_per_content_type[content_type]->client_sync_type) {
1291 _DEBUG_VERBOSE("datastoreinfo_per_content_type[%d]->client_sync_type = %d", content_type, datastoreinfo_per_content_type[content_type]->client_sync_type);
1293 for (serverDatastore_iter = datastore_info; serverDatastore_iter != NULL; serverDatastore_iter = g_list_next(serverDatastore_iter)) {
1294 serverDatastoreInfo = serverDatastore_iter->data;
1296 if (strcmp(serverDatastoreInfo->source, datastoreinfo_per_content_type[content_type]->target) == 0) {
1297 existInServerDatastore = true;
1299 if (serverDatastoreInfo->next_anchor != NULL)
1300 datastoreinfo_per_content_type[content_type]->next_anchor_server = strdup(serverDatastoreInfo->next_anchor);
1302 datastoreinfo_per_content_type[content_type]->server_sync_type = serverDatastoreInfo->sync_type;
1304 if (datastoreinfo_per_content_type[content_type]->client_sync_type != datastoreinfo_per_content_type[content_type]->server_sync_type) {
1305 changeSyncType = true;
1306 sync_type = datastoreinfo_per_content_type[content_type]->server_sync_type;
1309 _DEBUG_VERBOSE("datastoreinfo_per_content_type[%d]->server_sync_type = %d", content_type, datastoreinfo_per_content_type[content_type]->server_sync_type);
1311 if (datastoreinfo_per_content_type[content_type]->last_anchor_server) {
1312 /*if (strcmp(datastoreinfo_per_content_type[content_type]->lastAnchorServer, serverDatastoreInfo->lastAnchor) != 0) {
1313 free(datastoreinfo_per_content_type[content_type]->lastAnchorServer);
1314 datastoreinfo_per_content_type[content_type]->lastAnchorServer = NULL;
1315 datastoreinfo_per_content_type[content_type]->server_sync_type == ALERT_SLOW_SYNC;
1318 /* When first synchronize, lastAnchorServer is NULL...
1319 if (datastoreinfo_per_content_type[content_type]->server_sync_type != ALERT_SLOW_SYNC
1320 && datastoreinfo_per_content_type[content_type]->server_sync_type != ALERT_REFRESH_FROM_CLIENT
1321 && datastoreinfo_per_content_type[content_type]->server_sync_type != ALERT_REFRESH_FROM_CLIENT_BY_SERVER
1322 && datastoreinfo_per_content_type[content_type]->server_sync_type != ALERT_REFRESH_FROM_SERVER
1323 && datastoreinfo_per_content_type[content_type]->server_sync_type != ALERT_REFRESH_FROM_SERVER_BY_SERVER) {
1324 _DEBUG_VERBOSE("sync_agent_refresh_item_tbl_from_service");
1325 sync_agent_refresh_item_tbl_from_service(account_id, datastoreinfo_per_content_type[content_type]->plugin_type);
1332 if (!existInServerDatastore) {
1333 /* datastore config is wrong this datastore is not going to contain sync process from now */
1334 err = __process_update(account_id, ALERT_UNKNOWN, SYNC_FAILED_DB_CONFIG, OPERATION_NOOP, content_type, false, true, datastoreinfo_per_content_type[content_type]->client_sync_result);
1335 if (err != SE_INTERNAL_OK) {
1336 _DEBUG_ERROR("failed to process_update");
1340 err = __process_update(account_id, ALERT_UNKNOWN, SYNC_FAILED_DB_CONFIG, OPERATION_NOOP, content_type, true, true, datastoreinfo_per_content_type[content_type]->server_sync_result);
1341 if (err != SE_INTERNAL_OK) {
1342 _DEBUG_ERROR("failed to process_update");
1346 /* set fail into result (both client and server) */
1347 if (datastoreinfo_per_content_type[content_type]->client_sync_result != NULL)
1348 datastoreinfo_per_content_type[content_type]->client_sync_result->session_result = SYNC_SESSION_FAILED;
1349 if (datastoreinfo_per_content_type[content_type]->server_sync_result != NULL)
1350 datastoreinfo_per_content_type[content_type]->server_sync_result->session_result = SYNC_SESSION_FAILED;
1352 err = ___write_sync_resource_info(account_id, content_type, session_time, 0, datastoreinfo_per_content_type[content_type]->client_sync_result, datastoreinfo_per_content_type[content_type]->server_sync_result);
1353 if (err != SE_INTERNAL_OK) {
1354 _DEBUG_ERROR("failed to write_SyncResourceInfo");
1358 free_datastore(datastoreinfo_per_content_type[content_type]);
1359 datastoreinfo_per_content_type[content_type] = NULL;
1361 datastore_s *datastore = NULL;
1362 err = __init_datastore_info(account_id, content_type, &datastore);
1363 if (err != SE_INTERNAL_OK) {
1364 _DEBUG_ERROR("failed to init_datastore_info");
1368 datastoreinfo_per_content_type[content_type] = datastore;
1374 if (changeSyncType) {
1375 *server_sync_type = sync_type;
1376 result = set_config_str(account_id, DEFINE_CONFIG_KEY_PROFILE_SERVER_SYNC_TYPE, __convert_sync_type_str(sync_type), "string", "SE");
1377 if (result == false) {
1378 _DEBUG_ERROR("failed in set_config");
1379 err = SE_INTERNAL_DA_ERROR;
1390 static se_error_type_e _execute_sync(int account_id, alert_type_e client_sync_type, alert_type_e server_sync_type, sync_obj_s ** sync_obj, sync_return_obj_s ** sync_return_obj)
1394 se_error_type_e err = SE_INTERNAL_OK;
1396 if (client_sync_type == ALERT_TWO_WAY || client_sync_type == ALERT_TWO_WAY_BY_SERVER || client_sync_type == ALERT_ONE_WAY_FROM_CLIENT || client_sync_type == ALERT_ONE_WAY_FROM_CLIENT_BY_SERVER) {
1398 err = __execute_sync_arrange_changelog(account_id, client_sync_type, (*sync_return_obj)->status);
1399 if (err != SE_INTERNAL_OK) {
1400 _DEBUG_ERROR("failed to process_update");
1405 err = __execute_sync_status(account_id, server_sync_type, sync_obj, sync_return_obj);
1406 if (err != SE_INTERNAL_OK) {
1407 _DEBUG_ERROR("failed in __execute_sync_status");
1411 err = __execute_sync_change(account_id, server_sync_type, sync_obj, sync_return_obj);
1412 if (err != SE_INTERNAL_OK) {
1413 _DEBUG_ERROR("failed in __execute_sync_change");
1423 static se_error_type_e __execute_sync_arrange_changelog(int account_id, alert_type_e sync_type, GList * status)
1427 se_error_type_e err = SE_INTERNAL_OK;
1428 sync_agent_da_return_e da_err;
1432 int list_length = g_list_length(status);
1433 char **itemIdList = (char **)calloc(list_length, sizeof(char *));
1434 if (itemIdList == NULL) {
1435 _DEBUG_ERROR("Failed to alloc memory");
1436 err = SE_INTERNAL_NO_MEMORY;
1440 GList *appliedStatus_iter = NULL;
1441 applied_status_s *pAppliedStatus = NULL;
1442 for (appliedStatus_iter = status; appliedStatus_iter != NULL; appliedStatus_iter = g_list_next(appliedStatus_iter)) {
1443 pAppliedStatus = appliedStatus_iter->data;
1445 switch (pAppliedStatus->status) {
1458 /*clean up change log */
1459 if (pAppliedStatus->luid != NULL)
1460 itemIdList[count++] = strdup(pAppliedStatus->luid);
1462 if (sync_type == ALERT_TWO_WAY || sync_type == ALERT_TWO_WAY_BY_SERVER || sync_type == ALERT_ONE_WAY_FROM_CLIENT || sync_type == ALERT_ONE_WAY_FROM_CLIENT_BY_SERVER) {
1464 if (pAppliedStatus->change_type == CHANGE_DELETE) {
1465 da_err = sync_agent_delete_item(pAppliedStatus->luid, 0);
1466 if (da_err != SYNC_AGENT_DA_SUCCESS) {
1467 _DEBUG_ERROR("failed in da_delete_item_by_item_id_internal");
1468 err = SE_INTERNAL_DA_ERROR;
1481 sync_agent_da_item_changelog_s *get_changelog = NULL;
1482 da_err = sync_agent_create_changelog(&get_changelog);
1483 if (da_err != SYNC_AGENT_DA_SUCCESS) {
1484 _DEBUG_ERROR("failed in sync_agent_create_changelog !!");
1485 err = SE_INTERNAL_DA_ERROR;
1489 da_err = sync_agent_get_changelog(account_id, pAppliedStatus->luid, &get_changelog);
1490 if (da_err == SYNC_AGENT_DA_ERR_NO_DATA) {
1491 _DEBUG_VERBOSE("%s item does not exist in ChangeLog tbl", pAppliedStatus->luid);
1492 sync_agent_free_changelog(get_changelog);
1494 } else if (da_err != SYNC_AGENT_DA_SUCCESS) {
1495 _DEBUG_ERROR("failed in sync_agent_get_changelog !!");
1496 sync_agent_free_changelog(get_changelog);
1497 err = SE_INTERNAL_DA_ERROR;
1501 if (get_changelog->status != NULL) {
1502 if (strcmp(get_changelog->status, "SYNC_ERROR") == 0) {
1503 if (pAppliedStatus->luid != NULL)
1504 itemIdList[count++] = strdup(pAppliedStatus->luid);
1506 sync_agent_da_item_changelog_s *set_changelog = NULL;
1508 da_err = sync_agent_create_changelog(&set_changelog);
1509 if (da_err != SYNC_AGENT_DA_SUCCESS) {
1510 _DEBUG_ERROR("failed in sync_agent_create_changelog !!");
1511 sync_agent_free_changelog(get_changelog);
1512 err = SE_INTERNAL_DA_ERROR;
1516 set_changelog->item_id = strdup(pAppliedStatus->luid);
1517 set_changelog->status = strdup("SYNC_ERROR");
1518 set_changelog->access_name = strdup("SE");
1520 sync_agent_da_update_changelog_query_s update_ch_query;
1521 update_ch_query.option = SYNC_AGENT_DA_UPDATE_CHANGELOG_OPTION_SYNC_STATUS;
1522 update_ch_query.update_item = set_changelog;
1524 da_err = sync_agent_update_changelog(account_id, &update_ch_query);
1525 if (da_err != SYNC_AGENT_DA_SUCCESS) {
1526 _DEBUG_ERROR("failed in sync_agent_update_changelog !!");
1527 sync_agent_free_changelog(get_changelog);
1528 sync_agent_free_changelog(set_changelog);
1529 err = SE_INTERNAL_DA_ERROR;
1533 sync_agent_free_changelog(set_changelog);
1537 sync_agent_free_changelog(get_changelog);
1543 if (list_length >= 1) {
1544 _DEBUG_TRACE("before da_delete_item_changelog_by_item_id_list_internal");
1545 _DEBUG_TRACE("count = %d", count);
1547 sync_agent_da_delete_changelog_query_s query;
1548 query.option = SYNC_AGENT_DA_DELETE_CHANGELOG_OPTION_ITEM_ID_LIST;
1549 query.item_id_list = itemIdList;
1550 query.count = count;
1552 da_err = sync_agent_delete_changelog(account_id, &query);
1553 if (da_err != SYNC_AGENT_DA_SUCCESS) {
1554 _DEBUG_ERROR("failed in sync_agent_delete_changelog !!");
1555 err = SE_INTERNAL_DA_ERROR;
1562 /*free itemIdList */
1563 if (itemIdList != NULL) {
1564 for (i = 0; i < list_length; i++) {
1565 if (itemIdList[i] != NULL)
1566 free(itemIdList[i]);
1575 static se_error_type_e __execute_sync_status(int account_id, alert_type_e server_sync_type, sync_obj_s ** sync_obj, sync_return_obj_s ** sync_return_obj)
1579 se_error_type_e err = SE_INTERNAL_OK;
1582 bool existEqualItem;
1584 sync_result_s *pClientSyncResult;
1585 GList *changedDatastore_iter = NULL;
1586 changed_datastore_s *pSyncChangedDatastore = NULL;
1587 for (changedDatastore_iter = (*sync_obj)->changed_datastore; changedDatastore_iter != NULL;) {
1588 pSyncChangedDatastore = (changed_datastore_s *) changedDatastore_iter->data;
1589 _DEBUG_VERBOSE("pChangedDatastore = %p", pSyncChangedDatastore);
1591 int datastoreContentType = 0;
1592 for (content_type = 0; content_type < TYPE_SERVICE_COUNT; content_type++) {
1593 if (datastoreinfo_per_content_type[content_type] != NULL) {
1594 if (strcmp(pSyncChangedDatastore->source, datastoreinfo_per_content_type[content_type]->source) == 0) {
1595 datastoreContentType = content_type;
1601 GList *changedItem_iter = NULL;
1602 changed_item_s *changedItem = NULL;
1603 for (changedItem_iter = pSyncChangedDatastore->sent_item; changedItem_iter != NULL;) {
1604 changedItem = changedItem_iter->data;
1606 existEqualItem = false;
1607 GList *appliedStatus_iter = NULL;
1608 applied_status_s *pAppliedStatus = NULL;
1609 for (appliedStatus_iter = (*sync_return_obj)->status; appliedStatus_iter != NULL; appliedStatus_iter = g_list_next(appliedStatus_iter)) {
1610 pAppliedStatus = appliedStatus_iter->data;
1612 if (strcmp(pAppliedStatus->luid, changedItem->luid) == 0) {
1613 add_receive_count(datastoreinfo_per_content_type[datastoreContentType]->client_sync_result, 1);
1615 if (pAppliedStatus->status >= 200 && pAppliedStatus->status <= 210) {
1616 switch (changedItem->change_type) {
1618 add_add_count(datastoreinfo_per_content_type[datastoreContentType]->client_sync_result, 1);
1620 case CHANGE_REPLACE:
1621 add_replace_count(datastoreinfo_per_content_type[datastoreContentType]->client_sync_result, 1);
1624 add_delete_count(datastoreinfo_per_content_type[datastoreContentType]->client_sync_result, 1);
1630 /* if status is not success count it is failed */
1633 (*sync_return_obj)->status = g_list_remove((*sync_return_obj)->status, pAppliedStatus);
1634 free_applied_status(pAppliedStatus);
1635 pAppliedStatus = NULL;
1637 changedItem_iter = g_list_next(changedItem_iter);
1639 pSyncChangedDatastore->sent_item = g_list_remove(pSyncChangedDatastore->sent_item, changedItem);
1640 free_changed_item(changedItem);
1643 existEqualItem = true;
1647 if (existEqualItem == false)
1648 changedItem_iter = g_list_next(changedItem_iter);
1651 changedDatastore_iter = g_list_next(changedDatastore_iter);
1654 pClientSyncResult = datastoreinfo_per_content_type[datastoreContentType]->client_sync_result;
1655 if (pClientSyncResult->number_of_change == pClientSyncResult->received_count) {
1658 if (datastoreinfo_per_content_type[datastoreContentType]->client_sync_result != NULL)
1659 datastoreinfo_per_content_type[datastoreContentType]->client_sync_result->session_result = SYNC_SESSION_SUCCEEDED;
1661 /*remove datastore from list and
1662 free current ChangedDatastore it does not need anymore because all item in datastore has been sent and receive status */
1663 (*sync_obj)->changed_datastore = g_list_remove((*sync_obj)->changed_datastore, pSyncChangedDatastore);
1664 free_changed_datastore(pSyncChangedDatastore);
1665 pSyncChangedDatastore = NULL;
1668 operation_type_e operation_type;
1669 if (datastoreinfo_per_content_type[datastoreContentType]->client_sync_result->number_of_change == 0)
1670 operation_type = OPERATION_NOOP;
1672 operation_type = OPERATION_ADD;
1673 err = __process_update(account_id, server_sync_type, SYNC_PROGRESS_SUCCESS, operation_type, datastoreContentType, false, needToSave, datastoreinfo_per_content_type[datastoreContentType]->client_sync_result);
1674 if (err != SE_INTERNAL_OK) {
1675 _DEBUG_ERROR("failed in process_update");
1686 static se_error_type_e __execute_sync_change(int account_id, alert_type_e server_sync_type, sync_obj_s ** sync_obj, sync_return_obj_s ** sync_return_obj)
1690 se_error_type_e err = SE_INTERNAL_OK;
1691 sync_agent_da_return_e da_err = SYNC_AGENT_DA_SUCCESS;
1692 sync_agent_da_service_item_s *service_item = NULL;
1693 sync_agent_da_item_s *fw_item = NULL;
1695 GList *f_id_list = NULL;
1696 sync_result_s *tempServerSyncResult = NULL;
1698 /* process command that from server sended to client(sync, add, replace etc...) */
1699 changed_datastore_s *pSyncReturnChangedDatastore = NULL;
1700 sending_status_s *sendingStatus = NULL;
1702 for (iter = (*sync_return_obj)->changed_datastore; iter != NULL;) {
1703 pSyncReturnChangedDatastore = (changed_datastore_s *) iter->data;
1705 int datastoreContentType = 0;
1706 for (content_type = 0; content_type < TYPE_SERVICE_COUNT; content_type++) {
1707 if (datastoreinfo_per_content_type[content_type] != NULL) {
1708 if (strcmp(pSyncReturnChangedDatastore->target, datastoreinfo_per_content_type[content_type]->source) == 0) {
1709 datastoreContentType = content_type;
1715 /*noti to UI numberOfChanges from server */
1716 if (pSyncReturnChangedDatastore->has_number_of_changes) {
1717 set_number_of_change(datastoreinfo_per_content_type[datastoreContentType]->server_sync_result, pSyncReturnChangedDatastore->number_of_changes);
1719 operation_type_e operation_type;
1720 if (datastoreinfo_per_content_type[datastoreContentType]->server_sync_result->number_of_change == 0)
1721 operation_type = OPERATION_NOOP;
1723 operation_type = OPERATION_ADD;
1724 err = __process_update(account_id, server_sync_type, SYNC_PROGRESS_SUCCESS, operation_type, datastoreContentType, true, false, datastoreinfo_per_content_type[datastoreContentType]->server_sync_result);
1725 if (err != SE_INTERNAL_OK) {
1726 _DEBUG_ERROR("failed in process_update");
1731 sendingStatus = create_sending_status(pSyncReturnChangedDatastore->target, pSyncReturnChangedDatastore->source);
1732 if (sendingStatus == NULL) {
1733 err = SE_INTERNAL_NO_MEMORY;
1734 _DEBUG_ERROR("failed to alloc memory");
1739 char *folderId = NULL;
1740 sync_agent_da_get_folder_id_list_query_s query;
1741 query.option = SYNC_AGENT_DA_GET_FOLDER_ID_OPTION_FOLDER_TYPE_ID;
1742 query.account_id = account_id;
1743 query.item_type_id = datastoreinfo_per_content_type[datastoreContentType]->datastore_id;
1744 query.folder_type_id = datastoreinfo_per_content_type[datastoreContentType]->folder_type_id;
1746 da_err = sync_agent_get_folder_id_list(&query, &f_id_list);
1747 if (da_err != SYNC_AGENT_DA_SUCCESS) {
1748 _DEBUG_ERROR("sync_agent_get_folder_id_list_inferface() failed !!");
1752 if (g_list_length(f_id_list) > 0) {
1753 GList *iter = g_list_nth(f_id_list, 0);
1754 folderId = (char *)(iter->data);
1756 _DEBUG_ERROR("failed to get folderId");
1757 err = SE_INTERNAL_DA_ERROR;
1761 int changeItemCount = g_list_length(pSyncReturnChangedDatastore->change_item);
1762 if (changeItemCount > 0) {
1763 /*begin transaction */
1764 _DEBUG_VERBOSE("sync_agent_begin_service with datastoreContentType = %d", datastoreContentType);
1765 // sync_agent_begin_service(datastoreinfo_per_content_type[datastoreContentType]->datastore_id);
1766 sync_agent_begin_transaction();
1768 /*back up syncresult structure for rollback case */
1769 tempServerSyncResult = dup_sync_result(datastoreinfo_per_content_type[datastoreContentType]->server_sync_result);
1772 bool needToSave = false;
1773 sync_result_s *pServerSyncResult = NULL;
1774 GList *changedIter = NULL;
1775 changed_item_s *changedItem = NULL;
1776 applied_status_s *appliedStatus = NULL;
1778 for (changedIter = pSyncReturnChangedDatastore->change_item; changedIter != NULL; changedIter = g_list_next(changedIter)) {
1779 changedItem = (changedIter->data);
1781 _DEBUG_VERBOSE("changedItem->changeType : %d", changedItem->change_type);
1782 _DEBUG_VERBOSE("changedItem->luid : %s", changedItem->luid);
1783 _DEBUG_VERBOSE("changedItem->content_type : %s", changedItem->content_type);
1784 _DEBUG_VERBOSE("changedItem->indexOfDatastore : %d", changedItem->index_of_datastore);
1785 _DEBUG_VERBOSE("changedItem->data : %s", changedItem->data);
1787 add_receive_count(datastoreinfo_per_content_type[datastoreContentType]->server_sync_result, 1);
1789 bool da_fail = false;
1790 command_result_e returnResult = COMMAND_RESULT_INIT;
1791 switch (changedItem->change_type) {
1794 /* add to service DB */
1795 if (changedItem->data != NULL) {
1798 da_err = sync_agent_create_service_item(&service_item);
1799 if ((da_err != SYNC_AGENT_DA_SUCCESS) || (service_item == NULL)) {
1800 _DEBUG_ERROR("failed in sync_agent_create_service_item() = %d", da_err);
1801 returnResult = ___convert_return_status(da_err);
1806 service_item->item_id = g_strdup(changedItem->luid);
1807 service_item->content_type = datastoreinfo_per_content_type[datastoreContentType]->datastore_id;
1808 service_item->account_id = account_id;
1809 service_item->folder_id = g_strdup(folderId);
1810 service_item->access_name = g_strdup("Engine");
1811 service_item->data = g_strdup(changedItem->data);
1812 sync_agent_begin_service(datastoreinfo_per_content_type[datastoreContentType]->datastore_id);
1814 da_err = sync_agent_add_service_item(service_item, &fw_id, false);
1816 sync_agent_end_service(datastoreinfo_per_content_type[datastoreContentType]->datastore_id, 1);
1818 _DEBUG_VERBOSE("da_err = %d", da_err);
1820 if (da_err == SYNC_AGENT_DA_SUCCESS) {
1822 bool success = true;
1823 char *service_id = sync_agent_get_service_item_id(fw_id);
1825 GList *folder_list = NULL;
1826 sync_agent_da_get_folder_list_query_s query;
1827 query.option = SYNC_AGENT_DA_GET_FOLDER_LIST_OPTION_SERVICE_ID_MAPPING;
1828 query.account_id = account_id;
1829 query.folder_id = folderId;
1830 da_err = sync_agent_get_folder_list(&query, &folder_list);
1831 if (da_err != SYNC_AGENT_DA_SUCCESS) {
1832 _DEBUG_ERROR("sync_agent_get_folder_list() failed !!");
1836 acc_cnt = g_list_length(folder_list);
1838 _DEBUG_VERBOSE("acc_cnt = %d", acc_cnt);
1840 char **fw_item_id_list = sync_agent_generate_item_luid(1, acc_cnt);
1841 char **id_list = (char **)calloc(acc_cnt, sizeof(char *));
1842 if (id_list == NULL) {
1843 _DEBUG_ERROR("CALLOC failed !!!");
1848 if (fw_item_id_list == NULL) {
1849 _DEBUG_ERROR("failed in sync_agent_generate_item_luid");
1850 da_err = SYNC_AGENT_DA_ERRORS;
1855 sync_agent_da_folder_s *iter_data;
1857 for (iter = folder_list; iter != NULL; iter = g_list_next(iter)) {
1859 iter_data = (sync_agent_da_folder_s *) (iter->data);
1861 da_err = sync_agent_create_item(&fw_item);
1862 if ((da_err != SYNC_AGENT_DA_SUCCESS) || (fw_item == NULL)) {
1863 _DEBUG_ERROR("failed in sync_agent_create_item() = %d", da_err);
1868 fw_item->item_id = g_strdup(fw_item_id_list[i]);
1869 fw_item->data_store_id = datastoreinfo_per_content_type[datastoreContentType]->datastore_id;
1870 fw_item->account_id = iter_data->account_id;
1871 fw_item->folder_id = g_strdup(iter_data->folder_id);
1872 fw_item->service_id = g_strdup(service_id);
1873 fw_item->access_name = g_strdup("DACI_ChangeLog");
1875 da_err = sync_agent_add_item(fw_item, &(id_list[i]), true);
1876 if (fw_item != NULL)
1877 sync_agent_free_item(fw_item);
1878 free(fw_item_id_list[i]);
1883 _DEBUG_VERBOSE("da_err = %d", da_err);
1885 if (da_err != SYNC_AGENT_DA_SUCCESS) {
1890 if (fw_item_id_list != NULL) {
1891 free(fw_item_id_list);
1893 if (id_list != NULL) {
1899 if (success == true) {
1900 returnResult = COMMAND_RESULT_ADDED;
1901 add_add_count(datastoreinfo_per_content_type[datastoreContentType]->server_sync_result, 1);
1903 /*this case just fail do rollback and goto fail */
1904 returnResult = ___convert_return_status(da_err);
1907 sync_agent_free_folder_list(folder_list);
1909 if (service_id != NULL)
1912 } else if (da_err == SYNC_AGENT_DA_ERR_NOT_SUPPORTED || da_err == SYNC_AGENT_DA_ERR_INVALID_CONTENT || da_err == SYNC_AGENT_DA_ERR_ALREADY_EXIST) {
1913 /*just return error to server */
1914 returnResult = ___convert_return_status(da_err);
1916 /*this case just fail do rollback and goto fail */
1917 returnResult = ___convert_return_status(da_err);
1921 if (service_item != NULL)
1922 sync_agent_free_service_item(service_item);
1927 returnResult = COMMAND_RESULT_COMMAND_FAIL;
1931 case CHANGE_REPLACE:
1933 if (changedItem->data != NULL) {
1934 /* update from service DB */
1935 da_err = sync_agent_create_service_item(&service_item);
1936 if (da_err != SYNC_AGENT_DA_SUCCESS || (service_item == NULL)) {
1937 _DEBUG_ERROR("failed in sync_agent_create_service_item() = %d", da_err);
1938 returnResult = ___convert_return_status(da_err);
1943 service_item->item_id = g_strdup(changedItem->luid);
1944 service_item->content_type = datastoreinfo_per_content_type[datastoreContentType]->datastore_id;
1945 service_item->account_id = account_id;
1946 service_item->folder_id = g_strdup(folderId);
1947 service_item->access_name = g_strdup("Engine");
1948 service_item->data = (const void *)g_strdup(changedItem->data);
1950 sync_agent_begin_service(datastoreinfo_per_content_type[datastoreContentType]->datastore_id);
1952 da_err = sync_agent_update_service_item(service_item, changedItem->luid, false);
1954 sync_agent_end_service(datastoreinfo_per_content_type[datastoreContentType]->datastore_id, 1);
1956 _DEBUG_VERBOSE("da_err = %d", da_err);
1957 if (da_err == SYNC_AGENT_DA_SUCCESS) {
1959 GList *item_list = NULL;
1960 sync_agent_da_get_item_list_query_s query;
1961 query.option = SYNC_AGENT_DA_GET_ITEM_LIST_OPTION_SERVICE_ID_MAPPING;
1962 query.item_id = changedItem->luid;
1964 da_err = sync_agent_get_item_list(account_id, &query, &item_list);
1965 if (da_err != SYNC_AGENT_DA_SUCCESS) {
1966 _DEBUG_ERROR("failed in sync_agent_get_item_list !!");
1969 bool success = true;
1971 sync_agent_da_item_s *iter_data;
1973 for (iter = item_list; iter != NULL; iter = g_list_next(iter)) {
1975 iter_data = (sync_agent_da_item_s *) (iter->data);
1977 da_err = sync_agent_update_item(iter_data->item_id, 1);
1978 if (da_err != SYNC_AGENT_DA_SUCCESS) {
1984 if (success == true) {
1985 returnResult = COMMAND_RESULT_OK;
1986 add_replace_count(datastoreinfo_per_content_type[datastoreContentType]->server_sync_result, 1);
1988 /*this case just fail do rollback and goto fail */
1989 returnResult = ___convert_return_status(da_err);
1993 sync_agent_free_item_list(item_list);
1994 } else if (da_err == SYNC_AGENT_DA_ERR_NOT_SUPPORTED || da_err == SYNC_AGENT_DA_ERR_INVALID_CONTENT) {
1995 /*just return error to server */
1996 returnResult = ___convert_return_status(da_err);
1998 /*this case just fail do rollback and goto fail */
1999 returnResult = ___convert_return_status(da_err);
2003 if (service_item != NULL)
2004 sync_agent_free_service_item(service_item);
2006 returnResult = COMMAND_RESULT_COMMAND_FAIL;
2012 /* delete from service DB */
2013 GList *item_list = NULL;
2014 sync_agent_da_get_item_list_query_s query;
2015 query.option = SYNC_AGENT_DA_GET_ITEM_LIST_OPTION_SERVICE_ID_MAPPING;
2016 query.item_id = changedItem->luid;
2018 da_err = sync_agent_get_item_list(account_id, &query, &item_list);
2019 if (da_err != SYNC_AGENT_DA_SUCCESS) {
2020 _DEBUG_ERROR("failed in sync_agent_get_item_list !!");
2023 sync_agent_begin_service(datastoreinfo_per_content_type[datastoreContentType]->datastore_id);
2025 da_err = sync_agent_delete_service_item(changedItem->luid, false);
2027 sync_agent_end_service(datastoreinfo_per_content_type[datastoreContentType]->datastore_id, 1);
2029 _DEBUG_VERBOSE("[sync_agent_delete_service_item] result : %d", da_err);
2030 if (da_err == SYNC_AGENT_DA_SUCCESS) {
2031 bool success = true;
2033 sync_agent_da_item_s *iter_data;
2035 for (iter = item_list; iter != NULL; iter = g_list_next(iter)) {
2037 iter_data = (sync_agent_da_item_s *) (iter->data);
2039 da_err = sync_agent_delete_item(iter_data->item_id, true);
2040 if (da_err != SYNC_AGENT_DA_SUCCESS) {
2046 if (success == true) {
2047 returnResult = COMMAND_RESULT_DELETE_WITHOUT_ARCHIVE;
2048 add_delete_count(datastoreinfo_per_content_type[datastoreContentType]->server_sync_result, 1);
2050 /*this case just fail do rollback and goto fail */
2051 returnResult = ___convert_return_status(da_err);
2054 } else if (da_err == SYNC_AGENT_DA_ERR_NO_DATA || da_err == SYNC_AGENT_DA_ERR_SUB_DATA_EXIST || da_err == SYNC_AGENT_DA_ERR_INVALID_CONTENT) {
2055 /*just return error to server */
2056 returnResult = ___convert_return_status(da_err);
2058 /*this case just fail do rollback and goto fail */
2059 returnResult = ___convert_return_status(da_err);
2062 sync_agent_free_item_list(item_list);
2069 if (da_fail == true) {
2070 /*replace syncresult when rollback happened */
2071 if (datastoreinfo_per_content_type[datastoreContentType]->server_sync_result != NULL)
2072 free(datastoreinfo_per_content_type[datastoreContentType]->server_sync_result);
2074 datastoreinfo_per_content_type[datastoreContentType]->server_sync_result = tempServerSyncResult;
2075 tempServerSyncResult = NULL;
2077 _DEBUG_VERBOSE("Transaction_Rollback");
2078 _DEBUG_VERBOSE("sync_agent_end_service with datastoreContentType = %d", datastoreContentType);
2079 // sync_agent_end_service(datastoreinfo_per_content_type[datastoreContentType]->datastore_id, 0);
2080 sync_agent_end_transaction(SYNC_AGENT_DA_TRANSACTION_ROLLBACK);
2082 err = SE_INTERNAL_DA_ERROR;
2083 _DEBUG_ERROR("failed in DA");
2087 appliedStatus = create_applied_status(changedItem->luid, changedItem->change_type, returnResult);
2088 if (appliedStatus == NULL) {
2089 _DEBUG_VERBOSE("Transaction_Rollback");
2090 _DEBUG_VERBOSE("sync_agent_end_service with datastoreContentType = %d", datastoreContentType);
2091 // sync_agent_end_service(datastoreinfo_per_content_type[datastoreContentType]->datastore_id, 0);
2092 sync_agent_end_transaction(SYNC_AGENT_DA_TRANSACTION_ROLLBACK);
2094 err = SE_INTERNAL_NO_MEMORY;
2095 _DEBUG_ERROR("failed to alloc memory");
2098 add_sending_status_applied_status(sendingStatus, appliedStatus);
2101 if (changeItemCount > 0) {
2102 /*end transaction */
2103 _DEBUG_VERBOSE("sync_agent_end_service with datastoreContentType = %d", datastoreContentType);
2104 // sync_agent_end_service(datastoreinfo_per_content_type[datastoreContentType]->datastore_id, 1);
2105 sync_agent_end_transaction(SYNC_AGENT_DA_TRANSACTION_COMMIT);
2108 /* Do not need to send update event to ui when changeItemCount less than 0 */
2109 /* send update event about add, delete, replace count during this sync command */
2110 if (changeItemCount >= 0) {
2112 pServerSyncResult = datastoreinfo_per_content_type[datastoreContentType]->server_sync_result;
2113 if (pServerSyncResult->number_of_change == pServerSyncResult->received_count) {
2116 if (datastoreinfo_per_content_type[datastoreContentType]->server_sync_result != NULL)
2117 datastoreinfo_per_content_type[datastoreContentType]->server_sync_result->session_result = SYNC_SESSION_SUCCEEDED;
2120 operation_type_e operation_type;
2121 if (datastoreinfo_per_content_type[datastoreContentType]->server_sync_result->number_of_change == 0)
2122 operation_type = OPERATION_NOOP;
2124 operation_type = OPERATION_ADD;
2125 err = __process_update(account_id, server_sync_type, SYNC_PROGRESS_SUCCESS, operation_type, datastoreContentType, true, needToSave, datastoreinfo_per_content_type[datastoreContentType]->server_sync_result);
2126 if (err != SE_INTERNAL_OK) {
2127 _DEBUG_ERROR("failed in process_update");
2132 (*sync_obj)->sending_status = g_list_append((*sync_obj)->sending_status, sendingStatus);
2133 sendingStatus = NULL;
2135 iter = g_list_next(iter);
2137 (*sync_return_obj)->changed_datastore = g_list_remove((*sync_return_obj)->changed_datastore, pSyncReturnChangedDatastore);
2138 free_changed_datastore(pSyncReturnChangedDatastore);
2139 pSyncReturnChangedDatastore = NULL;
2141 if (tempServerSyncResult != NULL) {
2142 free(tempServerSyncResult);
2143 tempServerSyncResult = NULL;
2148 sync_agent_free_folder_id_list(f_id_list);
2150 if (tempServerSyncResult != NULL)
2151 free(tempServerSyncResult);
2154 free_sending_status(sendingStatus);
2160 static se_error_type_e _update_sync_result(int account_id)
2164 se_error_type_e err = SE_INTERNAL_OK;
2165 sync_agent_da_return_e da_err = SYNC_AGENT_DA_SUCCESS;
2168 sync_agent_da_last_anchor_s next_anchor_info;
2169 for (content_type = 0; content_type < TYPE_SERVICE_COUNT; content_type++) {
2170 if (datastoreinfo_per_content_type[content_type] != NULL) {
2171 if (!datastoreinfo_per_content_type[content_type]->client_sync_type)
2174 next_anchor_info.access_name = "Engine";
2175 next_anchor_info.account_id = account_id;
2176 next_anchor_info.data_store_id = datastoreinfo_per_content_type[content_type]->datastore_id;
2177 next_anchor_info.last_anchor_client = datastoreinfo_per_content_type[content_type]->next_anchor_client;
2178 next_anchor_info.last_anchor_server = datastoreinfo_per_content_type[content_type]->next_anchor_server;
2180 da_err = sync_agent_update_last_anchor(&next_anchor_info);
2181 if (da_err != SYNC_AGENT_DA_SUCCESS)
2182 _DEBUG_ERROR("failed in da_set_last_anchor_internal");
2184 da_err = sync_agent_set_service_change_point(account_id, datastoreinfo_per_content_type[content_type]->datastore_id);
2185 if (da_err != SYNC_AGENT_DA_SUCCESS)
2186 _DEBUG_ERROR("failed in sync_agent_set_service_change_point");
2194 static command_result_e ___convert_return_status(sync_agent_da_return_e da_err)
2198 command_result_e returnResult = COMMAND_RESULT_INIT;
2200 case 1: /*SYNC_AGENT_DA_SUCCESS */
2201 /*never comes this case
2203 case -813: /*SYNC_AGENT_DA_ERR_ALREADY_EXIST */
2204 returnResult = COMMAND_RESULT_ALREADY_EXIST; /*[A] Already exists exception */
2206 case -815: /*SYNC_AGENT_DA_ERR_MEMORY_FULL *//* oma : 420 (device full exception) */
2207 returnResult = COMMAND_RESULT_DEVICE_FULL; /*[AR] Device full exception */
2209 case -820: /*SYNC_AGENT_DA_ERR_NOT_SUPPORTED *//* oma : 415 (unsupported media type or format exception) */
2210 returnResult = COMMAND_RESULT_UNSUPPORTED_TYPE; /*[AR] Unsupported media type or format exception */
2212 case -819: /*SYNC_AGENT_DA_ERR_NO_DATA *//* kies : not found, oma : 211 (item not deleted exception) */
2213 returnResult = COMMAND_RESULT_NOT_EXIST; /*[D] Item not deleted exception */
2215 case -800: /*SYNC_AGENT_DA_ERRORS */
2216 case -801: /*SYNC_AGENT_DA_NOT_FOUND_PLUG_IN */
2217 case -802: /*SYNC_AGENT_DA_ERR_OPEN_FAILED */
2218 case -803: /*SYNC_AGENT_DA_ERR_CLOSE_FAILED */
2219 case -804: /*SYNC_AGENT_DA_ERR_TRANSACTION_FAILED */
2220 case -805: /*SYNC_AGENT_DA_ERR_CREATE_TABLE_FAILED */
2221 case -806: /*SYNC_AGENT_DA_ERR_DROP_TABLE_FAILED */
2222 case -807: /*SYNC_AGENT_DA_ERR_QUERY_FAILED */
2223 case -808: /*SYNC_AGENT_DA_ERR_NOT_OPENED */
2224 case -809: /*SYNC_AGENT_DA_ERR_ACCOUNT_FULL */
2225 case -810: /*SYNC_AGENT_DA_ERR_DELETE_LAST_ACCOUNT */
2226 case -811: /*SYNC_AGENT_DA_ERR_PRIMARY_KEY_NOT_UNIQUE */
2227 case -812: /*SYNC_AGENT_DA_ERR_DB_HANDLER_MGR */
2228 case -814: /*SYNC_AGENT_DA_ERR_INVALID_CONTENT */
2229 case -816: /*SYNC_AGENT_DA_ERR_SUB_DATA_EXIST *//* oma : 427 (item not empty) */
2230 case -817: /*SYNC_AGENT_DA_ERR_LOCKED *//* kies : cannot access */
2231 case -818: /*SYNC_AGENT_DA_ERR_MORE_DATA */
2232 case -821: /*SYNC_AGENT_DA_ERR_NOT_EXECUTE *//* kies : ex) sms send command, no network service */
2234 returnResult = COMMAND_RESULT_COMMAND_FAIL; /*[ARD] Command failed exception */
2239 return returnResult;
2242 static char *__convert_cttype_str(int datastore_id)
2246 char *cttype = NULL;
2247 /*FIXME : check type and version (contact : vCard2.1 , calendar : vCalendar 1.0 , memo : plain text) of real item data.. */
2248 switch (datastore_id) {
2249 case TYPE_CONTACT: /*contact (vCard2.1) */
2250 cttype = ELEMENT_TEXT_VCARD;
2252 case TYPE_CALENDAR: /*calendar (vCalendar2.0) */
2253 cttype = ELEMENT_TEXT_VCAL;
2255 case TYPE_MEMO: /*note(Memo) */
2256 cttype = ELEMENT_TEXT_PLAIN;
2259 cttype = ELEMENT_TEXT_XCALLLOG;
2269 static int ___convert_sync_type_value(char *sync_type_str)
2273 int sync_type_value;
2275 if (strcmp(sync_type_str, DEFINE_ALERT_SLOW_SYNC_STR) == 0)
2276 sync_type_value = ALERT_SLOW_SYNC;
2277 else if (strcmp(sync_type_str, DEFINE_ALERT_TWO_WAY_STR) == 0)
2278 sync_type_value = ALERT_TWO_WAY;
2279 else if (strcmp(sync_type_str, DEFINE_ALERT_ONE_WAY_FROM_CLIENT_STR) == 0)
2280 sync_type_value = ALERT_ONE_WAY_FROM_CLIENT;
2281 else if (strcmp(sync_type_str, DEFINE_ALERT_ONE_WAY_FROM_SERVER_STR) == 0)
2282 sync_type_value = ALERT_ONE_WAY_FROM_SERVER;
2283 else if (strcmp(sync_type_str, DEFINE_ALERT_REFRESH_FROM_SERVER_STR) == 0)
2284 sync_type_value = ALERT_REFRESH_FROM_SERVER;
2285 else if (strcmp(sync_type_str, DEFINE_ALERT_REFRESH_FROM_CLIENT_STR) == 0)
2286 sync_type_value = ALERT_REFRESH_FROM_CLIENT;
2288 sync_type_value = ALERT_UNKNOWN;
2291 return sync_type_value;
2294 static char *__convert_sync_type_str(alert_type_e sync_type)
2298 char *sync_Type = NULL;
2300 switch (sync_type) {
2302 sync_Type = DEFINE_ALERT_TWO_WAY_STR;
2304 case ALERT_SLOW_SYNC:
2305 sync_Type = DEFINE_ALERT_SLOW_SYNC_STR;
2307 case ALERT_ONE_WAY_FROM_CLIENT:
2308 sync_Type = DEFINE_ALERT_ONE_WAY_FROM_CLIENT_STR;
2310 case ALERT_REFRESH_FROM_CLIENT:
2311 sync_Type = DEFINE_ALERT_REFRESH_FROM_CLIENT_STR;
2313 case ALERT_ONE_WAY_FROM_SERVER:
2314 sync_Type = DEFINE_ALERT_ONE_WAY_FROM_SERVER_STR;
2316 case ALERT_REFRESH_FROM_SERVER:
2317 sync_Type = DEFINE_ALERT_REFRESH_FROM_SERVER_STR;
2320 sync_Type = DEFINE_ALERT_UNKNOWN_STR;
2328 static char *___convert_sync_progress_status_str(sync_progress_status_e progress_status)
2332 char *progress = NULL;
2334 switch (progress_status) {
2335 case SYNC_PROGRESS_NONE:
2336 progress = DEFINE_PROGRESS_NONE;
2338 case SYNC_PROGRESS_SUCCESS:
2339 progress = DEFINE_PROGRESS_SUCCESS;
2341 case SYNC_FAILED_DB:
2342 progress = DEFINE_FAILED_DB;
2344 case SYNC_FAILED_DB_FORBIDDEN:
2345 progress = DEFINE_FAILED_DB_FORBIDDEN;
2347 case SYNC_FAILED_DB_ITEM:
2348 progress = DEFINE_FAILED_DB_ITEM;
2350 case SYNC_FAILED_DB_CONFIG:
2351 progress = DEFINE_FAILED_DB_CONFIG;
2353 case SYNC_FAILED_DB_DEVICEFULL:
2354 progress = DEFINE_FAILED_DB_DEVICEFULL;
2364 static char *___convert_operation_type_str(operation_type_e operation_type)
2368 char *operation = NULL;
2370 switch (operation_type) {
2371 case OPERATION_NOOP:
2372 operation = DEFINE_NOOP;
2375 operation = DEFINE_ADD;
2377 case OPERATION_DELETE:
2378 operation = DEFINE_DELETE;
2380 case OPERATION_MOVE:
2381 operation = DEFINE_MOVE;
2383 case OPERATION_COPY:
2384 operation = DEFINE_COPY;
2386 case OPERATION_REPLACE:
2387 operation = DEFINE_REPLACE;
2397 static char *_convert_sync_progress_str(sync_progress_e process)
2401 char *syncProcess = NULL;
2405 syncProcess = DEFINE_SYNC_PROGRESS_NONE;
2408 syncProcess = DEFINE_SYNC_INIT;
2410 case PROGRESS_CONNECTING:
2411 syncProcess = DEFINE_SYNC_CONNECTING;
2413 case PROGRESS_AUTHENTICATED:
2414 syncProcess = DEFINE_SYNC_AUTHENTICATED;
2417 syncProcess = DEFINE_SYNC_DONE;
2419 case PROGRESS_ERROR:
2420 syncProcess = DEFINE_SYNC_ERROR;
2430 static char *_convert_sync_error_str(sync_error_e error)
2434 char *syncError = NULL;
2438 syncError = DEFINE_ERROR_NONE;
2440 case ERROR_CONNECTION:
2441 syncError = DEFINE_ERROR_CONNECTION;
2444 syncError = DEFINE_ERROR_SYNCHDR;
2446 case ERROR_INTERNAL:
2447 syncError = DEFINE_ERROR_INTERNAL;
2449 case ERROR_SUSPENDED:
2450 syncError = DEFINE_ERROR_SUSPENDED;
2453 syncError = DEFINE_ERROR_DB;
2456 syncError = DEFINE_ERROR_ABORT;
2459 syncError = DEFINE_ERROR_SERVER;
2461 case ERROR_MEMORY_FULL:
2462 syncError = DEFINE_ERROR_MEMORY_FULL;
2464 case ERROR_AUTHENTICATE:
2465 syncError = DEFINE_ERROR_AUTHENTICATE;
2467 case ERROR_AUTOCONFIG_NOT_SUPPORT_BY_SERVER:
2468 syncError = DEFINE_ERROR_AUTOCONFIG_NOT_SUPPORT_BY_SERVER;
2470 case ERROR_LOW_BATTERY:
2471 syncError = DEFINE_ERROR_LOW_BATTERY;
2481 static se_error_type_e _check_low_battery()
2485 se_error_type_e err = SE_INTERNAL_OK;
2486 sync_agent_dev_return_e dci_err = SYNC_AGENT_DEV_RETURN_SUCCESS;
2487 char *battery_level = NULL;
2488 int int_battery_level = 0;
2490 dci_err = sync_agent_get_devinfo(1, "Battery", &battery_level);
2491 if (dci_err != SYNC_AGENT_DEV_RETURN_SUCCESS) {
2492 _DEBUG_ERROR("failed in sync_agent_get_devinfo = %d", dci_err);
2493 err = SE_INTERNAL_DA_ERROR;
2497 _DEBUG_TRACE("battery_level =%s", battery_level);
2499 if (battery_level != NULL) {
2500 int_battery_level = atoi(battery_level);
2502 if (int_battery_level < LOW_BATTERY_LEVEL) {
2503 _DEBUG_ERROR("LOW Battery = %d", int_battery_level);
2504 err = SE_INTERNAL_LOW_BATTERY;
2511 if (battery_level != NULL)
2512 free(battery_level);
2518 static se_error_type_e _open_services()
2522 se_error_type_e err = SE_INTERNAL_OK;
2523 sync_agent_da_return_e da_err = SYNC_AGENT_DA_SUCCESS;
2526 for (content_type = 0; content_type < TYPE_SERVICE_COUNT; content_type++) {
2527 if (datastoreinfo_per_content_type[content_type] != NULL) {
2528 if (!datastoreinfo_per_content_type[content_type]->client_sync_type)
2531 da_err = sync_agent_open_service(content_type);
2532 if (da_err != SYNC_AGENT_DA_SUCCESS) {
2533 _DEBUG_ERROR("sync_agent_open_service(%d) is failed", content_type);
2534 err = SE_INTERNAL_DA_ERROR;
2544 static se_error_type_e _close_services()
2548 se_error_type_e err = SE_INTERNAL_OK;
2549 sync_agent_da_return_e da_err = SYNC_AGENT_DA_SUCCESS;
2552 for (content_type = 0; content_type < TYPE_SERVICE_COUNT; content_type++) {
2553 if (datastoreinfo_per_content_type[content_type] != NULL) {
2554 if (!datastoreinfo_per_content_type[content_type]->client_sync_type)
2557 da_err = sync_agent_close_service(content_type);
2558 if (da_err != SYNC_AGENT_DA_SUCCESS)
2559 _DEBUG_ERROR("sync_agent_close_service(%d) is failed", content_type);
2567 bool synchronize(int account_id, char *sync_mode, san_package_s * san_package)
2571 _DEBUG_INFO("accountID = %d", account_id);
2572 _DEBUG_INFO("sync_mode = %s", sync_mode);
2574 /*FIXME remove msg file */
2575 int ret_val = remove(OMA_DS_MSG_PATH);
2577 _DEBUG_ERROR("failed in synchronize - remove()");
2580 /*FIXME time check */
2584 se_error_type_e err = SE_INTERNAL_OK;
2585 sync_agent_dev_return_e dci_result = SYNC_AGENT_DEV_RETURN_SUCCESS;
2586 sync_agent_da_return_e da_err = SYNC_AGENT_DA_SUCCESS;
2588 common_error_type_e errorCode = COMMON_OK;
2589 sync_progress_e process = PROGRESS_NONE;
2590 sync_error_e error = ERROR_NONE;
2592 alert_type_e client_sync_type = ALERT_UNKNOWN;
2593 alert_type_e server_sync_type = ALERT_UNKNOWN;
2594 int only_from_client = 0;
2596 int session_time = sync_agent_convert_seconds_to_utc(time(NULL)); /*lastSessionTime for resultView; */
2597 _DEBUG_INFO("session_time = %d", session_time);
2599 pre_sync_return_obj_s *pre_sync_return_obj = NULL;
2600 sync_obj_s *sync_obj = NULL;
2601 sync_return_obj_s *sync_return_obj = NULL;
2603 bool cancel_flag = false;
2605 char *session_id = NULL;
2607 char *access_name = NULL;
2608 bool server_flag = false;
2611 unsigned int msg_size;
2612 char *recvMsg = NULL;
2613 unsigned int recvMsg_size;
2615 sync_agent_acc_error_e acc_err = SYNC_AGENT_ACC_SUCCESS;
2616 sync_agent_fw_account_s *fw_account = NULL;
2618 dci_result = sync_agent_execute_dev_function(DEFINE_PLATFORM, "pm_lock", 3, LCD_OFF, STAY_CUR_STATE, 0);
2619 if (dci_result != SYNC_AGENT_DEV_RETURN_SUCCESS) {
2620 _DEBUG_ERROR("failed in sync_agent_execute_dev_function lock = %d", dci_result);
2623 /* low battery check */
2624 err = _check_low_battery();
2625 if (err != SE_INTERNAL_OK) {
2626 _DEBUG_ERROR("check_low_battery = %d", err);
2630 da_err = sync_agent_open_agent();
2631 if (da_err != SYNC_AGENT_DA_SUCCESS) {
2632 _DEBUG_ERROR("failed in sync_agent_open_agent = %d", da_err);
2633 err = SE_INTERNAL_DA_ERROR;
2637 /* prepare for sending pre sync */
2638 err = _prepare_pre_sync(account_id, sync_mode, san_package, &client_sync_type);
2639 if (err != SE_INTERNAL_OK) {
2640 _DEBUG_ERROR("failed in __prepare_pre_sync = %d", err);
2644 /* check cancel flag */
2645 cancel_flag = sync_agent_check_cancel_flag();
2647 err = SE_INTERNAL_CANCEL;
2648 _DEBUG_INFO("cancle flag is on");
2652 pre_sync_return_obj = (pre_sync_return_obj_s *) calloc(1, sizeof(pre_sync_return_obj_s));
2653 if (pre_sync_return_obj == NULL) {
2654 _DEBUG_ERROR("failed to alloc memory");
2655 err = SE_INTERNAL_NO_MEMORY;
2659 acc_err = sync_agent_create_fw_account(&fw_account);
2660 if (acc_err != SYNC_AGENT_ACC_SUCCESS) {
2661 _DEBUG_ERROR("failed in sync_agent_create_fw_account");
2662 err = SE_INTERNAL_NO_MEMORY;
2666 acc_err = sync_agent_get_fw_account(account_id, &fw_account);
2667 if (acc_err != SYNC_AGENT_ACC_SUCCESS) {
2668 _DEBUG_ERROR("failed in sync_agent_update_fw_account");
2669 err = SE_INTERNAL_ERROR;
2673 access_name = strdup(fw_account->access_name);
2674 if (strcmp(access_name, "DIVE") == 0) {
2679 if (strcmp(sync_mode, DEFINE_SYNC_MODE_PUSH) == 0) {
2680 _DEBUG_INFO("sessionID = %d", san_package->session_id);
2681 session_id = g_strdup_printf("%u", san_package->session_id); /*freed in pre_sync */
2682 errorCode = pre_sync(TRANSPORT_TYPE, account_id, session_id, server_flag, (void **)&pre_sync_return_obj);
2684 errorCode = pre_sync(TRANSPORT_TYPE, account_id, NULL, server_flag, (void **)&pre_sync_return_obj);
2686 /* check cancel flag */
2687 cancel_flag = sync_agent_check_cancel_flag();
2689 err = SE_INTERNAL_CANCEL;
2690 _DEBUG_INFO("cancle flag is on");
2694 _DEBUG_INFO("pre_sync errorCode =[%d]", errorCode);
2695 if (errorCode != COMMON_OK) {
2696 err = SE_INTERNAL_SA_ERROR;
2700 /*execute pre_sync return */
2701 server_sync_type = client_sync_type;
2702 err = _execute_pre_sync(account_id, session_time, pre_sync_return_obj, &server_sync_type);
2703 if (err != SE_INTERNAL_OK) {
2704 _DEBUG_ERROR("failed in __process_pre_sync = %d", err);
2708 if (server_sync_type == ALERT_REFRESH_FROM_CLIENT || server_sync_type == ALERT_ONE_WAY_FROM_CLIENT)
2709 only_from_client = 1;
2711 _DEBUG_INFO("client_sync_type = %d", client_sync_type);
2712 _DEBUG_INFO("server_sync_type = %d", server_sync_type);
2713 _DEBUG_INFO("only_from_client = %d", only_from_client);
2715 _session_process(account_id, server_sync_type, PROGRESS_AUTHENTICATED, ERROR_NONE);
2717 /* check cancel flag */
2718 cancel_flag = sync_agent_check_cancel_flag();
2720 err = SE_INTERNAL_CANCEL;
2721 _DEBUG_INFO("cancle flag is on");
2725 err = _open_services();
2726 if (err != SE_INTERNAL_OK) {
2727 _DEBUG_ERROR("failed in __prepare_pre_sync = %d", err);
2732 _DEBUG_INFO("pre_sync end pkg3 start");
2733 sync_obj = (sync_obj_s *) calloc(1, sizeof(sync_obj_s));
2734 if (sync_obj == NULL) {
2735 _DEBUG_ERROR("failed to alloc memory");
2736 err = SE_INTERNAL_NO_MEMORY;
2740 sync_return_obj = (sync_return_obj_s *) calloc(1, sizeof(sync_return_obj_s));
2741 if (sync_return_obj == NULL) {
2742 _DEBUG_ERROR("failed to alloc memory");
2743 err = SE_INTERNAL_NO_MEMORY;
2747 err = _assemble_changed_datastores(account_id, server_sync_type, &sync_obj);
2748 if (err != SE_INTERNAL_OK) {
2749 _DEBUG_ERROR("failed in __assemble_changeddatastore = %d", err);
2753 /* check cancel flag */
2754 cancel_flag = sync_agent_check_cancel_flag();
2756 err = SE_INTERNAL_CANCEL;
2757 _DEBUG_INFO("cancle flag is on");
2764 errorCode = generate_msg((void **)&sync_obj, server_flag, &msg, &msg_size);
2765 if (errorCode != COMMON_OK) {
2766 _DEBUG_ERROR("Failed in generate_Msg = %d", errorCode);
2767 err = SE_INTERNAL_SA_ERROR;
2771 errorCode = exchange_msg(TRANSPORT_TYPE, msg, msg_size, &recvMsg, &recvMsg_size);
2772 if (errorCode != COMMON_OK) {
2773 _DEBUG_ERROR("Failed in exchange_Msg = %d", errorCode);
2774 if (errorCode == COMMON_CANCEL) {
2775 bool cancel_status = check_cancel_status();
2776 if (cancel_status) {
2777 err = SE_INTERNAL_SUSPEND;
2778 _DEBUG_INFO("cancle flag is on");
2782 err = SE_INTERNAL_SA_ERROR;
2787 /* check cancel flag */
2788 cancel_flag = sync_agent_check_cancel_flag();
2790 bool cancel_status = check_cancel_status();
2791 if (cancel_status) {
2792 err = SE_INTERNAL_SUSPEND;
2793 _DEBUG_INFO("cancle flag is on");
2798 errorCode = process_recv_msg(recvMsg, recvMsg_size, only_from_client, (void **)&sync_return_obj, &isFinish);
2799 if (errorCode != COMMON_OK) {
2800 _DEBUG_ERROR("Failed in processRecv_Msg = %d", errorCode);
2801 err = SE_INTERNAL_SA_ERROR;
2805 err = _execute_sync(account_id, client_sync_type, server_sync_type, &sync_obj, &sync_return_obj);
2806 if (err != SE_INTERNAL_OK) {
2807 _DEBUG_ERROR("failed in __execute_sync = %d", err);
2811 free_changed_datastores(sync_return_obj->changed_datastore);
2812 sync_return_obj->changed_datastore = NULL;
2814 free_applied_statuses(sync_return_obj->status);
2815 sync_return_obj->status = NULL;
2822 if (recvMsg != NULL) {
2828 err = _update_sync_result(account_id);
2829 if (err != SE_INTERNAL_OK) {
2830 _DEBUG_ERROR("failed in __update_anchor = %d", err);
2834 _write_sync_data(account_id, client_sync_type, SYNC_SESSION_SUCCEEDED, session_time, only_from_client);
2840 errorCode = suspend_sync(TRANSPORT_TYPE, account_id, server_flag);
2841 if (errorCode != COMMON_OK) {
2842 _DEBUG_ERROR("Failed in suspend_sync = %d", errorCode);
2843 err = SE_INTERNAL_SA_ERROR;
2844 if (errorCode == COMMON_SUSPEND_FAIL)
2845 _off_resume_flag(account_id);
2852 /*clean up for SA unusual end sync process case */
2855 for (content_type = 0; content_type < TYPE_SERVICE_COUNT; content_type++) {
2856 if (datastoreinfo_per_content_type[content_type] != NULL) {
2857 if (datastoreinfo_per_content_type[content_type]->client_sync_type) {
2858 if (datastoreinfo_per_content_type[content_type]->client_sync_result != NULL)
2859 datastoreinfo_per_content_type[content_type]->client_sync_result->session_result = SYNC_SESSION_STOPPED;
2861 if (datastoreinfo_per_content_type[content_type]->server_sync_result != NULL)
2862 datastoreinfo_per_content_type[content_type]->server_sync_result->session_result = SYNC_SESSION_STOPPED;
2868 _write_sync_data(account_id, client_sync_type, SYNC_SESSION_STOPPED, session_time, only_from_client);
2874 /*clean up for SA unusual end sync process case */
2877 for (content_type = 0; content_type < TYPE_SERVICE_COUNT; content_type++) {
2878 if (datastoreinfo_per_content_type[content_type] != NULL) {
2879 if (datastoreinfo_per_content_type[content_type]->client_sync_type) {
2880 if (datastoreinfo_per_content_type[content_type]->client_sync_result != NULL)
2881 datastoreinfo_per_content_type[content_type]->client_sync_result->session_result = SYNC_SESSION_FAILED;
2883 if (datastoreinfo_per_content_type[content_type]->server_sync_result != NULL)
2884 datastoreinfo_per_content_type[content_type]->server_sync_result->session_result = SYNC_SESSION_FAILED;
2889 _write_sync_data(account_id, client_sync_type, SYNC_SESSION_FAILED, session_time, only_from_client);
2893 if (err == SE_INTERNAL_SA_ERROR)
2894 convert_common_errorcode(errorCode, &process, &error);
2896 convert_engine_errorcode(err, &process, &error);
2898 /* off when session finish normal or cancel case(not suspend) */
2899 if (err != SE_INTERNAL_SUSPEND)
2900 _off_resume_flag(account_id);
2902 _off_synchronising_account(account_id);
2904 _session_process(account_id, server_sync_type, process, error);
2905 _DEBUG_INFO("server_sync_type = %d", server_sync_type);
2906 _DEBUG_INFO("process = %d", process);
2907 _DEBUG_INFO("error = %d", error);
2909 sync_agent_close_agent();
2912 dci_result = sync_agent_execute_dev_function(DEFINE_PLATFORM, "pm_unlock", 2, LCD_OFF, RESET_TIMER);
2913 if (dci_result != SYNC_AGENT_DEV_RETURN_SUCCESS) {
2914 _DEBUG_ERROR("failed in sync_agent_execute_dev_function unlock");
2917 sync_agent_free_fw_account(fw_account);
2919 if (access_name != NULL) {
2929 if (recvMsg != NULL) {
2934 if (pre_sync_return_obj != NULL) {
2935 free_pre_sync_return_obj(pre_sync_return_obj);
2936 pre_sync_return_obj = NULL;
2939 if (sync_obj != NULL) {
2940 free_sync_obj(sync_obj);
2944 if (sync_return_obj != NULL) {
2945 free_sync_return_obj(sync_return_obj);
2946 sync_return_obj = NULL;
2949 for (content_type = 0; content_type < TYPE_SERVICE_COUNT; content_type++) {
2950 if (datastoreinfo_per_content_type[content_type] != NULL) {
2951 free_datastore(datastoreinfo_per_content_type[content_type]);
2952 datastoreinfo_per_content_type[content_type] = NULL;
2956 /*FIXME*/ dt = myclock() - t;
2957 _DEBUG_ERROR("\n=============TOTAL---- % d . % d sec\n", dt / 1000, dt % 1000);
2960 if (err != SE_INTERNAL_OK)
2966 void convert_common_errorcode(common_error_type_e errorCode, sync_progress_e * process, sync_error_e * error)
2970 switch (errorCode) {
2972 case COMMON_SUSPEND_FAIL:
2973 case COMMON_OK: /*ERROR_INTERNAL_OK */
2975 /* Do nothing : Error None
2976 * pre_sync : PROGRESS_AUTHENTICATED
2977 * sync end : PROGRESS_DONE
2978 process = PROGRESS_AUTHENTICATED;
2979 process = PROGRESS_DONE;
2981 *process = PROGRESS_DONE;
2982 *error = ERROR_NONE;
2985 case COMMON_MISCONFIGURATION: /*ERROR_INTERNAL_MISCONFIGURATION : need configure infomation (account_id, id, pw, server_url...) */
2987 *process = PROGRESS_ERROR;
2988 *error = ERROR_SYNCHDR;
2991 case COMMON_AUTHENTICATION_ERROR: /*ERROR_AUTH_REQUIRED, ERROR_AUTH_REJECTED */
2993 *process = PROGRESS_ERROR;
2994 *error = ERROR_AUTHENTICATE;
2997 case COMMON_NOT_FOUND: /*ERROR_NOT_FOUND (ERROR_INTERNAL ??) */
2999 *process = PROGRESS_ERROR;
3000 *error = ERROR_SYNCHDR;
3003 case COMMON_NO_MEMORY: /*ERROR_INTERNAL_NO_MEMORY */
3005 *process = PROGRESS_ERROR;
3006 *error = ERROR_MEMORY_FULL;
3009 case COMMON_INTERNAL_ERROR: /*ERROR_INTERNAL_NOT_DEFINED || ERROR_INTERNAL_BINDER_ERROR */
3011 *process = PROGRESS_ERROR;
3012 *error = ERROR_INTERNAL;
3015 case COMMON_SERVER_ERROR: /*ERROR_GENERIC || ERROR_SERVER_FAILURE */
3017 *process = PROGRESS_ERROR;
3018 *error = ERROR_SERVER;
3021 case COMMON_CONNECTION_ERROR: /*ERROR_INTERNAL_CONNECTION_ERROR */
3023 *process = PROGRESS_ERROR;
3024 *error = ERROR_CONNECTION;
3027 case COMMON_AUTOCONFIG_NOT_SUPPORT_BY_SERVER: /*ERROR_INTERNAL_AUTOCONFIG_NOT_SUPPORT_BY_SERVER */
3029 *process = PROGRESS_ERROR;
3030 *error = ERROR_AUTOCONFIG_NOT_SUPPORT_BY_SERVER;
3035 *process = PROGRESS_ERROR;
3036 *error = ERROR_INTERNAL; /*?? unknown error */
3044 void convert_engine_errorcode(se_error_type_e err, sync_progress_e * process, sync_error_e * error)
3049 case SE_INTERNAL_SUSPEND:
3050 case SE_INTERNAL_CANCEL:
3051 case SE_INTERNAL_OK:
3052 *process = PROGRESS_DONE;
3053 *error = ERROR_NONE;
3056 case SE_INTERNAL_SA_ERROR:
3057 case SE_INTERNAL_SCHEDULER_ERROR:
3058 case SE_INTERNAL_ENGINE_CONTROLER_ERROR:
3059 case SE_INTERNAL_EVENT_ERROR:
3060 case SE_INTERNAL_NOT_DEFINED:
3061 case SE_INTERNAL_ERROR:
3062 *process = PROGRESS_ERROR;
3063 *error = ERROR_INTERNAL;
3065 case SE_INTERNAL_NO_MEMORY:
3066 *process = PROGRESS_ERROR;
3067 *error = ERROR_MEMORY_FULL;
3069 case SE_INTERNAL_DA_ERROR:
3070 *process = PROGRESS_ERROR;
3073 case SE_INTERNAL_MISCONFIGURATION:
3074 *process = PROGRESS_ERROR;
3075 *error = ERROR_SYNCHDR;
3077 case SE_INTERNAL_LOW_BATTERY:
3078 *process = PROGRESS_ERROR;
3079 *error = ERROR_LOW_BATTERY;
3086 se_error_type_e session_process(char *profileDirName, alert_type_e server_sync_type, sync_progress_e process, sync_error_e error)
3090 _DEBUG_INFO("profileDirName = %s", profileDirName);
3091 _DEBUG_INFO("process = %d", process);
3092 _DEBUG_INFO("error = %d", error);
3094 se_error_type_e err = SE_INTERNAL_OK;
3096 char *sync_type = NULL;
3097 char *syncProcess = NULL;
3098 char *syncError = NULL;
3100 sync_type = __convert_sync_type_str(server_sync_type);
3102 syncProcess = _convert_sync_progress_str(process);
3104 syncError = _convert_sync_error_str(error);
3106 if (sync_type == NULL || syncProcess == NULL || syncError == NULL) {
3107 err = SE_INTERNAL_NOT_DEFINED;
3111 err = send_noti_session_process(profileDirName, sync_type, syncProcess, syncError);
3112 if (err != SE_INTERNAL_OK) {
3113 _DEBUG_ERROR("failed in send_noti_session_process");
3124 se_error_type_e reset_synchronizing_profiles()
3128 se_error_type_e err = SE_INTERNAL_OK;
3130 sync_agent_acc_error_e acc_err = SYNC_AGENT_ACC_SUCCESS;
3131 sync_agent_fw_account_s *fw_account = NULL;
3132 GList *account_info_list = NULL;
3135 sync_agent_da_return_e da_err = sync_agent_open_agent();
3136 if (da_err != SYNC_AGENT_DA_SUCCESS) {
3137 _DEBUG_ERROR("failed in sync_agent_open_agent");
3138 err = SE_INTERNAL_DA_ERROR;
3142 sync_agent_fw_account_query_s query;
3143 query.query = ACCOUNT_QUERY_BY_NONE;
3145 acc_err = sync_agent_query_fw_account(&query, &account_info_list);
3146 if (acc_err != SYNC_AGENT_ACC_SUCCESS) {
3147 _DEBUG_ERROR("sync_agent_query_fw_account is failed");
3151 for (iter = account_info_list; iter != NULL; iter = g_list_next(iter)) {
3152 fw_account = (sync_agent_fw_account_s *) iter->data;
3154 _DEBUG_INFO("account = %d", fw_account->account_id);
3155 _off_synchronising_account(fw_account->account_id);
3157 _DEBUG_INFO("construct_itemTbl From service start");
3160 for (content_type = 0; content_type < TYPE_SERVICE_COUNT - 1; content_type++) {
3162 da_err = sync_agent_open_service(content_type);
3163 if (da_err != SYNC_AGENT_DA_SUCCESS) {
3164 _DEBUG_ERROR("sync_agent_open_service(%d) is failed ", content_type);
3168 _DEBUG_INFO("sync_agent_construct_item_tbl_from_service(%d, %d);", fw_account->account_id, content_type);
3169 sync_agent_construct_item_tbl_from_service(fw_account->account_id, content_type);
3171 da_err = sync_agent_close_service(content_type);
3172 if (da_err != SYNC_AGENT_DA_SUCCESS) {
3173 _DEBUG_ERROR("sync_agent_close_service(%d) is failed ", content_type);
3178 _DEBUG_INFO("construct_itemTbl From service end");
3183 sync_agent_close_agent();
3185 sync_agent_free_fw_account_list(account_info_list);
3192 bool refresh_from_service_all(int account_id)
3196 se_error_type_e err = SE_INTERNAL_OK;
3198 sync_agent_da_return_e da_err = sync_agent_open_agent();
3199 if (da_err != SYNC_AGENT_DA_SUCCESS) {
3200 err = SE_INTERNAL_DA_ERROR;
3205 for (content_type = 0; content_type < TYPE_SERVICE_COUNT - 1; content_type++) {
3207 da_err = sync_agent_open_service(content_type);
3208 if (da_err != SYNC_AGENT_DA_SUCCESS) {
3209 _DEBUG_ERROR("sync_agent_open_service(%d) is failed ", content_type);
3213 _DEBUG_INFO("sync_agent_refresh_item_tbl_from_service(%d, %d);", account_id, content_type);
3214 sync_agent_refresh_item_tbl_from_service(account_id, content_type);
3216 da_err = sync_agent_close_service(content_type);
3217 if (da_err != SYNC_AGENT_DA_SUCCESS) {
3218 _DEBUG_ERROR("sync_agent_close_service(%d) is failed ", content_type);
3225 sync_agent_close_agent();
3229 if (err != SE_INTERNAL_OK)
3235 se_error_type_e cancel_sync_request()
3238 se_error_type_e err = SE_INTERNAL_OK;
3240 cancel_connection_sync_request(TRANSPORT_TYPE);