--- /dev/null
+/*\r
+* email-service\r
+*\r
+* Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.\r
+*\r
+* Contact: Kyuho Jo <kyuho.jo@samsung.com>, Sunghyun Kwon <sh0701.kwon@samsung.com>\r
+*\r
+* Licensed under the Apache License, Version 2.0 (the "License");\r
+* you may not use this file except in compliance with the License.\r
+* You may obtain a copy of the License at\r
+*\r
+* http://www.apache.org/licenses/LICENSE-2.0\r
+*\r
+* Unless required by applicable law or agreed to in writing, software\r
+* distributed under the License is distributed on an "AS IS" BASIS,\r
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+* See the License for the specific language governing permissions and\r
+* limitations under the License.\r
+*\r
+*/\r
+\r
+/*\r
+ * email-core-signal.c\r
+ *\r
+ * Created on: 2012. 11. 22.\r
+ * Author: kyuho.jo@samsung.com\r
+ */\r
+#include <dbus/dbus.h>\r
+\r
+#include "email-core-signal.h"\r
+#include "email-core-utils.h"\r
+#include "email-internal-types.h"\r
+#include "email-debug-log.h"\r
+\r
+#define EMAIL_STORAGE_CHANGE_NOTI "User.Email.StorageChange"\r
+#define EMAIL_NETOWRK_CHANGE_NOTI "User.Email.NetworkStatus"\r
+#define EMAIL_RESPONSE_TO_API_NOTI "User.Email.ResponseToAPI"\r
+\r
+#define DBUS_SIGNAL_PATH_FOR_TASK_STATUS "/User/Email/TaskStatus"\r
+#define DBUS_SIGNAL_INTERFACE_FOR_TASK_STATUS "User.Email.TaskStatus"\r
+#define DBUS_SIGNAL_NAME_FOR_TASK_STATUS "email"\r
+\r
+static pthread_mutex_t _dbus_noti_lock = PTHREAD_MUTEX_INITIALIZER;\r
+\r
+typedef enum\r
+{\r
+ _NOTI_TYPE_STORAGE = 0,\r
+ _NOTI_TYPE_NETWORK = 1,\r
+ _NOTI_TYPE_RESPONSE_TO_API = 2,\r
+} enotitype_t;\r
+\r
+INTERNAL_FUNC int emcore_initialize_signal()\r
+{\r
+ return EMAIL_ERROR_NONE;\r
+}\r
+\r
+INTERNAL_FUNC int emcore_finalize_signal()\r
+{\r
+ DELETE_CRITICAL_SECTION(_dbus_noti_lock);\r
+ return EMAIL_ERROR_NONE;\r
+}\r
+\r
+static int emcore_send_signal(enotitype_t notiType, int subType, int data1, int data2, char *data3, int data4)\r
+{\r
+ EM_DEBUG_FUNC_BEGIN();\r
+ EM_PROFILE_BEGIN(profile_emcore_send_signal);\r
+\r
+ int ret = 0;\r
+ DBusConnection *connection;\r
+ DBusMessage *signal = NULL;\r
+ DBusError dbus_error;\r
+ dbus_uint32_t error;\r
+ const char *nullString = "";\r
+\r
+ ENTER_CRITICAL_SECTION(_dbus_noti_lock);\r
+\r
+ dbus_error_init (&dbus_error);\r
+ connection = dbus_bus_get(DBUS_BUS_SYSTEM, &dbus_error);\r
+\r
+ if (connection == NULL) {\r
+ EM_DEBUG_LOG("dbus_bus_get is failed");\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ if (notiType == _NOTI_TYPE_STORAGE) {\r
+ signal = dbus_message_new_signal("/User/Email/StorageChange", EMAIL_STORAGE_CHANGE_NOTI, "email");\r
+\r
+ if (signal == NULL) {\r
+ EM_DEBUG_EXCEPTION("dbus_message_new_signal is failed");\r
+ goto FINISH_OFF;\r
+ }\r
+ EM_DEBUG_LOG("/User/Email/StorageChange Signal is created by dbus_message_new_signal");\r
+\r
+ dbus_message_append_args(signal, DBUS_TYPE_INT32, &subType, DBUS_TYPE_INVALID);\r
+ dbus_message_append_args(signal, DBUS_TYPE_INT32, &data1, DBUS_TYPE_INVALID);\r
+ dbus_message_append_args(signal, DBUS_TYPE_INT32, &data2, DBUS_TYPE_INVALID);\r
+ if (data3 == NULL)\r
+ dbus_message_append_args(signal, DBUS_TYPE_STRING, &nullString, DBUS_TYPE_INVALID);\r
+ else\r
+ dbus_message_append_args(signal, DBUS_TYPE_STRING, &data3, DBUS_TYPE_INVALID);\r
+ dbus_message_append_args(signal, DBUS_TYPE_INT32, &data4, DBUS_TYPE_INVALID);\r
+ }\r
+ else if (notiType == _NOTI_TYPE_NETWORK) {\r
+ signal = dbus_message_new_signal("/User/Email/NetworkStatus", EMAIL_NETOWRK_CHANGE_NOTI, "email");\r
+\r
+ if (signal == NULL) {\r
+ EM_DEBUG_EXCEPTION("dbus_message_new_signal is failed");\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ EM_DEBUG_LOG("/User/Email/NetworkStatus Signal is created by dbus_message_new_signal");\r
+\r
+ dbus_message_append_args(signal, DBUS_TYPE_INT32, &subType, DBUS_TYPE_INVALID);\r
+ dbus_message_append_args(signal, DBUS_TYPE_INT32, &data1, DBUS_TYPE_INVALID);\r
+ if (data3 == NULL)\r
+ dbus_message_append_args(signal, DBUS_TYPE_STRING, &nullString, DBUS_TYPE_INVALID);\r
+ else\r
+ dbus_message_append_args(signal, DBUS_TYPE_STRING, &data3, DBUS_TYPE_INVALID);\r
+ dbus_message_append_args(signal, DBUS_TYPE_INT32, &data2, DBUS_TYPE_INVALID);\r
+ dbus_message_append_args(signal, DBUS_TYPE_INT32, &data4, DBUS_TYPE_INVALID);\r
+ }\r
+ else if (notiType == _NOTI_TYPE_RESPONSE_TO_API) {\r
+ signal = dbus_message_new_signal("/User/Email/ResponseToAPI", EMAIL_RESPONSE_TO_API_NOTI, "email");\r
+\r
+ if (signal == NULL) {\r
+ EM_DEBUG_EXCEPTION("dbus_message_new_signal is failed");\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ EM_DEBUG_LOG("/User/Email/ResponseToAPI Signal is created by dbus_message_new_signal");\r
+\r
+ dbus_message_append_args(signal, DBUS_TYPE_INT32, &subType, DBUS_TYPE_INVALID);\r
+ dbus_message_append_args(signal, DBUS_TYPE_INT32, &data1, DBUS_TYPE_INVALID);\r
+ dbus_message_append_args(signal, DBUS_TYPE_INT32, &data2, DBUS_TYPE_INVALID);\r
+ }\r
+ else {\r
+ EM_DEBUG_EXCEPTION("Wrong notification type [%d]", notiType);\r
+ error = EMAIL_ERROR_IPC_CRASH;\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ if (!dbus_connection_send(connection, signal, &error)) {\r
+ EM_DEBUG_LOG("dbus_connection_send is failed [%d]", error);\r
+ }\r
+ else {\r
+ EM_DEBUG_LOG("dbus_connection_send is successful");\r
+ ret = 1;\r
+ }\r
+\r
+/* EM_DEBUG_LOG("Before dbus_connection_flush"); */\r
+/* dbus_connection_flush(connection); */\r
+/* EM_DEBUG_LOG("After dbus_connection_flush"); */\r
+\r
+ ret = true;\r
+FINISH_OFF:\r
+ if (signal)\r
+ dbus_message_unref(signal);\r
+\r
+ LEAVE_CRITICAL_SECTION(_dbus_noti_lock);\r
+ EM_PROFILE_END(profile_emcore_send_signal);\r
+ EM_DEBUG_FUNC_END("ret [%d]", ret);\r
+ return ret;\r
+}\r
+\r
+\r
+INTERNAL_FUNC int emcore_notify_storage_event(email_noti_on_storage_event transaction_type, int data1, int data2 , char *data3, int data4)\r
+{\r
+ EM_DEBUG_FUNC_BEGIN("transaction_type[%d], data1[%d], data2[%d], data3[%p], data4[%d]", transaction_type, data1, data2, data3, data4);\r
+ return emcore_send_signal(_NOTI_TYPE_STORAGE, (int)transaction_type, data1, data2, data3, data4);\r
+}\r
+\r
+INTERNAL_FUNC int emcore_notify_network_event(email_noti_on_network_event status_type, int data1, char *data2, int data3, int data4)\r
+{\r
+ EM_DEBUG_FUNC_BEGIN("status_type[%d], data1[%d], data2[%p], data3[%d], data4[%d]", status_type, data1, data2, data3, data4);\r
+ return emcore_send_signal(_NOTI_TYPE_NETWORK, (int)status_type, data1, data3, data2, data4);\r
+}\r
+\r
+INTERNAL_FUNC int emcore_notify_response_to_api(email_event_type_t event_type, int data1, int data2)\r
+{\r
+ EM_DEBUG_FUNC_BEGIN("event_type[%d], data1[%d], data2[%p], data3[%d], data4[%d]", event_type, data1, data2);\r
+ return emcore_send_signal(_NOTI_TYPE_RESPONSE_TO_API, (int)event_type, data1, data2, NULL, 0);\r
+}\r
+\r
+INTERNAL_FUNC int emcore_send_task_status_signal(email_task_type_t input_task_type, int input_task_id, email_task_status_type_t input_task_status, int input_param_1, int input_param_2)\r
+{\r
+ EM_DEBUG_FUNC_BEGIN("input_task_type [%d] input_task_id [%d] input_task_status [%d] input_param_1 [%d] input_param_2 [%d]", input_task_type, input_task_id, input_task_status, input_param_1, input_param_2);\r
+\r
+ int err = EMAIL_ERROR_NONE;\r
+ DBusConnection *connection;\r
+ DBusMessage *signal = NULL;\r
+ DBusError dbus_error;\r
+ dbus_uint32_t error;\r
+\r
+ ENTER_CRITICAL_SECTION(_dbus_noti_lock);\r
+\r
+ dbus_error_init (&dbus_error);\r
+ connection = dbus_bus_get(DBUS_BUS_SYSTEM, &dbus_error);\r
+\r
+ if (connection == NULL) {\r
+ EM_DEBUG_LOG("dbus_bus_get is failed");\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ signal = dbus_message_new_signal(DBUS_SIGNAL_PATH_FOR_TASK_STATUS, DBUS_SIGNAL_INTERFACE_FOR_TASK_STATUS, DBUS_SIGNAL_NAME_FOR_TASK_STATUS);\r
+\r
+ if (signal == NULL) {\r
+ EM_DEBUG_EXCEPTION("dbus_message_new_signal is failed");\r
+ goto FINISH_OFF;\r
+ }\r
+ EM_DEBUG_LOG("Signal for task status has been created by dbus_message_new_signal");\r
+\r
+ dbus_message_append_args(signal, DBUS_TYPE_INT32, &input_task_type, DBUS_TYPE_INVALID);\r
+ dbus_message_append_args(signal, DBUS_TYPE_INT32, &input_task_id, DBUS_TYPE_INVALID);\r
+ dbus_message_append_args(signal, DBUS_TYPE_INT32, &input_task_status, DBUS_TYPE_INVALID);\r
+ dbus_message_append_args(signal, DBUS_TYPE_INT32, &input_param_1, DBUS_TYPE_INVALID);\r
+ dbus_message_append_args(signal, DBUS_TYPE_INT32, &input_param_2, DBUS_TYPE_INVALID);\r
+\r
+ if (!dbus_connection_send(connection, signal, &error)) {\r
+ EM_DEBUG_LOG("dbus_connection_send is failed [%d]", error);\r
+ }\r
+ else {\r
+ EM_DEBUG_LOG("dbus_connection_send is successful");\r
+ }\r
+\r
+/* EM_DEBUG_LOG("Before dbus_connection_flush"); */\r
+/* dbus_connection_flush(connection); */\r
+/* EM_DEBUG_LOG("After dbus_connection_flush"); */\r
+\r
+FINISH_OFF:\r
+ if (signal)\r
+ dbus_message_unref(signal);\r
+\r
+ LEAVE_CRITICAL_SECTION(_dbus_noti_lock);\r
+ EM_DEBUG_FUNC_END("err [%d]", err);\r
+ return err;\r
+}\r
--- /dev/null
+/*\r
+* email-service\r
+*\r
+* Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.\r
+*\r
+* Contact: Kyuho Jo <kyuho.jo@samsung.com>, Sunghyun Kwon <sh0701.kwon@samsung.com>\r
+*\r
+* Licensed under the Apache License, Version 2.0 (the "License");\r
+* you may not use this file except in compliance with the License.\r
+* You may obtain a copy of the License at\r
+*\r
+* http://www.apache.org/licenses/LICENSE-2.0\r
+*\r
+* Unless required by applicable law or agreed to in writing, software\r
+* distributed under the License is distributed on an "AS IS" BASIS,\r
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+* See the License for the specific language governing permissions and\r
+* limitations under the License.\r
+*\r
+*/\r
+\r
+/*\r
+ * email-core-task-manager.c\r
+ *\r
+ * Created on: 2012. 11. 1.\r
+ * Author: kyuho.jo@samsung.com\r
+ */\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+#include <pthread.h>\r
+#include <dbus/dbus.h>\r
+\r
+#include "email-internal-types.h"\r
+#include "email-utilities.h"\r
+#include "email-core-tasks.h"\r
+#include "email-core-task-manager.h"\r
+#include "email-core-signal.h"\r
+#include "email-core-global.h"\r
+#include "email-core-utils.h"\r
+#include "email-debug-log.h"\r
+\r
+/* TODO : implement a function for removing a task from task pool */\r
+/* TODO : after fetching a task from DB, update status of the task. */\r
+\r
+\r
+#define REGISTER_TASK_BINDER(TASK_NAME) emcore_register_task_handler(TASK_NAME, task_handler_##TASK_NAME, email_encode_task_parameter_##TASK_NAME, email_decode_task_parameter_##TASK_NAME)\r
+\r
+/*- variables - begin --------------------------------------------------------*/\r
+static pthread_cond_t _task_available_signal = PTHREAD_COND_INITIALIZER;\r
+static pthread_mutex_t _task_available_lock = PTHREAD_MUTEX_INITIALIZER;\r
+static pthread_mutex_t _task_manager_loop_lock = PTHREAD_MUTEX_INITIALIZER;\r
+static pthread_mutex_t _active_task_pool_lock = PTHREAD_MUTEX_INITIALIZER;\r
+\r
+static email_active_task_t _active_task_pool[MAX_ACTIVE_TASK];\r
+static thread_t _thread_task_manager_loop;\r
+static int _task_manager_loop_availability = 1;\r
+/*- variables - end ----------------------------------------------------------*/\r
+static int emcore_insert_task_to_active_task_pool(int input_task_slot_index, int input_task_id, email_task_type_t input_task_type, thread_t input_thread_id);\r
+static int emcore_remove_task_from_active_task_pool(int input_task_id);\r
+static int emcore_find_available_slot_in_active_task_pool(int *result_index);\r
+static int emcore_update_task_status_on_task_table(int input_task_id, email_task_status_type_t task_status);\r
+static int emcore_get_task_handler_reference(email_task_type_t input_task_type, email_task_handler_t **output_task_handler);\r
+\r
+/*- task handlers helpers - begin --------------------------------------------*/\r
+static int emcore_initialize_task_handler(email_task_t *input_task)\r
+{\r
+ EM_DEBUG_FUNC_BEGIN("input_task [%p]", input_task);\r
+ int err = EMAIL_ERROR_NONE;\r
+\r
+ if(input_task == NULL) {\r
+ EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");\r
+ err = EMAIL_ERROR_INVALID_PARAM;\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ /* insert task to _active_task_pool */\r
+ emcore_insert_task_to_active_task_pool(input_task->active_task_id\r
+ , input_task->task_id\r
+ , input_task->task_type\r
+ , THREAD_SELF());\r
+\r
+ /* send notification for 'task start */\r
+ if( (err = emcore_send_task_status_signal(input_task->task_type, input_task->task_id, EMAIL_TASK_STATUS_STARTED, EMAIL_ERROR_NONE, 0)) != EMAIL_ERROR_NONE) {\r
+ EM_DEBUG_EXCEPTION("emcore_send_task_status_signal failed [%d]", err);\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+FINISH_OFF:\r
+\r
+ EM_DEBUG_FUNC_END("err [%d]", err);\r
+ return err;\r
+}\r
+\r
+static int emcore_finalize_task_handler(email_task_t *input_task, int input_error_code)\r
+{\r
+ EM_DEBUG_FUNC_BEGIN("input_task [%p] input_error_code [%d]",input_task ,input_error_code);\r
+ int err = EMAIL_ERROR_NONE;\r
+ email_task_status_type_t task_status = EMAIL_TASK_STATUS_FINISHED;\r
+\r
+ if(input_task == NULL) {\r
+ EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");\r
+ err = EMAIL_ERROR_INVALID_PARAM;\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ if(input_error_code != EMAIL_ERROR_NONE) {\r
+ task_status = EMAIL_TASK_STATUS_FAILED;\r
+ }\r
+\r
+ /* remove task from task table */\r
+ if( (err = emcore_remove_task_from_task_table(input_task->task_id)) != EMAIL_ERROR_NONE) {\r
+ EM_DEBUG_EXCEPTION("emcore_remove_task_from_active_task_pool failed [%d]", err);\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ /* remove task id from active task id array */\r
+ if( (err = emcore_remove_task_from_active_task_pool(input_task->task_id)) != EMAIL_ERROR_NONE) {\r
+ EM_DEBUG_EXCEPTION("emcore_remove_task_from_active_task_pool failed [%d]", err);\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ /* send signal for 'task finish or failure */\r
+ if( (err = emcore_send_task_status_signal(input_task->task_type, input_task->task_id, task_status, input_error_code, 0)) != EMAIL_ERROR_NONE) {\r
+ EM_DEBUG_EXCEPTION("emcore_send_task_status_signal failed [%d]", err);\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ ENTER_CRITICAL_SECTION(_task_available_lock);\r
+ WAKE_CONDITION_VARIABLE(_task_available_signal);\r
+ LEAVE_CRITICAL_SECTION(_task_available_lock);\r
+\r
+FINISH_OFF:\r
+ EM_DEBUG_FUNC_END("err [%d]", err);\r
+ return err;\r
+}\r
+\r
+void* emcore_default_task_handler(void *intput_param)\r
+{\r
+ EM_DEBUG_FUNC_BEGIN("intput_param [%p]", intput_param);\r
+ int err = EMAIL_ERROR_NONE;\r
+ email_task_t *task = intput_param;\r
+ email_task_handler_t *task_handler = NULL;\r
+ void *decoded_task_parameter = NULL;\r
+\r
+ if((err = emcore_initialize_task_handler(task)) != EMAIL_ERROR_NONE) {\r
+ EM_DEBUG_EXCEPTION("emcore_initialize_task_handler failed. [%d]", err);\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ /* create a thread to do this task */\r
+ if((err = emcore_get_task_handler_reference(task->task_type, &task_handler)) != EMAIL_ERROR_NONE) {\r
+ EM_DEBUG_LOG("emcore_get_task_handler_reference returns [%d]", err);\r
+ }\r
+ else {\r
+ /* Decode parameter */\r
+ emcore_decode_task_parameter(task->task_type, task->task_parameter, task->task_parameter_length, &decoded_task_parameter);\r
+ task_handler->task_handler_function(decoded_task_parameter);\r
+ }\r
+\r
+FINISH_OFF:\r
+ emcore_finalize_task_handler(task, err);\r
+\r
+ if(task) {\r
+ EM_SAFE_FREE(task->task_parameter);\r
+ EM_SAFE_FREE(task);\r
+ }\r
+\r
+ EM_SAFE_FREE(decoded_task_parameter);\r
+\r
+ EM_DEBUG_FUNC_END("err [%d]", err);\r
+ return NULL;\r
+}\r
+/*- task handlers helpers - end --------------------------------------------*/\r
+\r
+int _task_handler_array_size;\r
+email_task_handler_t **_task_handler_array;\r
+\r
+static int emcore_register_task_handler(email_task_type_t input_task_type, void* (*input_task_handler)(void *), int (*input_task_parameter_encoder)(void*,char**,int*), int (*input_task_parameter_decoder)(char*,int,void**))\r
+{\r
+ EM_DEBUG_FUNC_BEGIN("input_task_type [%d] input_task_handler [%p] input_task_parameter_encoder [%p] input_task_parameter_decoder [%p]", input_task_type, input_task_handler, input_task_parameter_encoder, input_task_parameter_decoder);\r
+ int err = EMAIL_ERROR_NONE;\r
+ email_task_handler_t *new_task_handler = NULL;\r
+\r
+ new_task_handler = malloc(sizeof(email_task_handler_t));\r
+\r
+ if (new_task_handler == NULL) {\r
+ err = EMAIL_ERROR_OUT_OF_MEMORY;\r
+ EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY");\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ new_task_handler->task_type = input_task_type;\r
+ new_task_handler->task_handler_function = input_task_handler;\r
+ new_task_handler->task_parameter_encoder = input_task_parameter_encoder;\r
+ new_task_handler->task_parameter_decoder = input_task_parameter_decoder;\r
+\r
+ _task_handler_array_size++;\r
+\r
+ if (_task_handler_array) {\r
+ _task_handler_array = realloc(_task_handler_array, sizeof(email_task_handler_t*) * _task_handler_array_size);\r
+ }\r
+ else {\r
+ _task_handler_array = malloc(sizeof(email_task_handler_t*) * _task_handler_array_size);\r
+ }\r
+\r
+ if (_task_handler_array == NULL) {\r
+ err = EMAIL_ERROR_OUT_OF_MEMORY;\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ _task_handler_array[_task_handler_array_size - 1] = new_task_handler;\r
+\r
+FINISH_OFF:\r
+\r
+ EM_DEBUG_FUNC_END("err [%d]", err);\r
+ return err;\r
+}\r
+\r
+\r
+INTERNAL_FUNC int emcore_init_task_handler_array()\r
+{\r
+ EM_DEBUG_FUNC_BEGIN();\r
+\r
+ if (_task_handler_array == NULL) {\r
+\r
+ _task_handler_array = NULL;\r
+ _task_handler_array_size = 0;\r
+\r
+ REGISTER_TASK_BINDER(EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT);\r
+ }\r
+\r
+ EM_DEBUG_FUNC_END();\r
+ return EMAIL_ERROR_NONE;\r
+}\r
+\r
+INTERNAL_FUNC int emcore_free_task_handler_array()\r
+{\r
+ EM_DEBUG_FUNC_BEGIN();\r
+\r
+ int i = 0;\r
+\r
+ for(i = 0; i < _task_handler_array_size; i++) {\r
+ free(_task_handler_array[i]);\r
+ }\r
+\r
+ free(_task_handler_array);\r
+ _task_handler_array = NULL;\r
+ _task_handler_array_size = 0;\r
+\r
+ EM_DEBUG_FUNC_END();\r
+ return EMAIL_ERROR_NONE;\r
+}\r
+\r
+static int emcore_get_task_handler_reference(email_task_type_t input_task_type, email_task_handler_t **output_task_handler)\r
+{\r
+ EM_DEBUG_FUNC_BEGIN("input_task_type [%d] output_task_handler [%p]", input_task_type, output_task_handler);\r
+ int i = 0;\r
+ int err = EMAIL_ERROR_NONE;\r
+\r
+ if (output_task_handler == NULL) {\r
+ EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");\r
+ err = EMAIL_ERROR_INVALID_PARAM;\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ *output_task_handler = NULL;\r
+ for (i = 0; i < _task_handler_array_size; i++) {\r
+ if (_task_handler_array[i]->task_type == input_task_type) {\r
+ *output_task_handler = _task_handler_array[i];\r
+ break;\r
+ }\r
+ }\r
+\r
+ if (*output_task_handler == NULL) {\r
+ EM_DEBUG_EXCEPTION("EMAIL_ERROR_TASK_BINDER_NOT_FOUND");\r
+ err = EMAIL_ERROR_TASK_BINDER_NOT_FOUND;\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+FINISH_OFF:\r
+ EM_DEBUG_FUNC_END("err [%d]", err);\r
+ return err;\r
+}\r
+\r
+INTERNAL_FUNC int emcore_encode_task_parameter(email_task_type_t input_task_type, void *input_task_parameter_struct, char **output_byte_stream, int *output_stream_size)\r
+{\r
+ EM_DEBUG_FUNC_BEGIN("input_task_type [%d] input_task_parameter_struct [%p] output_byte_stream [%p] output_stream_size [%p]", input_task_type, input_task_parameter_struct, output_byte_stream, output_stream_size);\r
+ int err = EMAIL_ERROR_NONE;\r
+ email_task_handler_t *task_handler = NULL;\r
+ int (*task_parameter_encoder)(void*, char**, int*);\r
+\r
+ if (input_task_parameter_struct == NULL || output_byte_stream == NULL || output_stream_size == NULL) {\r
+ EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");\r
+ err = EMAIL_ERROR_INVALID_PARAM;\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ if ((err = emcore_get_task_handler_reference(input_task_type, &task_handler)) != EMAIL_ERROR_NONE) {\r
+ EM_DEBUG_EXCEPTION("emcore_get_task_handler_reference failed [%d]", err);\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ task_parameter_encoder = task_handler->task_parameter_encoder;\r
+\r
+ if ((err = task_parameter_encoder(input_task_parameter_struct, output_byte_stream, output_stream_size)) != EMAIL_ERROR_NONE) {\r
+ EM_DEBUG_EXCEPTION("task_parameter_encoder failed [%d]", err);\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+FINISH_OFF:\r
+ EM_DEBUG_FUNC_END("err [%d]", err);\r
+ return err;\r
+}\r
+\r
+INTERNAL_FUNC int emcore_decode_task_parameter(email_task_type_t input_task_type, char *input_byte_stream, int input_stream_size, void **output_task_parameter_struct)\r
+{\r
+ EM_DEBUG_FUNC_BEGIN("input_task_type [%d] input_byte_stream [%p] input_stream_size [%d] output_task_parameter_struct [%p]", input_task_type, input_byte_stream, input_stream_size, output_task_parameter_struct);\r
+ int err = EMAIL_ERROR_NONE;\r
+ email_task_handler_t *task_handler = NULL;\r
+ int (*task_parameter_decoder)(char*, int, void**);\r
+\r
+ if (input_byte_stream == NULL || output_task_parameter_struct == NULL) {\r
+ EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");\r
+ err = EMAIL_ERROR_INVALID_PARAM;\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ if ((err = emcore_get_task_handler_reference(input_task_type, &task_handler)) != EMAIL_ERROR_NONE) {\r
+ EM_DEBUG_EXCEPTION("emcore_get_task_handler_reference failed [%d]", err);\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ task_parameter_decoder = task_handler->task_parameter_decoder;\r
+\r
+ if ((err = task_parameter_decoder(input_byte_stream, input_stream_size, output_task_parameter_struct)) != EMAIL_ERROR_NONE) {\r
+ EM_DEBUG_EXCEPTION("task_parameter_decoder failed [%d]", err);\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+FINISH_OFF:\r
+ EM_DEBUG_FUNC_END("err [%d]", err);\r
+ return err;\r
+}\r
+\r
+int emcore_fetch_task_from_task_pool(email_task_t **output_task)\r
+{\r
+ EM_DEBUG_FUNC_BEGIN("output_task [%p]", output_task);\r
+ int err = EMAIL_ERROR_NONE;\r
+ int output_task_count;\r
+\r
+ if((err = emstorage_query_task("WHERE task_status == 1", " ORDER BY date_time ASC, task_priority ASC LIMIT 0, 1", output_task, &output_task_count)) != EMAIL_ERROR_NONE) {\r
+ EM_DEBUG_EXCEPTION("emstorage_query_task failed [%d]", err);\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+FINISH_OFF:\r
+\r
+ EM_DEBUG_FUNC_END("err [%d]", err);\r
+ return err;\r
+}\r
+\r
+\r
+/*-Task manager loop - begin -------------------------------------------------------------*/\r
+\r
+\r
+static int emcore_insert_task_to_active_task_pool(int input_task_slot_index, int input_task_id, email_task_type_t input_task_type, thread_t input_thread_id)\r
+{\r
+ EM_DEBUG_FUNC_BEGIN("input_task_slot_index [%d] input_task_id [%d] input_task_type [%d] input_thread_id [%d]", input_task_slot_index, input_task_id, input_task_type, input_thread_id);\r
+ int err = EMAIL_ERROR_NONE;\r
+\r
+ ENTER_CRITICAL_SECTION(_active_task_pool_lock);\r
+ _active_task_pool[input_task_slot_index].task_id = input_task_id;\r
+ _active_task_pool[input_task_slot_index].task_type = input_task_type;\r
+ _active_task_pool[input_task_slot_index].thread_id = input_thread_id;\r
+ LEAVE_CRITICAL_SECTION(_active_task_pool_lock);\r
+\r
+ EM_DEBUG_LOG("_active_task_pool[%d].task_id [%d]", input_task_slot_index, _active_task_pool[input_task_slot_index].task_id);\r
+\r
+ EM_DEBUG_FUNC_END("err [%d]", err);\r
+ return err;\r
+}\r
+\r
+static int emcore_remove_task_from_active_task_pool(int input_task_id)\r
+{\r
+ EM_DEBUG_FUNC_BEGIN(" input_task_id [%d]", input_task_id);\r
+ int err = EMAIL_ERROR_NONE;\r
+ int i = 0;\r
+\r
+ ENTER_CRITICAL_SECTION(_active_task_pool_lock);\r
+ for(i = 0; i < MAX_ACTIVE_TASK; i++) {\r
+ if(_active_task_pool[i].task_id == input_task_id) {\r
+ _active_task_pool[i].task_id = 0;\r
+ _active_task_pool[i].task_type = 0;\r
+ _active_task_pool[i].thread_id = 0;\r
+ break;\r
+ }\r
+ }\r
+ LEAVE_CRITICAL_SECTION(_active_task_pool_lock);\r
+\r
+ if(i >= MAX_ACTIVE_TASK) {\r
+ EM_DEBUG_LOG("couldn't find proper task in active task pool [%d]", input_task_id);\r
+ err = EMAIL_ERROR_TASK_NOT_FOUND;\r
+ }\r
+\r
+ EM_DEBUG_FUNC_END("err [%d]", err);\r
+ return err;\r
+}\r
+\r
+INTERNAL_FUNC int emcore_get_active_task_by_thread_id(thread_t input_thread_id, email_active_task_t **output_active_task)\r
+{\r
+ EM_DEBUG_FUNC_BEGIN(" input_thread_id [%d] output_active_task [%p]", input_thread_id, output_active_task);\r
+ int err = EMAIL_ERROR_NONE;\r
+ int i = 0;\r
+\r
+ if (output_active_task == NULL) {\r
+ EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");\r
+ err = EMAIL_ERROR_INVALID_PARAM;\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ for(i = 0; i < MAX_ACTIVE_TASK; i++) {\r
+ if(_active_task_pool[i].thread_id == input_thread_id) {\r
+ *output_active_task = _active_task_pool + i;\r
+ break;\r
+ }\r
+ }\r
+\r
+ if(i >= MAX_ACTIVE_TASK) {\r
+ EM_DEBUG_LOG("couldn't find proper task in active task pool [%d]", input_thread_id);\r
+ err = EMAIL_ERROR_TASK_NOT_FOUND;\r
+ }\r
+\r
+FINISH_OFF:\r
+\r
+ EM_DEBUG_FUNC_END("err [%d]", err);\r
+ return err;\r
+}\r
+\r
+\r
+static int emcore_find_available_slot_in_active_task_pool(int *result_index)\r
+{\r
+ EM_DEBUG_FUNC_BEGIN("result_index [%p]", result_index);\r
+ int i = 0;\r
+ int err = EMAIL_ERROR_NONE;\r
+\r
+ if (result_index == NULL) {\r
+ EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");\r
+ err = EMAIL_ERROR_INVALID_PARAM;\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ ENTER_CRITICAL_SECTION(_active_task_pool_lock);\r
+ for(i = 0; i < MAX_ACTIVE_TASK; i++) {\r
+ if(_active_task_pool[i].task_id == 0) {\r
+ break;\r
+ }\r
+ }\r
+\r
+ if(i >= MAX_ACTIVE_TASK) {\r
+ EM_DEBUG_EXCEPTION("There is no available task slot");\r
+ err = EMAIL_NO_AVAILABLE_TASK_SLOT;\r
+ }\r
+ else {\r
+ _active_task_pool[i].task_id = -1;\r
+ *result_index = i;\r
+ }\r
+ LEAVE_CRITICAL_SECTION(_active_task_pool_lock);\r
+\r
+FINISH_OFF :\r
+ EM_DEBUG_FUNC_END("err [%d]", err);\r
+ return err;\r
+}\r
+\r
+void* thread_func_task_manager_loop(void *arg)\r
+{\r
+ EM_DEBUG_FUNC_BEGIN();\r
+ int err = EMAIL_ERROR_NONE;\r
+ int thread_error;\r
+ int available_slot_index = 0;\r
+ email_task_t *new_task = NULL;\r
+\r
+ /* while loop */\r
+ while (_task_manager_loop_availability) {\r
+ /* fetch task from DB */\r
+ if( ((err = emcore_fetch_task_from_task_pool(&new_task)) == EMAIL_ERROR_NONE) &&\r
+ ((err = emcore_find_available_slot_in_active_task_pool(&available_slot_index)) == EMAIL_ERROR_NONE) ) {\r
+\r
+ /* update task status as STARTED */\r
+ if((err = emcore_update_task_status_on_task_table(new_task->task_id, EMAIL_TASK_STATUS_STARTED)) != EMAIL_ERROR_NONE) {\r
+ EM_DEBUG_EXCEPTION("emcore_update_task_status_on_task_table failed [%d]", err);\r
+ }\r
+ new_task->active_task_id = available_slot_index;\r
+\r
+ /* create a thread to do this task */\r
+ THREAD_CREATE(new_task->thread_id, emcore_default_task_handler, new_task, thread_error);\r
+\r
+ /* new_task and task_parameter will be free in task handler. */\r
+ new_task = NULL;\r
+\r
+ }\r
+ else {\r
+ /* If there is no task or no available slot, sleep until someone wake you up. */\r
+ /* Wake up case 1 : by emcore_add_task_to_task_table */\r
+ /* Wake up case 2 : when some task terminated */\r
+ ENTER_CRITICAL_SECTION(_task_available_lock);\r
+ SLEEP_CONDITION_VARIABLE(_task_available_signal, _task_available_lock);\r
+ LEAVE_CRITICAL_SECTION(_task_available_lock);\r
+ EM_DEBUG_LOG("thread_func_task_manager_loop wake up!");\r
+ }\r
+ }\r
+\r
+ EM_DEBUG_FUNC_END();\r
+ return NULL;\r
+}\r
+\r
+INTERNAL_FUNC int emcore_start_task_manager_loop()\r
+{\r
+ EM_DEBUG_FUNC_BEGIN();\r
+ int thread_error;\r
+ int err = EMAIL_ERROR_NONE;\r
+\r
+ memset(&_active_task_pool, 0, sizeof(email_active_task_t) * MAX_ACTIVE_TASK);\r
+\r
+ if (_thread_task_manager_loop) {\r
+ EM_DEBUG_EXCEPTION("service thread is already running...");\r
+ err = EMAIL_ERROR_ALREADY_INITIALIZED;\r
+ goto FINISH_OFF;\r
+ }\r
+ emcore_init_task_handler_array();\r
+\r
+ _task_manager_loop_availability = 10;\r
+\r
+ /* create thread */\r
+ THREAD_CREATE(_thread_task_manager_loop, thread_func_task_manager_loop, NULL, thread_error);\r
+\r
+ if (thread_error != 0) {\r
+ EM_DEBUG_EXCEPTION("cannot create thread [%d]", thread_error);\r
+ err = EMAIL_ERROR_SYSTEM_FAILURE;\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+FINISH_OFF :\r
+ EM_DEBUG_FUNC_END("err [%d]", err);\r
+ return err;\r
+}\r
+\r
+INTERNAL_FUNC int emcore_stop_task_manager_loop()\r
+{\r
+ EM_DEBUG_FUNC_BEGIN();\r
+\r
+ int err = EMAIL_ERROR_NONE;\r
+\r
+ /* TODO : cancel tasks */\r
+\r
+ /* stop event_data loop */\r
+ _task_manager_loop_availability = 0;\r
+\r
+ ENTER_CRITICAL_SECTION(_task_manager_loop_lock);\r
+ WAKE_CONDITION_VARIABLE(_task_available_signal);\r
+ LEAVE_CRITICAL_SECTION(_task_manager_loop_lock);\r
+\r
+ /* wait for thread finished */\r
+ THREAD_JOIN(_thread_task_manager_loop);\r
+\r
+ _thread_task_manager_loop = 0;\r
+\r
+ DELETE_CRITICAL_SECTION(_task_manager_loop_lock);\r
+ DELETE_CONDITION_VARIABLE(_task_available_signal);\r
+\r
+ /* Free _active_task_pool */\r
+\r
+//FINISH_OFF :\r
+\r
+ EM_DEBUG_FUNC_END("err [%d]", err);\r
+ return err;\r
+}\r
+\r
+INTERNAL_FUNC int emcore_add_task_to_task_table(email_task_type_t input_task_type, email_task_priority_t input_task_priority, char *input_task_parameter, int input_task_parameter_length, int *output_task_id)\r
+{\r
+ EM_DEBUG_FUNC_BEGIN("input_task_type [%d] input_task_priority [%d] input_task_parameter [%p] input_task_parameter_length [%d] output_task_id [%p]", input_task_type, input_task_priority, input_task_parameter, input_task_parameter_length, output_task_id);\r
+ int err = EMAIL_ERROR_NONE;\r
+\r
+ if((err = emstorage_add_task(input_task_type, input_task_priority, input_task_parameter, input_task_parameter_length, false, output_task_id)) != EMAIL_ERROR_NONE) {\r
+ EM_DEBUG_EXCEPTION("emstorage_add_task failed [%d]", err);\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ ENTER_CRITICAL_SECTION(_task_available_lock);\r
+ WAKE_CONDITION_VARIABLE(_task_available_signal);\r
+ LEAVE_CRITICAL_SECTION(_task_available_lock);\r
+\r
+FINISH_OFF:\r
+ EM_DEBUG_FUNC_END("err [%d]", err);\r
+ return err;\r
+}\r
+\r
+INTERNAL_FUNC int emcore_remove_task_from_task_table(int input_task_id)\r
+{\r
+ EM_DEBUG_FUNC_BEGIN("input_task_id [%d]", input_task_id);\r
+ int err = EMAIL_ERROR_NONE;\r
+\r
+ if((err = emstorage_delete_task(input_task_id, true)) != EMAIL_ERROR_NONE) {\r
+ EM_DEBUG_EXCEPTION("emstorage_delete_task failed [%d]", err);\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+FINISH_OFF:\r
+ EM_DEBUG_FUNC_END("err [%d]", err);\r
+ return err;\r
+}\r
+\r
+static int emcore_update_task_status_on_task_table(int input_task_id, email_task_status_type_t task_status)\r
+{\r
+ EM_DEBUG_FUNC_BEGIN("input_task_id [%d] task_status [%d]", input_task_id, task_status);\r
+ int err = EMAIL_ERROR_NONE;\r
+\r
+ if((err = emstorage_update_task_status(input_task_id, task_status, true)) != EMAIL_ERROR_NONE) {\r
+ EM_DEBUG_EXCEPTION("emstorage_update_task_status failed [%d]", err);\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+FINISH_OFF:\r
+ EM_DEBUG_FUNC_END("err [%d]", err);\r
+ return err;\r
+}\r
+\r
+/*-Task manager loop - end-------------------------------------------------------------*/\r
--- /dev/null
+/*\r
+* email-service\r
+*\r
+* Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.\r
+*\r
+* Contact: Kyuho Jo <kyuho.jo@samsung.com>, Sunghyun Kwon <sh0701.kwon@samsung.com>\r
+*\r
+* Licensed under the Apache License, Version 2.0 (the "License");\r
+* you may not use this file except in compliance with the License.\r
+* You may obtain a copy of the License at\r
+*\r
+* http://www.apache.org/licenses/LICENSE-2.0\r
+*\r
+* Unless required by applicable law or agreed to in writing, software\r
+* distributed under the License is distributed on an "AS IS" BASIS,\r
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+* See the License for the specific language governing permissions and\r
+* limitations under the License.\r
+*\r
+*/\r
+/*\r
+ * email-tasks.c\r
+ *\r
+ * Created on: 2012. 11. 5.\r
+ * Author: kyuho.jo@samsung.com\r
+ */\r
+#include <stdlib.h>\r
+#include <stdio.h>\r
+#include <string.h>\r
+\r
+\r
+#include "email-debug-log.h"\r
+#include "email-utilities.h"\r
+#include "email-internal-types.h"\r
+#include "email-core-tasks.h"\r
+#include "email-core-task-manager.h"\r
+#include "email-core-mail.h"\r
+#include "email-core-mailbox-sync.h"\r
+#include "tpl.h"\r
+\r
+/*-------------------------------------------------------------------------------------------*/\r
+/* to handle EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT */\r
+#define task_parameter_format_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT "iiiB"\r
+\r
+INTERNAL_FUNC int email_encode_task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT(void *input_task_parameter_struct, char **output_byte_stream, int *output_stream_size)\r
+{\r
+ EM_DEBUG_FUNC_BEGIN("input_task_parameter_struct [%p] output_byte_stream [%p] output_stream_size [%p]", input_task_parameter_struct, output_byte_stream, output_stream_size);\r
+\r
+ int err = EMAIL_ERROR_NONE;\r
+ task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT *task_parameter = input_task_parameter_struct;\r
+ tpl_bin tb;\r
+ tpl_node *tn = NULL;\r
+ void *result_data = NULL;\r
+ size_t result_data_length = 0;\r
+\r
+ if (task_parameter == NULL || output_byte_stream == NULL || output_stream_size == NULL) {\r
+ EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");\r
+ err = EMAIL_ERROR_INVALID_PARAM;\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT\r
+ , &task_parameter->source_mailbox_id\r
+ , &task_parameter->target_mailbox_id\r
+ , &task_parameter->mail_id_count\r
+ , &tb);\r
+ tb.sz = sizeof(int) * task_parameter->mail_id_count;\r
+ tb.addr = task_parameter->mail_id_array;\r
+ tpl_pack(tn, 0);\r
+ tpl_dump(tn, TPL_MEM, &result_data, &result_data_length);\r
+ tpl_free(tn);\r
+\r
+ *output_byte_stream = result_data;\r
+ *output_stream_size = result_data_length;\r
+\r
+FINISH_OFF:\r
+\r
+ EM_DEBUG_FUNC_END("err [%d]", err);\r
+ return EMAIL_ERROR_NONE;\r
+}\r
+\r
+INTERNAL_FUNC int email_decode_task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT(char *input_byte_stream, int input_stream_size, void **output_task_parameter_struct)\r
+{\r
+ EM_DEBUG_FUNC_BEGIN("input_byte_stream [%p] input_stream_size [%d] output_task_parameter_struct [%p]", input_byte_stream, input_stream_size, output_task_parameter_struct);\r
+ int err = EMAIL_ERROR_NONE;\r
+ tpl_bin tb;\r
+ tpl_node *tn = NULL;\r
+ task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT *task_parameter = NULL;\r
+\r
+ if (input_byte_stream == NULL || input_stream_size == 0 || output_task_parameter_struct == NULL) {\r
+ EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");\r
+ err = EMAIL_ERROR_INVALID_PARAM;\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ task_parameter = em_malloc(sizeof(task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT));\r
+\r
+ if(task_parameter == NULL) {\r
+ EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY");\r
+ err = EMAIL_ERROR_OUT_OF_MEMORY;\r
+ goto FINISH_OFF;\r
+ }\r
+\r
+ tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT\r
+ , &task_parameter->source_mailbox_id\r
+ , &task_parameter->target_mailbox_id\r
+ , &task_parameter->mail_id_count\r
+ , &tb);\r
+ tpl_load(tn, TPL_MEM, input_byte_stream, input_stream_size);\r
+ tpl_unpack(tn, 0);\r
+ if(task_parameter->mail_id_count <= 0 || tb.addr == NULL) {\r
+ EM_DEBUG_LOG("No mail id list. mail_id_count[%d] addr[%p]", task_parameter->mail_id_count, tb.addr);\r
+ }\r
+ else {\r
+ task_parameter->mail_id_array = em_malloc(sizeof(int) * task_parameter->mail_id_count);\r
+\r
+ if(task_parameter->mail_id_array == NULL) {\r
+ EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY");\r
+ err = EMAIL_ERROR_OUT_OF_MEMORY;\r
+ goto FINISH_OFF;\r
+ }\r
+ memcpy(task_parameter->mail_id_array, tb.addr, sizeof(int) * task_parameter->mail_id_count);\r
+ EM_SAFE_FREE(tb.addr);\r
+ }\r
+\r
+ *output_task_parameter_struct = task_parameter;\r
+\r
+FINISH_OFF:\r
+\r
+ if(tn)\r
+ tpl_free(tn);\r
+\r
+ EM_DEBUG_FUNC_END("err [%d]", err);\r
+ return EMAIL_ERROR_NONE;\r
+}\r
+\r
+void* task_handler_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT(void *input_param)\r
+{\r
+ EM_DEBUG_FUNC_BEGIN("input_param [%p]", input_param);\r
+ int err = EMAIL_ERROR_NONE;\r
+ int i = 0;\r
+ int moved_mail_id = 0;\r
+ task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT *task_param = input_param;\r
+ email_active_task_t *active_task = NULL;\r
+\r
+ if((err = emcore_get_active_task_by_thread_id(THREAD_SELF(), &active_task)) != EMAIL_ERROR_NONE) {\r
+ EM_DEBUG_EXCEPTION("emcore_get_active_task_by_thread_id failed [%d]", err);\r
+ goto FINISH_OFF;\r
+ }\r
+ for(i = 0; i < task_param->mail_id_count; i++) {\r
+ if((err = emcore_move_mail_to_another_account_on_local_storeage(active_task->task_id, task_param->mail_id_array[i], task_param->source_mailbox_id, task_param->target_mailbox_id, &moved_mail_id)) != EMAIL_ERROR_NONE) {\r
+ EM_DEBUG_EXCEPTION("emcore_move_mail_to_another_account_on_local_storeage failed [%d]", err);\r
+ /* goto FINISH_OFF; */\r
+ }\r
+\r
+ if((err = emcore_sync_mail_from_client_to_server(moved_mail_id, &err)) != EMAIL_ERROR_NONE) {\r
+ EM_DEBUG_EXCEPTION("emcore_sync_mail_from_client_to_server failed [%d]", err);\r
+ /* goto FINISH_OFF; */\r
+ }\r
+ }\r
+\r
+FINISH_OFF:\r
+\r
+ EM_DEBUG_FUNC_END("err [%d]", err);\r
+ return NULL;\r
+}\r
+/*-------------------------------------------------------------------------------------------*/\r
--- /dev/null
+/*\r
+* email-service\r
+*\r
+* Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.\r
+*\r
+* Contact: Kyuho Jo <kyuho.jo@samsung.com>, Sunghyun Kwon <sh0701.kwon@samsung.com>\r
+*\r
+* Licensed under the Apache License, Version 2.0 (the "License");\r
+* you may not use this file except in compliance with the License.\r
+* You may obtain a copy of the License at\r
+*\r
+* http://www.apache.org/licenses/LICENSE-2.0\r
+*\r
+* Unless required by applicable law or agreed to in writing, software\r
+* distributed under the License is distributed on an "AS IS" BASIS,\r
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+* See the License for the specific language governing permissions and\r
+* limitations under the License.\r
+*\r
+*/\r
+\r
+/*\r
+ * email-core-signal.h\r
+ *\r
+ * Created on: 2012. 11. 22.\r
+ * Author: kyuho.jo@samsung.com\r
+ */\r
+\r
+#ifndef EMAIL_CORE_SIGNAL_H_\r
+#define EMAIL_CORE_SIGNAL_H_\r
+\r
+#include "email-internal-types.h"\r
+#include "email-core-tasks.h"\r
+\r
+INTERNAL_FUNC int emcore_initialize_signal();\r
+\r
+INTERNAL_FUNC int emcore_finalize_signal();\r
+\r
+/* emcore_notify_storage_event - Notification for storage related operations */\r
+INTERNAL_FUNC int emcore_notify_storage_event(email_noti_on_storage_event event_type, int data1, int data2 , char *data3, int data4);\r
+\r
+/* emcore_notify_network_event - Notification for network related operations */\r
+INTERNAL_FUNC int emcore_notify_network_event(email_noti_on_network_event event_type, int data1, char *data2, int data3, int data4);\r
+\r
+/* emcore_notify_response_to_api - Notification for response to API */\r
+INTERNAL_FUNC int emcore_notify_response_to_api(email_event_type_t event_type, int data1, int data2);\r
+\r
+INTERNAL_FUNC int emcore_send_task_status_signal(email_task_type_t input_task_type, int input_task_id, email_task_status_type_t input_task_status, int input_param_1, int input_param_2);\r
+\r
+#endif /* EMAIL_CORE_SIGNAL_H_ */\r
--- /dev/null
+/*\r
+* email-service\r
+*\r
+* Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.\r
+*\r
+* Contact: Kyuho Jo <kyuho.jo@samsung.com>, Sunghyun Kwon <sh0701.kwon@samsung.com>\r
+*\r
+* Licensed under the Apache License, Version 2.0 (the "License");\r
+* you may not use this file except in compliance with the License.\r
+* You may obtain a copy of the License at\r
+*\r
+* http://www.apache.org/licenses/LICENSE-2.0\r
+*\r
+* Unless required by applicable law or agreed to in writing, software\r
+* distributed under the License is distributed on an "AS IS" BASIS,\r
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+* See the License for the specific language governing permissions and\r
+* limitations under the License.\r
+*\r
+*/\r
+\r
+/*\r
+ * email-core-task-manager.h\r
+ *\r
+ * Created on: 2012. 11. 1.\r
+ * Author: kyuho.jo@samsung.com\r
+ */\r
+\r
+#ifndef EMAIL_CORE_TASK_MANAGER_H_\r
+#define EMAIL_CORE_TASK_MANAGER_H_\r
+\r
+#include "email-internal-types.h"\r
+#include "email-core-tasks.h"\r
+\r
+INTERNAL_FUNC int emcore_init_task_handler_array();\r
+INTERNAL_FUNC int emcore_free_task_handler_array();\r
+\r
+INTERNAL_FUNC int emcore_encode_task_parameter(email_task_type_t input_task_type, void *input_task_parameter_struct, char **output_byte_stream, int *output_stream_size);\r
+INTERNAL_FUNC int emcore_decode_task_parameter(email_task_type_t input_task_type, char *input_byte_stream, int input_stream_size, void **output_task_parameter_struct);\r
+\r
+INTERNAL_FUNC int emcore_add_task_to_task_table(email_task_type_t input_task_type, email_task_priority_t input_task_priority, char *input_task_parameter, int input_task_parameter_length, int *output_task_id);\r
+INTERNAL_FUNC int emcore_remove_task_from_task_table(int input_task_id);\r
+INTERNAL_FUNC int emcore_get_active_task_by_thread_id(thread_t input_thread_id, email_active_task_t **output_active_task);\r
+\r
+INTERNAL_FUNC int emcore_start_task_manager_loop();\r
+INTERNAL_FUNC int emcore_stop_task_manager_loop();\r
+\r
+#endif /* EMAIL_CORE_TASK_MANAGER_H_ */\r
--- /dev/null
+/*\r
+* email-service\r
+*\r
+* Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.\r
+*\r
+* Contact: Kyuho Jo <kyuho.jo@samsung.com>, Sunghyun Kwon <sh0701.kwon@samsung.com>\r
+*\r
+* Licensed under the Apache License, Version 2.0 (the "License");\r
+* you may not use this file except in compliance with the License.\r
+* You may obtain a copy of the License at\r
+*\r
+* http://www.apache.org/licenses/LICENSE-2.0\r
+*\r
+* Unless required by applicable law or agreed to in writing, software\r
+* distributed under the License is distributed on an "AS IS" BASIS,\r
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+* See the License for the specific language governing permissions and\r
+* limitations under the License.\r
+*\r
+*/\r
+/*\r
+ * email-core-tasks.h\r
+ *\r
+ * Created on: 2012. 11. 5.\r
+ * Author: kyuho.jo@samsung.com\r
+ */\r
+\r
+#ifndef EMAIL_CORE_TASKS_H_\r
+#define EMAIL_CORE_TASKS_H_\r
+\r
+#include "email-internal-types.h"\r
+\r
+typedef struct\r
+{\r
+ email_task_type_t task_type;\r
+ void* (*task_handler_function)(void*);\r
+ int (*task_parameter_encoder)(void*, char**, int*);\r
+ int (*task_parameter_decoder)(char*, int, void**);\r
+} email_task_handler_t;\r
+\r
+typedef struct\r
+{\r
+ int task_id;\r
+ email_task_type_t task_type;\r
+ email_task_status_type_t task_status;\r
+ email_task_priority_t task_priority;\r
+ int task_parameter_length;\r
+ char *task_parameter;\r
+\r
+ /* Not be stored in DB*/\r
+ thread_t thread_id;\r
+ int active_task_id;\r
+} email_task_t;\r
+\r
+#define DECLARE_CONVERTER_FOR_TASK_PARAMETER(TASK_NAME) INTERNAL_FUNC int email_encode_task_parameter_##TASK_NAME(void *input_task_parameter_struct, char **output_byte_stream, int *output_stream_size); \\r
+ INTERNAL_FUNC int email_decode_task_parameter_##TASK_NAME(char *input_byte_stream, int input_stream_size, void **output_task_parameter_struct);\r
+\r
+/*-------------------------------------------------------------------------------------------*/\r
+/* to handle _EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT */\r
+typedef struct\r
+{\r
+ int source_mailbox_id;\r
+ int target_mailbox_id;\r
+ int mail_id_count;\r
+ int *mail_id_array;\r
+} task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT;\r
+\r
+DECLARE_CONVERTER_FOR_TASK_PARAMETER(EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT);\r
+void* task_handler_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT(void *param);\r
+/*-------------------------------------------------------------------------------------------*/\r
+\r
+#endif /* EMAIL_CORE_TASKS_H_ */\r
--- /dev/null
+[D-BUS Service]
+Name=org.tizen.email_service
+Exec=/usr/bin/email-service
--- /dev/null
+<?xml version="1.0" encoding="UTF-8" ?>
+<node name="/org/tizen/email_service">
+ <interface name="org.tizen.email_service">
+ <method name="Launch">
+ <annotation name="org.freedesktop.DBus.GLib.CSymbol" value="email_service_launch"/>
+ <arg type="u" name="result_val" direction="out"/>
+ </method>
+ </interface>
+</node>
projects / platform / framework / native / messaging.git / commitdiff