-/*\r
-* email-service\r
-*\r
-* Copyright (c) 2012 - 2013 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(char *multi_user_name, 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_async_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_async_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(NULL, 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
-INTERNAL_FUNC void* emcore_default_async_task_handler(void *input_param)\r
-{\r
- EM_DEBUG_FUNC_BEGIN("intput_param [%p]", input_param);\r
- int err = EMAIL_ERROR_NONE;\r
- email_task_t *task = input_param;\r
- email_task_handler_t *task_handler = NULL;\r
- void *decoded_task_parameter = NULL;\r
-\r
- if((err = emcore_initialize_async_task_handler(task)) != EMAIL_ERROR_NONE) {\r
- EM_DEBUG_EXCEPTION("emcore_initialize_async_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_async_task_handler(task, err);\r
-\r
- EM_SAFE_FREE(decoded_task_parameter);\r
-\r
- EM_DEBUG_FUNC_END("err [%d]", err);\r
- return NULL;\r
-}\r
-\r
-INTERNAL_FUNC void* emcore_default_sync_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
- /* 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
- err = (int)task_handler->task_handler_function(decoded_task_parameter);\r
- }\r
-\r
- EM_DEBUG_FUNC_END("err [%d]", err);\r
- return (void*)err;\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
- EM_SAFE_FREE(new_task_handler);\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
-INTERNAL_FUNC int emcore_init_task_handler_array()\r
-{\r
- EM_DEBUG_FUNC_BEGIN();\r
-\r
- if (_task_handler_array == NULL) {\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
- REGISTER_TASK_BINDER(EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX);\r
- REGISTER_TASK_BINDER(EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL);\r
- REGISTER_TASK_BINDER(EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL);\r
- REGISTER_TASK_BINDER(EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE);\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
- EM_SAFE_FREE (_task_handler_array[i]);\r
- }\r
-\r
- EM_SAFE_FREE (_task_handler_array);\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
+/*
+* email-service
+*
+* Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved.
+*
+* Contact: Kyuho Jo <kyuho.jo@samsung.com>, Sunghyun Kwon <sh0701.kwon@samsung.com>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*
+*/
+
+/*
+ * email-core-task-manager.c
+ *
+ * Created on: 2012. 11. 1.
+ * Author: kyuho.jo@samsung.com
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <dbus/dbus.h>
+
+#include "email-internal-types.h"
+#include "email-utilities.h"
+#include "email-core-tasks.h"
+#include "email-core-task-manager.h"
+#include "email-core-signal.h"
+#include "email-core-global.h"
+#include "email-core-utils.h"
+#include "email-debug-log.h"
+
+/* TODO : implement a function for removing a task from task pool */
+/* TODO : after fetching a task from DB, update status of the task. */
+
+
+#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)
+
+/*- variables - begin --------------------------------------------------------*/
+static pthread_cond_t _task_available_signal = PTHREAD_COND_INITIALIZER;
+static pthread_mutex_t _task_available_lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t _task_manager_loop_lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t _active_task_pool_lock = PTHREAD_MUTEX_INITIALIZER;
+
+static email_active_task_t _active_task_pool[MAX_ACTIVE_TASK];
+static thread_t _thread_task_manager_loop;
+static int _task_manager_loop_availability = 1;
+/*- variables - end ----------------------------------------------------------*/
+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);
+static int emcore_remove_task_from_active_task_pool(int input_task_id);
+static int emcore_find_available_slot_in_active_task_pool(int *result_index);
+static int emcore_update_task_status_on_task_table(char *multi_user_name, int input_task_id, email_task_status_type_t task_status);
+static int emcore_get_task_handler_reference(email_task_type_t input_task_type, email_task_handler_t **output_task_handler);
+
+/*- task handlers helpers - begin --------------------------------------------*/
+static int emcore_initialize_async_task_handler(email_task_t *input_task)
+{
+ EM_DEBUG_FUNC_BEGIN("input_task [%p]", input_task);
+ int err = EMAIL_ERROR_NONE;
+
+ if(input_task == NULL) {
+ EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
+ err = EMAIL_ERROR_INVALID_PARAM;
+ goto FINISH_OFF;
+ }
+
+ /* insert task to _active_task_pool */
+ emcore_insert_task_to_active_task_pool(input_task->active_task_id
+ , input_task->task_id
+ , input_task->task_type
+ , THREAD_SELF());
+
+ /* send notification for 'task start */
+ 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) {
+ EM_DEBUG_EXCEPTION("emcore_send_task_status_signal failed [%d]", err);
+ goto FINISH_OFF;
+ }
+
+FINISH_OFF:
+
+ EM_DEBUG_FUNC_END("err [%d]", err);
+ return err;
+}
+
+static int emcore_finalize_async_task_handler(email_task_t *input_task, int input_error_code)
+{
+ EM_DEBUG_FUNC_BEGIN("input_task [%p] input_error_code [%d]",input_task ,input_error_code);
+ int err = EMAIL_ERROR_NONE;
+ email_task_status_type_t task_status = EMAIL_TASK_STATUS_FINISHED;
+
+ if(input_task == NULL) {
+ EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
+ err = EMAIL_ERROR_INVALID_PARAM;
+ goto FINISH_OFF;
+ }
+
+ if(input_error_code != EMAIL_ERROR_NONE) {
+ task_status = EMAIL_TASK_STATUS_FAILED;
+ }
+
+ /* remove task from task table */
+ if( (err = emcore_remove_task_from_task_table(NULL, input_task->task_id)) != EMAIL_ERROR_NONE) {
+ EM_DEBUG_EXCEPTION("emcore_remove_task_from_active_task_pool failed [%d]", err);
+ goto FINISH_OFF;
+ }
+
+ /* remove task id from active task id array */
+ if( (err = emcore_remove_task_from_active_task_pool(input_task->task_id)) != EMAIL_ERROR_NONE) {
+ EM_DEBUG_EXCEPTION("emcore_remove_task_from_active_task_pool failed [%d]", err);
+ goto FINISH_OFF;
+ }
+
+ /* send signal for 'task finish or failure */
+ if( (err = emcore_send_task_status_signal(input_task->task_type, input_task->task_id, task_status, input_error_code, 0)) != EMAIL_ERROR_NONE) {
+ EM_DEBUG_EXCEPTION("emcore_send_task_status_signal failed [%d]", err);
+ goto FINISH_OFF;
+ }
+
+ ENTER_CRITICAL_SECTION(_task_available_lock);
+ WAKE_CONDITION_VARIABLE(_task_available_signal);
+ LEAVE_CRITICAL_SECTION(_task_available_lock);
+
+FINISH_OFF:
+ EM_DEBUG_FUNC_END("err [%d]", err);
+ return err;
+}
+
+INTERNAL_FUNC void* emcore_default_async_task_handler(void *input_param)
+{
+ EM_DEBUG_FUNC_BEGIN("intput_param [%p]", input_param);
+ int err = EMAIL_ERROR_NONE;
+ email_task_t *task = input_param;
+ email_task_handler_t *task_handler = NULL;
+ void *decoded_task_parameter = NULL;
+
+ if((err = emcore_initialize_async_task_handler(task)) != EMAIL_ERROR_NONE) {
+ EM_DEBUG_EXCEPTION("emcore_initialize_async_task_handler failed. [%d]", err);
+ goto FINISH_OFF;
+ }
+
+ /* create a thread to do this task */
+ if ((err = emcore_get_task_handler_reference(task->task_type, &task_handler)) != EMAIL_ERROR_NONE) {
+ EM_DEBUG_LOG("emcore_get_task_handler_reference returns [%d]", err);
+ }
+ else {
+ /* Decode parameter */
+ emcore_decode_task_parameter(task->task_type,
+ task->task_parameter,
+ task->task_parameter_length,
+ &decoded_task_parameter);
+
+ task_handler->task_handler_function(decoded_task_parameter);
+ }
+
+FINISH_OFF:
+ emcore_finalize_async_task_handler(task, err);
+
+ EM_SAFE_FREE(decoded_task_parameter);
+
+ EM_DEBUG_FUNC_END("err [%d]", err);
+ return NULL;
+}
+
+INTERNAL_FUNC int emcore_default_sync_task_handler(void *intput_param)
+{
+ EM_DEBUG_FUNC_BEGIN("intput_param [%p]", intput_param);
+ int err = EMAIL_ERROR_NONE;
+ int *return_err = NULL;
+ email_task_t *task = intput_param;
+ email_task_handler_t *task_handler = NULL;
+ void *decoded_task_parameter = NULL;
+
+ /* create a thread to do this task */
+ if ((err = emcore_get_task_handler_reference(task->task_type, &task_handler)) != EMAIL_ERROR_NONE) {
+ EM_DEBUG_LOG("emcore_get_task_handler_reference returns [%d]", err);
+ } else {
+ /* Decode parameter */
+ emcore_decode_task_parameter(task->task_type,
+ task->task_parameter,
+ task->task_parameter_length,
+ &decoded_task_parameter);
+
+ return_err = (int *)task_handler->task_handler_function(decoded_task_parameter);
+ }
+
+ if (return_err) {
+ err = *return_err;
+ free(return_err);
+ }
+
+ EM_SAFE_FREE(decoded_task_parameter);
+
+ EM_DEBUG_FUNC_END("err [%d]", err);
+ return err;
+}
+/*- task handlers helpers - end --------------------------------------------*/
+
+int _task_handler_array_size;
+email_task_handler_t **_task_handler_array;
+
+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**))
+{
+ 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);
+
+ int err = EMAIL_ERROR_NONE;
+ email_task_handler_t *new_task_handler = NULL;
+
+ new_task_handler = malloc(sizeof(email_task_handler_t));
+
+ if (new_task_handler == NULL) {
+ err = EMAIL_ERROR_OUT_OF_MEMORY;
+ EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY");
+ goto FINISH_OFF;
+ }
+
+ new_task_handler->task_type = input_task_type;
+ new_task_handler->task_handler_function = input_task_handler;
+ new_task_handler->task_parameter_encoder = input_task_parameter_encoder;
+ new_task_handler->task_parameter_decoder = input_task_parameter_decoder;
+
+ _task_handler_array_size++;
+
+ if (_task_handler_array) {
+ _task_handler_array = realloc(_task_handler_array, sizeof(email_task_handler_t*) * _task_handler_array_size);
+ }
+ else {
+ _task_handler_array = malloc(sizeof(email_task_handler_t*) * _task_handler_array_size);
+ }
+
+ if (_task_handler_array == NULL) {
+ err = EMAIL_ERROR_OUT_OF_MEMORY;
+ EM_SAFE_FREE(new_task_handler);
+ goto FINISH_OFF;
+ }
+
+ _task_handler_array[_task_handler_array_size - 1] = new_task_handler;
+
+FINISH_OFF:
+
+ EM_DEBUG_FUNC_END("err [%d]", err);
+ return err;
+}
+
+INTERNAL_FUNC int emcore_init_task_handler_array()
+{
+ EM_DEBUG_FUNC_BEGIN();
+
+ if (_task_handler_array == NULL) {
+ _task_handler_array = NULL;
+ _task_handler_array_size = 0;
+
+ REGISTER_TASK_BINDER(EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT);
+ REGISTER_TASK_BINDER(EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX);
+ REGISTER_TASK_BINDER(EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL);
+ REGISTER_TASK_BINDER(EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL);
+ REGISTER_TASK_BINDER(EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE);
+ }
+
+ EM_DEBUG_FUNC_END();
+ return EMAIL_ERROR_NONE;
+}
+
+INTERNAL_FUNC int emcore_free_task_handler_array()
+{
+ EM_DEBUG_FUNC_BEGIN();
+
+ int i = 0;
+
+ for(i = 0; i < _task_handler_array_size; i++) {
+ EM_SAFE_FREE (_task_handler_array[i]);
+ }
+
+ EM_SAFE_FREE (_task_handler_array);
+ _task_handler_array_size = 0;
+
+ EM_DEBUG_FUNC_END();
+ return EMAIL_ERROR_NONE;
+}
+
+static int emcore_get_task_handler_reference(email_task_type_t input_task_type, email_task_handler_t **output_task_handler)
+{
+ EM_DEBUG_FUNC_BEGIN("input_task_type [%d] output_task_handler [%p]", input_task_type, output_task_handler);
+ int i = 0;
+ int err = EMAIL_ERROR_NONE;
+
+ if (output_task_handler == NULL) {
+ EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
+ err = EMAIL_ERROR_INVALID_PARAM;
+ goto FINISH_OFF;
+ }
+
+ *output_task_handler = NULL;
+ for (i = 0; i < _task_handler_array_size; i++) {
+ if (_task_handler_array[i]->task_type == input_task_type) {
+ *output_task_handler = _task_handler_array[i];
+ break;
+ }
+ }
+
+ if (*output_task_handler == NULL) {
+ EM_DEBUG_EXCEPTION("EMAIL_ERROR_TASK_BINDER_NOT_FOUND");
+ err = EMAIL_ERROR_TASK_BINDER_NOT_FOUND;
+ goto FINISH_OFF;
+ }
+
+FINISH_OFF:
+ EM_DEBUG_FUNC_END("err [%d]", err);
+ return err;
+}
+
+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)
+{
+ 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);
+ int err = EMAIL_ERROR_NONE;
+ email_task_handler_t *task_handler = NULL;
+ int (*task_parameter_encoder)(void*, char**, int*);
+
+ if (input_task_parameter_struct == NULL || output_byte_stream == NULL || output_stream_size == NULL) {
+ EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
+ err = EMAIL_ERROR_INVALID_PARAM;
+ goto FINISH_OFF;
+ }
+
+ if ((err = emcore_get_task_handler_reference(input_task_type, &task_handler)) != EMAIL_ERROR_NONE) {
+ EM_DEBUG_EXCEPTION("emcore_get_task_handler_reference failed [%d]", err);
+ goto FINISH_OFF;
+ }
+
+ task_parameter_encoder = task_handler->task_parameter_encoder;
+
+ if ((err = task_parameter_encoder(input_task_parameter_struct, output_byte_stream, output_stream_size)) != EMAIL_ERROR_NONE) {
+ EM_DEBUG_EXCEPTION("task_parameter_encoder failed [%d]", err);
+ goto FINISH_OFF;
+ }
+
+FINISH_OFF:
+ EM_DEBUG_FUNC_END("err [%d]", err);
+ return err;
+}
+
+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)
+{
+ 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);
+ int err = EMAIL_ERROR_NONE;
+ email_task_handler_t *task_handler = NULL;
+ int (*task_parameter_decoder)(char*, int, void**);
+
+ if (input_byte_stream == NULL || output_task_parameter_struct == NULL) {
+ EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
+ err = EMAIL_ERROR_INVALID_PARAM;
+ goto FINISH_OFF;
+ }
+
+ if ((err = emcore_get_task_handler_reference(input_task_type, &task_handler)) != EMAIL_ERROR_NONE) {
+ EM_DEBUG_EXCEPTION("emcore_get_task_handler_reference failed [%d]", err);
+ goto FINISH_OFF;
+ }
+
+ task_parameter_decoder = task_handler->task_parameter_decoder;
+