*/
// includes
-#include <messages.h>
-#include <email.h>
+#include <msg.h>
+#include <msg_transport.h>
+#include <msg_storage.h>
+#include <dbus/dbus.h>
+#include <dbus/dbus-glib-lowlevel.h>
+#include <email-api.h>
#include <FBaseUtilStringUtil.h>
#include <FIoFile.h>
#include <FMsgMmsMessage.h>
#include <FBaseSysLog.h>
#include <FBase_StringConverter.h>
#include "FMsg_SmsMessageImpl.h"
+#include "FMsg_EmailManagerImpl.h"
#include "FMsg_MsgUtil.h"
using namespace Tizen::Base;
using namespace Tizen::Base::Utility;
using namespace Tizen::Io;
+static const char* BODY_TEXT_FILE_NAME = "/tmp/mmsbodytext.txt";
+
namespace Tizen { namespace Messaging
{
{
pItem = dynamic_cast< String* >(pToList->GetAt(index));
SysTryCatch(NID_MSG, pItem != null, r = E_INVALID_ADDRESS, r, "To List Null");
- r = CheckAddressValidity(*pItem, type);
+ r = CheckAddressValidity(*pItem, type);
if (type == _MSG_MMS && r != E_SUCCESS) //Check If MMS might have email address
{
}
SmsMessageBoxType
-_MsgUtil::GetSmsMessageBoxType(messages_message_box_e folderId)
+_MsgUtil::GetSmsMessageBoxType(_MSG_FOLDER_ID_E folderId)
{
SmsMessageBoxType type = SMS_MESSAGE_BOX_TYPE_NONE;
switch (folderId)
{
- case MESSAGES_MBOX_INBOX:
+ case MSG_INBOX_ID:
type = SMS_MESSAGE_BOX_TYPE_INBOX;
break;
- case MESSAGES_MBOX_OUTBOX:
+ case MSG_OUTBOX_ID:
type = SMS_MESSAGE_BOX_TYPE_OUTBOX;
break;
- case MESSAGES_MBOX_SENTBOX:
+ case MSG_SENTBOX_ID:
type = SMS_MESSAGE_BOX_TYPE_SENTBOX;
break;
-// case MESSAGES_MBOX_ALL:
+// case MSG_ALLBOX_ID:
// type = SMS_MESSAGE_BOX_TYPE_ALL;
// break;
return type;
}
-messages_message_box_e
+_MSG_FOLDER_ID_E
_MsgUtil::GetMsgFolderId(const SmsMessageBoxType& type)
{
- messages_message_box_e folderId;
+ _MSG_FOLDER_ID_E folderId;
switch (type)
{
case SMS_MESSAGE_BOX_TYPE_INBOX:
- folderId = MESSAGES_MBOX_INBOX;
+ folderId = MSG_INBOX_ID;
break;
case SMS_MESSAGE_BOX_TYPE_OUTBOX:
- folderId = MESSAGES_MBOX_OUTBOX;
+ folderId = MSG_OUTBOX_ID;
break;
case SMS_MESSAGE_BOX_TYPE_SENTBOX:
- folderId = MESSAGES_MBOX_SENTBOX;
+ folderId = MSG_SENTBOX_ID;
break;
case SMS_MESSAGE_BOX_TYPE_ALL:
- folderId = MESSAGES_MBOX_ALL;
+ folderId = MSG_ALLBOX_ID;
break;
default:
- folderId = (messages_message_box_e) -1;
+ folderId = MSG_MAX_FOLDER_ID;
break;
}
}
SmsMessageBoxType
-_MsgUtil::GetMsgBoxType(const messages_message_box_e& folderId)
+_MsgUtil::GetMsgBoxType(const _MSG_FOLDER_ID_E& folderId)
{
SmsMessageBoxType type;
switch (folderId)
{
- case MESSAGES_MBOX_INBOX:
+ case MSG_INBOX_ID:
type = SMS_MESSAGE_BOX_TYPE_INBOX;
break;
- case MESSAGES_MBOX_OUTBOX:
+ case MSG_OUTBOX_ID:
type = SMS_MESSAGE_BOX_TYPE_OUTBOX;
break;
- case MESSAGES_MBOX_SENTBOX:
+ case MSG_SENTBOX_ID:
type = SMS_MESSAGE_BOX_TYPE_SENTBOX;
break;
- case MESSAGES_MBOX_ALL:
+ case MSG_ALLBOX_ID:
type = SMS_MESSAGE_BOX_TYPE_ALL;
break;
}
int
-_MsgUtil::GetSmsMessage(const SmsMessage& message, const RecipientList& recipientList, messages_message_h& smsMsg)
+_MsgUtil::GetSmsMessage(msg_struct_t& msgInfo, const SmsMessage& message, const RecipientList& recipientList)
{
- int err = MESSAGES_ERROR_NONE;
- const char* pMsgBody = null;
+ int err = MSG_SUCCESS;
+ char* pMsgBody = null;
result r = E_SUCCESS;
- //create new message
- err = messages_create_message(MESSAGES_TYPE_SMS, &smsMsg);
- SysTryCatch(NID_MSG, err == MESSAGES_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "failed to create message object");
-
if (message.GetText().GetLength() == 0)
{
Tizen::Base::String emptyText(L" ");
SysTryCatch(NID_MSG, pMsgBody != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "memory allocation failed.");
- err = messages_set_text(smsMsg, pMsgBody);
- SysTryCatch(NID_MSG, err == MESSAGES_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "failed to set message text");
+ err = msg_set_int_value(msgInfo, MSG_MESSAGE_TYPE_INT, MSG_TYPE_SMS);
+ SysTryCatch(NID_MSG, err == MSG_SUCCESS, r = E_SYSTEM, E_SYSTEM, "Set Message Type error");
- err = AddMessageAddress(recipientList, RECIPIENT_TYPE_TO, smsMsg, MESSAGES_RECIPIENT_TO);
- SysTryCatch(NID_MSG, err == MESSAGES_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "failed to set message To address");
+ err = msg_set_str_value(msgInfo, MSG_MESSAGE_SMS_DATA_STR, pMsgBody, strlen(pMsgBody));
+ SysTryCatch(NID_MSG, err == MSG_SUCCESS, r = E_SYSTEM, E_SYSTEM, "Set Message body error");
+
+ err = AddMessageAddress(recipientList, RECIPIENT_TYPE_TO, msgInfo, MSG_RECIPIENTS_TYPE_TO);
+ SysTryCatch(NID_MSG, err == MSG_SUCCESS, r = E_SYSTEM, E_SYSTEM, "Message add address error");
if (pMsgBody)
{
return err;
CATCH:
+ SetLastResult(r);
if (pMsgBody)
{
}
int
-_MsgUtil::GetEmailMessage(const EmailMessage& message, const RecipientList& recipientList, email_h& emailMsg)
+_MsgUtil::GetMmsMessage(msg_struct_t& msgInfo, const MmsMessage& message, const RecipientList& recipientList)
{
- int err = EMAIL_ERROR_NONE;
+ int err = MSG_SUCCESS;
result r = E_SUCCESS;
- int attachNum = 0;
- const char* pSubject = null;
- const char* pMsgBody = null;
- Tizen::Base::Collection::IList* pAttachmentList = null;
+ char* pSubject = null;
pSubject = _StringConverter::CopyToCharArrayN(message.GetSubject());
- pMsgBody = _StringConverter::CopyToCharArrayN(message.GetText());
+ SysTryCatch(NID_MSG, pSubject != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "memory allocation failed.");
- err = email_set_subject(emailMsg, pSubject);
- SysTryCatch(NID_MSG, err == EMAIL_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] email add subject failed");
- err = email_set_body(emailMsg, pMsgBody);
- SysTryCatch(NID_MSG, err == EMAIL_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] email add body failed");
+ //create new message
+ err = msg_set_int_value(msgInfo, MSG_MESSAGE_TYPE_INT, MSG_TYPE_MMS);
+ SysTryCatch(NID_MSG, err == MSG_SUCCESS, r = E_SYSTEM, E_SYSTEM, "Set Message Type error");
- err = AddEmailMessageAddress(recipientList, RECIPIENT_TYPE_TO, emailMsg, EMAIL_RECIPIENT_TYPE_TO);
- SysTryCatch(NID_MSG, err == EMAIL_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] email add recipient failed");
- err = AddEmailMessageAddress(recipientList, RECIPIENT_TYPE_CC, emailMsg, EMAIL_RECIPIENT_TYPE_CC);
- SysTryCatch(NID_MSG, err == EMAIL_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] email add recipient failed");
- err = AddEmailMessageAddress(recipientList, RECIPIENT_TYPE_BCC, emailMsg, EMAIL_RECIPIENT_TYPE_BCC);
- SysTryCatch(NID_MSG, err == EMAIL_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] email add recipient failed");
+ err = msg_set_str_value(msgInfo, MSG_MESSAGE_SUBJECT_STR, pSubject, strlen(pSubject));
+ SysTryCatch(NID_MSG, err == MSG_SUCCESS, r = E_SYSTEM, E_SYSTEM, "Set Message body error");
- pAttachmentList = message.GetAttachmentListN();
+ err = AddMessageAddress(recipientList, RECIPIENT_TYPE_TO, msgInfo, MSG_RECIPIENTS_TYPE_TO);
+ SysTryCatch(NID_MSG, err == MSG_SUCCESS, r = E_SYSTEM, E_SYSTEM, "failed to add To address");
- if (pAttachmentList)
- {
- attachNum = pAttachmentList->GetCount();
- }
+ err = AddMessageAddress(recipientList, RECIPIENT_TYPE_CC, msgInfo, MSG_RECIPIENTS_TYPE_CC);
+ SysTryCatch(NID_MSG, err == MSG_SUCCESS, r = E_SYSTEM, E_SYSTEM, "failed to add Cc address");
- if (attachNum >= 1)
- {
- String* pAttachPath = null;
- char* pTempAttachPath = null;
-
- for (int index = 0; index < attachNum; index++)
- {
- pAttachPath = dynamic_cast< String* >(pAttachmentList->GetAt(index));
- SysTryCatch(NID_MSG, pAttachPath != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] email add attachment failed");
- pTempAttachPath = _StringConverter::CopyToCharArrayN(*pAttachPath);
- err = email_add_attach(emailMsg, pTempAttachPath);
- if (pTempAttachPath)
- {
- delete[] pTempAttachPath;
- pTempAttachPath = null;
- }
- SysTryCatch(NID_MSG, err == EMAIL_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] email add attachment failed");
- }
- }
-
- if (pAttachmentList)
- {
- if (pAttachmentList->GetCount() > 0)
- {
- pAttachmentList->RemoveAll(true);
- }
- delete pAttachmentList;
- pAttachmentList = null;
- }
+ err = AddMessageAddress(recipientList, RECIPIENT_TYPE_BCC, msgInfo, MSG_RECIPIENTS_TYPE_BCC);
+ SysTryCatch(NID_MSG, err == MSG_SUCCESS, r = E_SYSTEM, E_SYSTEM, "failed to add Bcc address");
- if (pMsgBody)
- {
- delete[] pMsgBody;
- pMsgBody = null;
- }
+ err = PopulateMmsContent(message, msgInfo);
+ SysTryCatch(NID_MSG, err == MSG_SUCCESS, r = E_SYSTEM, E_SYSTEM, "failed to generate MMS message");
if (pSubject)
{
return err;
CATCH:
- if (pMsgBody)
- {
- delete[] pMsgBody;
- pMsgBody = null;
- }
+ SetLastResult(r);
if (pSubject)
{
pSubject = null;
}
- if (pAttachmentList)
- {
- if (pAttachmentList->GetCount() > 0)
- {
- pAttachmentList->RemoveAll(true);
- }
- delete pAttachmentList;
- pAttachmentList = null;
- }
-
return err;
}
int
-_MsgUtil::AddEmailMessageAddress(const RecipientList& recipientList, RecipientType type, email_h& emailMsg, email_recipient_type_e recipientType)
+_MsgUtil::PopulateMmsContent(const MmsMessage& message, msg_struct_t& msgData)
{
- String* pTempRecipient = null;
- IList* pRecipientList = null;
- char* pEmailAddr = null;
- int count = 0;
- int err = EMAIL_ERROR_NONE;
+ int err = MSG_SUCCESS;
result r = E_SUCCESS;
+ String filePath;
+ char* pFilePath = null;
+ bool isImage = false;
+ bool isAudio = false;
+ bool isText = false;
- pRecipientList = (const_cast< RecipientList& >(recipientList)).GetListN(type);
- if (!pRecipientList)
+ msg_struct_t mmsData = NULL;
+ msg_struct_t region = NULL;
+ msg_struct_t page = NULL;
+ msg_struct_t media = NULL;
+ msg_struct_t smilText = NULL;
+ msg_struct_t mmsAttach = NULL;
+
+ //create a temp file for body text
+ Tizen::Base::String bodyText = message.GetText();
+ Tizen::Base::String bodyTextFilePath(BODY_TEXT_FILE_NAME);
+ Tizen::Io::File file;
+ r = file.Construct(bodyTextFilePath, L"w+");
+ err = MSG_ERR_MEMORY_ERROR;
+ SysTryCatch(NID_MSG, r == E_SUCCESS, r = E_OUT_OF_MEMORY, r, "memory allocation failed");
+
+ mmsData = msg_create_struct(MSG_STRUCT_MMS);
+
+ if (bodyText.GetLength())
{
- r = GetLastResult();
- SysLogException(NID_MSG, r, "[%s] Failed to get recipient list", GetErrorMessage(r));
- goto CATCH;
+ isText = true;
+ //write text to file
+ r = file.Write(bodyText);
+ err = MSG_ERR_MEMORY_ERROR;
+ SysTryCatch(NID_MSG, r == E_SUCCESS, r = E_OUT_OF_MEMORY, r, "memory allocation failed");
}
- count = pRecipientList->GetCount();
- for (int index = 0; index < count; index++)
+ filePath = message.GetAttachment(MMS_IMAGE);
+ if (filePath.GetLength())
{
- pTempRecipient = dynamic_cast< String* >(pRecipientList->GetAt(index));
- if (!pTempRecipient)
+ isImage = true;
+ }
+
+ filePath = message.GetAttachment(MMS_VIDEO);
+ if (filePath.GetLength())
+ {
+ isImage = true;
+ }
+
+ filePath = message.GetAttachment(MMS_AUDIO);
+ if (filePath.GetLength())
+ {
+ isAudio = true;
+ }
+
+ // Layout Setting
+ msg_set_int_value(mmsData, MSG_MMS_ROOTLAYOUT_WIDTH_INT, 100);
+ msg_set_int_value(mmsData, MSG_MMS_ROOTLAYOUT_HEIGHT_INT, 100);
+ msg_set_int_value(mmsData, MSG_MMS_ROOTLAYOUT_BGCOLOR_INT, 0xffffff);
+ msg_set_bool_value(mmsData, MSG_MMS_ROOTLAYOUT_WIDTH_PERCENT_BOOL, true);
+ msg_set_bool_value(mmsData, MSG_MMS_ROOTLAYOUT_HEIGHT_PERCENT_BOOL, true);
+
+ if (!isImage)
+ {
+ msg_mms_add_item(mmsData, MSG_STRUCT_MMS_REGION, ®ion);
+ msg_set_str_value(region, MSG_MMS_REGION_ID_STR, (char *)"Text", 4);
+ msg_set_int_value(region, MSG_MMS_REGION_LENGTH_LEFT_INT, 0);
+ msg_set_int_value(region, MSG_MMS_REGION_LENGTH_TOP_INT, 0);
+ msg_set_int_value(region, MSG_MMS_REGION_LENGTH_WIDTH_INT, 100);
+ msg_set_int_value(region, MSG_MMS_REGION_LENGTH_HEIGHT_INT, 100);
+ msg_set_int_value(region, MSG_MMS_REGION_BGCOLOR_INT, 0xffffff);
+ }
+ else if (!isText)
+ {
+ msg_mms_add_item(mmsData, MSG_STRUCT_MMS_REGION, ®ion);
+ msg_set_str_value(region, MSG_MMS_REGION_ID_STR, (char *)"Image", 5);
+ msg_set_int_value(region, MSG_MMS_REGION_LENGTH_LEFT_INT, 0);
+ msg_set_int_value(region, MSG_MMS_REGION_LENGTH_TOP_INT, 0);
+ msg_set_int_value(region, MSG_MMS_REGION_LENGTH_WIDTH_INT, 100);
+ msg_set_int_value(region, MSG_MMS_REGION_LENGTH_HEIGHT_INT, 100);
+ msg_set_int_value(region, MSG_MMS_REGION_BGCOLOR_INT, 0xffffff);
+ }
+ else
+ {
+ msg_mms_add_item(mmsData, MSG_STRUCT_MMS_REGION, ®ion);
+ msg_set_str_value(region, MSG_MMS_REGION_ID_STR, (char *)"Image", 5);
+ msg_set_int_value(region, MSG_MMS_REGION_LENGTH_LEFT_INT, 0);
+ msg_set_int_value(region, MSG_MMS_REGION_LENGTH_TOP_INT, 0);
+ msg_set_int_value(region, MSG_MMS_REGION_LENGTH_WIDTH_INT, 100);
+ msg_set_int_value(region, MSG_MMS_REGION_LENGTH_HEIGHT_INT, 50);
+ msg_set_int_value(region, MSG_MMS_REGION_BGCOLOR_INT, 0xffffff);
+
+ msg_mms_add_item(mmsData, MSG_STRUCT_MMS_REGION, ®ion);
+ msg_set_str_value(region, MSG_MMS_REGION_ID_STR, (char *)"Text", 4);
+ msg_set_int_value(region, MSG_MMS_REGION_LENGTH_LEFT_INT, 0);
+ msg_set_int_value(region, MSG_MMS_REGION_LENGTH_TOP_INT, 50);
+ msg_set_int_value(region, MSG_MMS_REGION_LENGTH_WIDTH_INT, 100);
+ msg_set_int_value(region, MSG_MMS_REGION_LENGTH_HEIGHT_INT, 50);
+ msg_set_int_value(region, MSG_MMS_REGION_BGCOLOR_INT, 0xffffff);
+ }
+
+ // Add Media
+ msg_mms_add_item(mmsData, MSG_STRUCT_MMS_PAGE, &page);
+ msg_set_int_value(page, MSG_MMS_PAGE_PAGE_DURATION_INT, 5440);
+
+ if (isImage)
+ {
+ filePath = message.GetAttachment(MMS_IMAGE);
+ if (filePath.GetLength())
{
- r = GetLastResult();
- err = EMAIL_ERROR_OPERATION_FAILED;
- SysLogException(NID_MSG, r, "[%s] Failed to get a recipient", GetErrorMessage(r));
- goto CATCH;
+ pFilePath = _StringConverter::CopyToCharArrayN(filePath);
+ err = MSG_ERR_MEMORY_ERROR;
+ SysTryCatch(NID_MSG, pFilePath != null, r = E_OUT_OF_MEMORY, r, "memory allocation failed");
+
+ msg_mms_add_item(page, MSG_STRUCT_MMS_MEDIA, &media);
+ msg_set_int_value(media, MSG_MMS_MEDIA_TYPE_INT, MMS_SMIL_MEDIA_IMG);
+ msg_set_str_value(media, MSG_MMS_MEDIA_REGION_ID_STR, (char *)"Image", 5);
+ msg_set_str_value(media, MSG_MMS_MEDIA_FILEPATH_STR, pFilePath, MSG_FILEPATH_LEN_MAX);
+
+ delete[] pFilePath;
+ pFilePath = null;
}
- pEmailAddr = _StringConverter::CopyToCharArrayN(*pTempRecipient);
- err = email_add_recipient(emailMsg, recipientType, pEmailAddr);
+ filePath = message.GetAttachment(MMS_VIDEO);
+ if (filePath.GetLength())
+ {
+ pFilePath = _StringConverter::CopyToCharArrayN(filePath);
+ err = MSG_ERR_MEMORY_ERROR;
+ SysTryCatch(NID_MSG, pFilePath != null, r = E_OUT_OF_MEMORY, r, "memory allocation failed");
+
+ msg_mms_add_item(page, MSG_STRUCT_MMS_MEDIA, &media);
+ msg_set_int_value(media, MSG_MMS_MEDIA_TYPE_INT, MMS_SMIL_MEDIA_VIDEO);
+ msg_set_str_value(media, MSG_MMS_MEDIA_REGION_ID_STR, (char *)"Image", 5);
+ msg_set_str_value(media, MSG_MMS_MEDIA_FILEPATH_STR, pFilePath, MSG_FILEPATH_LEN_MAX);
- if (pEmailAddr)
+ delete[] pFilePath;
+ pFilePath = null;
+ }
+ }
+
+ if (isAudio)
+ {
+ filePath = message.GetAttachment(MMS_AUDIO);
+ if (filePath.GetLength())
{
- delete[] pEmailAddr;
- pEmailAddr = null;
+ pFilePath = _StringConverter::CopyToCharArrayN(filePath);
+ err = MSG_ERR_MEMORY_ERROR;
+ SysTryCatch(NID_MSG, pFilePath != null, r = E_OUT_OF_MEMORY, r, "memory allocation failed");
+
+ msg_mms_add_item(page, MSG_STRUCT_MMS_MEDIA, &media);
+ msg_set_int_value(media, MSG_MMS_MEDIA_TYPE_INT, MMS_SMIL_MEDIA_AUDIO);
+ msg_set_str_value(media, MSG_MMS_MEDIA_REGION_ID_STR, (char *)"Audio", 5);
+ msg_set_str_value(media, MSG_MMS_MEDIA_FILEPATH_STR, pFilePath, MSG_FILEPATH_LEN_MAX);
+
+ delete[] pFilePath;
+ pFilePath = null;
}
- SysTryCatch(NID_MSG, err == EMAIL_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "failed to set message address");
+ }
+ if (isText)
+ {
+ pFilePath = _StringConverter::CopyToCharArrayN(bodyTextFilePath);
+ err = MSG_ERR_MEMORY_ERROR;
+ SysTryCatch(NID_MSG, pFilePath != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "memory allocation failed.");
+
+ msg_mms_add_item(page, MSG_STRUCT_MMS_MEDIA, &media);
+ msg_set_int_value(media, MSG_MMS_MEDIA_TYPE_INT, MMS_SMIL_MEDIA_TEXT);
+ msg_set_str_value(media, MSG_MMS_MEDIA_REGION_ID_STR, (char *)"Text", 4);
+ msg_set_str_value(media, MSG_MMS_MEDIA_FILEPATH_STR, pFilePath, MSG_FILEPATH_LEN_MAX);
+
+ msg_get_struct_handle(media, MSG_MMS_MEDIA_SMIL_TEXT_HND, &smilText);
+ msg_set_int_value(smilText, MSG_MMS_SMIL_TEXT_COLOR_INT, 0x000000);
+ msg_set_int_value(smilText, MSG_MMS_SMIL_TEXT_SIZE_INT, MMS_SMIL_FONT_SIZE_NORMAL);
+ msg_set_bool_value(smilText, MSG_MMS_SMIL_TEXT_BOLD_BOOL, false);
+
+ delete[] pFilePath;
+ pFilePath = null;
}
- // deallocate
- if (pRecipientList->GetCount() > 0)
+ //vcard attachment
+ filePath = message.GetAttachment(MMS_VCARD);
+ if (filePath.GetLength())
{
- pRecipientList->RemoveAll(true);
+ pFilePath = _StringConverter::CopyToCharArrayN(filePath);
+ err = MSG_ERR_MEMORY_ERROR;
+ SysTryCatch(NID_MSG, pFilePath != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "memory allocation failed.");
+ msg_mms_add_item(mmsData, MSG_STRUCT_MMS_ATTACH, &mmsAttach);
+ msg_set_str_value(mmsAttach, MSG_MMS_ATTACH_FILEPATH_STR, pFilePath, MSG_FILEPATH_LEN_MAX);
+ delete[] pFilePath;
+ pFilePath = null;
}
- delete pRecipientList;
- pRecipientList = null;
+ //calander attachment
+ filePath = message.GetAttachment(MMS_VCALENDAR);
+ if (filePath.GetLength())
+ {
+ pFilePath = _StringConverter::CopyToCharArrayN(filePath);
+ err = MSG_ERR_MEMORY_ERROR;
+ SysTryCatch(NID_MSG, pFilePath != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "memory allocation failed.");
+ msg_mms_add_item(mmsData, MSG_STRUCT_MMS_ATTACH, &mmsAttach);
+ msg_set_str_value(mmsAttach, MSG_MMS_ATTACH_FILEPATH_STR, pFilePath, MSG_FILEPATH_LEN_MAX);
+ delete[] pFilePath;
+ pFilePath = null;
+ }
+
+ err = msg_set_mms_struct(msgData, mmsData);
+ SysTryCatch(NID_MSG, err == MSG_SUCCESS, r = E_SYSTEM, E_SYSTEM, "failed to set message contents");
+
+ msg_release_struct(&mmsData);
return err;
CATCH:
- SetLastResult(r);
- if (pRecipientList)
+ if (mmsData)
+ {
+ msg_release_struct(&mmsData);
+ }
+ return err;
+}
+
+result
+_MsgUtil::AddEmailMessageAddress(const RecipientList& recipientList, RecipientType type, email_mail_data_t *pMail)
+{
+ String tempRecipient = null;
+ IList* pRecipientList = null;
+ int count = 0;
+ int index = 0;
+ const int zero = 0;
+ result r = E_SUCCESS;
+
+ pRecipientList = (const_cast< RecipientList& >(recipientList)).GetListN(type);
+ SysTryCatch(NID_MSG, pRecipientList != null, r = GetLastResult(), r, "[%s] Failed to get recipient list", GetErrorMessage(r));
+
+ count = pRecipientList->GetCount();
+ SysTryCatch(NID_MSG, count != zero, r = E_SUCCESS , r, "Type[%d] Recipient is empty",type);
+
+ tempRecipient.Append(L"<" + *(dynamic_cast< String* >(pRecipientList->GetAt(index))) + L">");
+ index++;
+
+ for (; index < count; index++)
{
+ tempRecipient.Append(L",<" + *(dynamic_cast< String* >(pRecipientList->GetAt(index))) + L">");
+
+ }
+ if(RECIPIENT_TYPE_TO == type)
+ {
+ pMail->full_address_to = _StringConverter::CopyToCharArrayN(tempRecipient);
+ }
+ else if(RECIPIENT_TYPE_CC == type)
+ {
+ pMail->full_address_cc = _StringConverter::CopyToCharArrayN(tempRecipient);
+
+ }
+ else if( RECIPIENT_TYPE_BCC == type)
+ {
+ pMail->full_address_bcc = _StringConverter::CopyToCharArrayN(tempRecipient);
+ }
+ else
+ {
+ SysLog(NID_MSG, "[%d] Wrong recipeint type", type);
+ r = E_INVALID_ARG;
+ goto CATCH;
+ }
+
if (pRecipientList->GetCount() > 0)
{
pRecipientList->RemoveAll(true);
}
delete pRecipientList;
pRecipientList = null;
+
+ return r;
+
+CATCH:
+ if (pRecipientList->GetCount() > 0)
+ {
+ pRecipientList->RemoveAll(true);
}
+ delete pRecipientList;
+ pRecipientList = null;
+
+ return r;
- return err;
}
int
-_MsgUtil::AddMessageAddress(const RecipientList& recipientList, RecipientType type, messages_message_h& messageMsg, messages_recipient_type_e recipientType)
+_MsgUtil::AddMessageAddress(const RecipientList& recipientList, RecipientType type, msg_struct_t& messageMsg, _MSG_RECIPIENT_TYPE_E recipientType)
{
String* pTempRecipient = null;
IList* pRecipientList = null;
char* pPhoneNum = null;
int count = 0;
- int err = MESSAGES_ERROR_NONE;
+ int msgType = -1;
+ int err = MSG_SUCCESS;
result r = E_SUCCESS;
pRecipientList = (const_cast< RecipientList& >(recipientList)).GetListN(type);
goto CATCH;
}
+ err = msg_get_int_value(messageMsg, MSG_MESSAGE_TYPE_INT, &msgType);
+ SysTryCatch(NID_MSG, err == MSG_SUCCESS, r = E_SYSTEM, E_SYSTEM, "failed to get message type");
+
count = pRecipientList->GetCount();
for (int index = 0; index < count; index++)
{
if (!pTempRecipient)
{
r = GetLastResult();
- err = MESSAGES_ERROR_OPERATION_FAILED;
+ err = MSG_ERR_NULL_POINTER;
SysLogException(NID_MSG, r, "[%s] Failed to get a recipient", GetErrorMessage(r));
goto CATCH;
}
pPhoneNum = _StringConverter::CopyToCharArrayN(*pTempRecipient);
- err = messages_add_address(messageMsg, pPhoneNum, recipientType);
+
+ msg_struct_list_s *pAddrList = NULL;
+ msg_struct_t addrInfo = NULL;
+
+ err = msg_get_list_handle(messageMsg, MSG_MESSAGE_ADDR_LIST_STRUCT, (void **)&pAddrList);
+ SysTryCatch(NID_MSG, err == MSG_SUCCESS, r = E_SYSTEM, E_SYSTEM, "failed to get message address handle");
+
+ addrInfo = pAddrList->msg_struct_info[pAddrList->nCount];
+
+ if (msgType == MSG_TYPE_SMS)
+ {
+ msg_set_int_value(addrInfo, MSG_ADDRESS_INFO_RECIPIENT_TYPE_INT, recipientType);
+ }
+ else if (msgType == MSG_TYPE_MMS)
+ {
+ if (strchr(pPhoneNum, '@') == NULL)
+ {
+ msg_set_int_value(addrInfo, MSG_ADDRESS_INFO_ADDRESS_TYPE_INT, MSG_ADDRESS_TYPE_PLMN);
+ }
+ else
+ {
+ msg_set_int_value(addrInfo, MSG_ADDRESS_INFO_ADDRESS_TYPE_INT, MSG_ADDRESS_TYPE_EMAIL);
+ }
+ msg_set_int_value(addrInfo, MSG_ADDRESS_INFO_RECIPIENT_TYPE_INT, recipientType);
+ }
+
+ err = msg_set_str_value(addrInfo, MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, pPhoneNum, strlen(pPhoneNum));
+ SysTryCatch(NID_MSG, err == MSG_SUCCESS, r = E_SYSTEM, E_SYSTEM, "failed to set message address");
+
+ pAddrList->nCount++;
if (pPhoneNum)
{
delete[] pPhoneNum;
pPhoneNum = null;
}
- SysTryCatch(NID_MSG, err == MESSAGES_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "failed to set message address");
-
}
// deallocate
pRecipientList = null;
}
+ if (pPhoneNum)
+ {
+ delete[] pPhoneNum;
+ pPhoneNum = null;
+ }
return err;
}
return concatenatedString;
}
-int
-_MsgUtil::GetMmsMessage(const MmsMessage& message, const RecipientList& recipientList, messages_message_h& mmsMsg)
-{
- int err = MESSAGES_ERROR_NONE;
- result r = E_SUCCESS;
- const char* pSubject = null;
- const char* pMsgBody = null;
- const char* pFilePath = null;
- String filePath;
-
- pSubject = _StringConverter::CopyToCharArrayN(message.GetSubject());
- pMsgBody = _StringConverter::CopyToCharArrayN(message.GetText());
-
- //create new message
- err = messages_create_message(MESSAGES_TYPE_MMS, &mmsMsg);
- SysTryCatch(NID_MSG, err == MESSAGES_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "Insufficient memory");
-
- err = messages_set_text(mmsMsg, pMsgBody);
- SysTryCatch(NID_MSG, err == MESSAGES_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "failed to set mms text");
-
- err = messages_mms_set_subject(mmsMsg, pSubject);
- SysTryCatch(NID_MSG, err == MESSAGES_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "failed to set mms body");
-
- err = AddMessageAddress(recipientList, RECIPIENT_TYPE_TO, mmsMsg, MESSAGES_RECIPIENT_TO);
- SysTryCatch(NID_MSG, err == MESSAGES_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "failed to add To address");
-
- err = AddMessageAddress(recipientList, RECIPIENT_TYPE_CC, mmsMsg, MESSAGES_RECIPIENT_CC);
- SysTryCatch(NID_MSG, err == MESSAGES_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "failed to add Cc address");
-
- err = AddMessageAddress(recipientList, RECIPIENT_TYPE_BCC, mmsMsg, MESSAGES_RECIPIENT_BCC);
- SysTryCatch(NID_MSG, err == MESSAGES_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "failed to add Bcc address");
-
- // populate attachments
- filePath = message.GetAttachment(MMS_IMAGE);
- if (filePath.GetLength())
- {
- pFilePath = _StringConverter::CopyToCharArrayN(filePath);
- err = messages_mms_add_attachment(mmsMsg, MESSAGES_MEDIA_IMAGE, pFilePath);
- delete[] pFilePath;
- pFilePath = null;
- SysTryCatch(NID_MSG, err == MESSAGES_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "mms add attachment failed");
- }
-
- //video attachment
- filePath = message.GetAttachment(MMS_VIDEO);
- if (filePath.GetLength())
- {
- pFilePath = _StringConverter::CopyToCharArrayN(filePath);
- err = messages_mms_add_attachment(mmsMsg, MESSAGES_MEDIA_VIDEO, pFilePath);
- delete[] pFilePath;
- pFilePath = null;
- SysTryCatch(NID_MSG, err == MESSAGES_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "mms add attachment failed");
- }
-
- //audio attachment
- filePath = message.GetAttachment(MMS_AUDIO);
- if (filePath.GetLength())
- {
- pFilePath = _StringConverter::CopyToCharArrayN(filePath);
- err = messages_mms_add_attachment(mmsMsg, MESSAGES_MEDIA_AUDIO, pFilePath);
- delete[] pFilePath;
- pFilePath = null;
- SysTryCatch(NID_MSG, err == MESSAGES_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "mms add attachment failed");
- }
-
- //vcard attachment
- filePath = message.GetAttachment(MMS_VCARD);
- if (filePath.GetLength())
- {
- pFilePath = _StringConverter::CopyToCharArrayN(filePath);
- err = messages_mms_add_attachment(mmsMsg, MESSAGES_MEDIA_UNKNOWN, pFilePath); // Not Suppourted Yet
- delete[] pFilePath;
- pFilePath = null;
- SysTryCatch(NID_MSG, err == MESSAGES_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "mms add attachment failed");
- }
-
- //calander attachment
- filePath = message.GetAttachment(MMS_VCALENDAR);
- if (filePath.GetLength())
- {
- pFilePath = _StringConverter::CopyToCharArrayN(filePath);
- err = messages_mms_add_attachment(mmsMsg, MESSAGES_MEDIA_UNKNOWN, pFilePath); // Not Suppourted Yet
- delete[] pFilePath;
- pFilePath = null;
- SysTryCatch(NID_MSG, err == MESSAGES_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "mms add attachment failed");
- }
-
- if (pMsgBody)
- {
- delete[] pMsgBody;
- pMsgBody = null;
- }
-
- if (pSubject)
- {
- delete[] pSubject;
- pSubject = null;
- }
-
- return err;
-
-CATCH:
-
- if (pMsgBody)
- {
- delete[] pMsgBody;
- pMsgBody = null;
- }
-
- if (pSubject)
- {
- delete[] pSubject;
- pSubject = null;
- }
-
- return err;
-}
-
Tizen::Base::DateTime
_MsgUtil::ConvertTime(time_t* pTime)
{
}
SmsMessage*
-_MsgUtil::ConvertSmsMessageN(const SmsMessageBoxType& type, messages_message_h msg)
+_MsgUtil::ConvertSmsMessageN(const SmsMessageBoxType& type, msg_struct_t& msg)
{
result r = E_SUCCESS;
+ int err = MSG_SUCCESS;
SmsMessage* pSmsMessage = null;
- char* pOriginalText = null;
- char* pBodyText = null;
- char* pMsgAddress = null;
DateTime time;
- time_t tempTime = 0;
+ int msgTime = -1;
bool hasMoreText = false;
- int messageId = 0;
+ int messageId;
String body;
- messages_recipient_type_e recipientType = MESSAGES_RECIPIENT_TO;
const int msgBodyLength = 160;
int originalTextLength = 0;
SysTryCatch(NID_MSG, pSmsMessage != null, r = E_OUT_OF_MEMORY, r, "memory allocation failed");
// message ID
- messages_get_message_id(msg, &messageId);
+ err = msg_get_int_value(msg, MSG_MESSAGE_ID_INT, &messageId);
+
// body text
- messages_get_text(msg, &pOriginalText);
- SysTryCatch(NID_MSG, pOriginalText != null, r = E_SYSTEM, r, "sms get message body failed");
+ char msgText[MAX_MSG_TEXT_LEN];
+ err = msg_get_str_value(msg, MSG_MESSAGE_SMS_DATA_STR, msgText, MAX_MSG_TEXT_LEN);
+ SysTryCatch(NID_MSG, err == MSG_SUCCESS, r = E_SYSTEM, r, "sms get message body failed");
- originalTextLength = strlen(pOriginalText);
+ originalTextLength = strlen(msgText);
if (originalTextLength > msgBodyLength)
{
- pBodyText = (char*) calloc(msgBodyLength + 1, sizeof(char)); // include NULL character
- SysTryCatch(NID_MSG, pBodyText != null, r = E_OUT_OF_MEMORY, r, "memory allocation failed");
- strncpy(pBodyText, pOriginalText, msgBodyLength);
- pBodyText[msgBodyLength] = '\0'; // add NULL character
- free(const_cast< char* >(pOriginalText));
- pOriginalText = null;
+ char msgBodyText[msgBodyLength + 1];
+ memset(msgText, 0, msgBodyLength + 1);
+ strncpy(msgBodyText, msgText, msgBodyLength);
+ body = msgBodyText;
hasMoreText = true;
-
}
else
{
- pBodyText = const_cast< char* >(pOriginalText);
- pOriginalText = null;
+ body = msgText;
}
- body = pBodyText;
-
// received/sent time
- messages_get_time(msg, &tempTime);
- time = _MsgUtil::ConvertTime(&tempTime);
+ err = msg_get_int_value(msg, MSG_MESSAGE_DISPLAY_TIME_INT, &msgTime);
+ time = _MsgUtil::ConvertTime((time_t*) &msgTime);
switch (type)
{
case SMS_MESSAGE_BOX_TYPE_INBOX:
{
// sender address
- messages_get_address(msg, 0, &pMsgAddress, &recipientType);
- SysTryCatch(NID_MSG, pMsgAddress != null, r = E_SYSTEM, r, "sms get message address failed");
- String senderAddress(pMsgAddress);
- free(pMsgAddress);
- pMsgAddress = null;
+ char address[MAX_ADDRESS_VAL_LEN] = {0, };
+ msg_struct_list_s* pAddrList = NULL;
+ msg_struct_t addrInfo = NULL;
+ err = msg_get_list_handle(msg, MSG_MESSAGE_ADDR_LIST_STRUCT, (void **)&pAddrList);
+ addrInfo = pAddrList->msg_struct_info[0];
+ err = msg_get_str_value(addrInfo, MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, address, MAX_ADDRESS_VAL_LEN);
+ String senderAddress(address);
+
_SmsMessageImpl::GetInstance(*pSmsMessage)->SetInboxMessage(messageId, body, hasMoreText, senderAddress, time);
break;
}
case SMS_MESSAGE_BOX_TYPE_SENTBOX:
{
// recipient list
- int recipient_count = 0;
- messages_get_address_count(msg, &recipient_count);
+ char address[MAX_ADDRESS_VAL_LEN] = {0, };
+ msg_struct_list_s* pAddrList = NULL;
+ msg_struct_t addrInfo = NULL;
+ err = msg_get_list_handle(msg, MSG_MESSAGE_ADDR_LIST_STRUCT, (void **)&pAddrList);
+ addrInfo = pAddrList->msg_struct_info[0];
+ int recipient_count = pAddrList->nCount;
RecipientList recipients;
for (int index = 0; index < recipient_count; index++)
{
- messages_get_address(msg, index, &pMsgAddress, &recipientType);
- SysTryCatch(NID_MSG, pMsgAddress != null, r = E_SYSTEM, r, "sms get message address failed");
- String senderAddress(pMsgAddress);
- free(pMsgAddress);
- pMsgAddress = null;
+ addrInfo = pAddrList->msg_struct_info[index];
+ err = msg_get_str_value(addrInfo, MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, address, MAX_ADDRESS_VAL_LEN);
+ String senderAddress(address);
r = recipients.Add(RECIPIENT_TYPE_TO, senderAddress);
}
+
_SmsMessageImpl::GetInstance(*pSmsMessage)->SetSentboxMessage(messageId, body, hasMoreText, recipients, time);
break;
}
case SMS_MESSAGE_BOX_TYPE_OUTBOX:
{
// recipient list
- int recipient_count = 0;
- messages_get_address_count(msg, &recipient_count);
+ char address[MAX_ADDRESS_VAL_LEN] = {0, };
+ msg_struct_list_s* pAddrList = NULL;
+ msg_struct_t addrInfo = NULL;
+ err = msg_get_list_handle(msg, MSG_MESSAGE_ADDR_LIST_STRUCT, (void **)&pAddrList);
+ addrInfo = pAddrList->msg_struct_info[0];
+ int recipient_count = pAddrList->nCount;
RecipientList recipients;
for (int index = 0; index < recipient_count; index++)
{
- messages_get_address(msg, index, &pMsgAddress, &recipientType);
- SysTryCatch(NID_MSG, pMsgAddress != null, r = E_SYSTEM, r, "sms get message address failed");
- String senderAddress(pMsgAddress);
- free(pMsgAddress);
- pMsgAddress = null;
- r = recipients.Add(RECIPIENT_TYPE_TO, senderAddress);
+ addrInfo = pAddrList->msg_struct_info[index];
+ err = msg_get_str_value(addrInfo, MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, address, MAX_ADDRESS_VAL_LEN);
+ String senderAddress(address);
}
+
_SmsMessageImpl::GetInstance(*pSmsMessage)->SetOutboxMessage(messageId, body, hasMoreText, recipients, time);
break;
}
break;
}
- if (pBodyText)
+ return pSmsMessage;
+
+CATCH:
+ if (pSmsMessage)
{
- free(pBodyText);
- pBodyText = null;
+ delete pSmsMessage;
}
- return pSmsMessage;
+ return NULL;
+}
+result
+_MsgUtil::SendEmail(const EmailMessage& message, const RecipientList& recipientList, int &mailId, int &requestId)
+{
+
+//////////////////
+ email_account_t* pAccount = NULL;
+ email_mail_data_t *pMail = null;
+ email_mailbox_t *pMailbox = null;
+ email_attachment_data_t **pAttach=null;
+ int accountId = 0;
+ int err = EMAIL_ERROR_NONE;
+ result r = E_SUCCESS;
+ String fromAddr;
+
+
+ email_service_begin();
+
+ pMail = (email_mail_data_t *)calloc(1,sizeof(email_mail_data_t));
+ SysTryCatch(NID_MSG, pMail != null, r = E_OUT_OF_MEMORY, r, "Insufficient memory");
+
+ pMailbox = (email_mailbox_t *)calloc(1,sizeof(email_mailbox_t));
+ SysTryCatch(NID_MSG, pMailbox != null, r = E_OUT_OF_MEMORY, r, "Insufficient memory");
+
+
+ err = email_load_default_account_id(&accountId);
+ SysTryCatch(NID_MSG, err == EMAIL_ERROR_NONE, r = E_INVALID_ACCOUNT, r, "Account Load is Failed.");
+
+ err = email_get_account(accountId, GET_FULL_DATA, &pAccount);
+ SysTryCatch(NID_MSG, err == EMAIL_ERROR_NONE, r = E_INVALID_ACCOUNT, r, "Account is Failed.");
+
+ fromAddr.Append(L'\"');
+ fromAddr.Append(pAccount->incoming_server_user_name);
+ fromAddr.Append(L"\"<");
+ fromAddr.Append(pAccount->user_email_address);
+ fromAddr.Append(L'>');
+ pMail->full_address_from = _StringConverter::CopyToCharArrayN(fromAddr);
+
+ err = email_get_mailbox_by_mailbox_type(accountId, EMAIL_MAILBOX_TYPE_OUTBOX, &pMailbox);
+ SysTryCatch(NID_MSG, err == EMAIL_ERROR_NONE, r = E_STORAGE_FULL, r, "Account is Failed.");
+
+ //info
+ pMail->account_id = pAccount->account_id;
+ pMail->flags_draft_field = 1;
+ pMail->flags_seen_field = 1;
+ pMail->priority = EMAIL_MAIL_PRIORITY_NORMAL;
+ pMail->mailbox_id = pMailbox->mailbox_id;
+ pMail->mailbox_type = pMailbox->mailbox_type;
+ pMail->attachment_count = 0;
+ pMail->subject = _StringConverter::CopyToCharArrayN(message.GetSubject());
+
+ r = AddEmailMessageBody(pMail,_StringConverter::CopyToCharArrayN(message.GetText()));
+ SysTryReturnResult(NID_MSG, r == E_SUCCESS, r, "[%s] email add body failed", GetErrorMessage(r));
+ r = AddEmailMessageAddress(recipientList, RECIPIENT_TYPE_TO, pMail);
+ SysTryReturnResult(NID_MSG, r == E_SUCCESS, r, "[%s] email add recipient failed", GetErrorMessage(r));
+ r = AddEmailMessageAddress(recipientList, RECIPIENT_TYPE_CC, pMail);
+ SysTryReturnResult(NID_MSG, r == E_SUCCESS, r, "[%s] email add recipient failed", GetErrorMessage(r));
+ r = AddEmailMessageAddress(recipientList, RECIPIENT_TYPE_BCC, pMail);
+ SysTryReturnResult(NID_MSG, r == E_SUCCESS, r, "[%s] email add recipient failed", GetErrorMessage(r));
+
+
+ r = AddEmailMessageAttachment(message, &pAttach, pMail);
+ SysTryReturnResult(NID_MSG, r == E_SUCCESS, r, "[%s] email add recipient failed", GetErrorMessage(r));
+
+
+ if( null != pAttach)
+ {
+ err=email_add_mail(pMail,*pAttach, pMail->attachment_count, NULL, 0);
+ }
+ else
+ {
+ err=email_add_mail(pMail,null, pMail->attachment_count, NULL, 0);
+ }
+
+ r = _MsgUtil::EmailConvertException(err);
+ SysTryReturnResult(NID_MSG, r == E_SUCCESS, r, "To make email body is failed.");
+
+ err = email_send_mail(pMail->mail_id, &requestId);
+ r = _MsgUtil::EmailConvertException(err);
+ SysTryReturnResult(NID_MSG, r == E_SUCCESS, r, "The sent mail is failed.");
+
+ mailId = pMail->mail_id;
+
+ r = AddEmailCallBackToDbus();
+
+ if (pAttach)
+ {
+ if (*pAttach)
+ {
+ for(int i=0 ; i < pMail->attachment_count ; i++)
+ {
+ if(pAttach[i])
+ {
+ if(pAttach[i]->attachment_name)
+ {
+ free(pAttach[i]->attachment_name);
+ }
+ if(pAttach[i]->attachment_path)
+ {
+ free(pAttach[i]->attachment_path);
+ }
+ }
+
+ }
+ free(*pAttach);
+ }
+ free( pAttach);
+
+ }
+ email_free_mail_data(&pMail, 1);
+ email_free_mailbox(&pMailbox, 1);
+ email_service_end();
+
+ return r;
CATCH:
+ if (pAttach)
+ {
+ if (*pAttach)
+ {
+ for(int i=0 ; i < pMail->attachment_count ; i++)
+ {
+ if(pAttach[i])
+ {
+ if(pAttach[i]->attachment_name)
+ {
+ free(pAttach[i]->attachment_name);
+ }
+ if(pAttach[i]->attachment_path)
+ {
+ free(pAttach[i]->attachment_path);
+ }
+ }
- if (pBodyText)
+ }
+ free(*pAttach);
+ }
+ free( pAttach);
+
+ }
+ email_free_mail_data(&pMail, 1);
+ email_free_mailbox(&pMailbox, 1);
+ email_service_end();
+
+ return r;
+
+/////////////
+
+}
+
+result
+_MsgUtil::AddEmailMessageBody(email_mail_data_t *pMail, char * pBody)
+{
+
+ String fileName(L"/tmp/mail.txt");
+ File file;
+ result r = E_SUCCESS;
+ int bodyLen = 0;
+ r = file.Construct(fileName, L"w");
+ if(IsFailed(r))
{
- free(pBodyText);
- pBodyText = null;
+ return E_STORAGE_FULL;
+
+ }
+ if (pBody)
+ {
+ bodyLen = strlen(pBody);
+ if (bodyLen)
+ {
+ r = file.Write(pBody, bodyLen);
+ if(IsFailed(r))
+ {
+ return E_STORAGE_FULL;
+ }
+ }
}
- if (pSmsMessage)
+ pMail->file_path_plain = _StringConverter::CopyToCharArrayN(fileName);
+
+ return E_SUCCESS;
+
+}
+
+result
+_MsgUtil::AddEmailMessageAttachment(const EmailMessage& message, email_attachment_data_t ***pAttach, email_mail_data_t *pMail)
+{
+ Tizen::Base::Collection::IList* pAttachmentList = null;
+ result r = E_SUCCESS;
+ int attachNum = 0 ;
+ email_attachment_data_t *getMemory=null;
+
+ SysTryCatch(NID_MSG, pAttach != null, r = E_OUT_OF_MEMORY, r, "Insufficient memory");
+
+ pAttachmentList = message.GetAttachmentListN();
+ SysTryCatch(NID_MSG, null != pAttachmentList, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] email add attachment failed");
+
+ attachNum = pAttachmentList->GetCount();
+ SysTryCatch(NID_MSG, attachNum > 0, r = E_SUCCESS, E_SUCCESS, "email attachment file does not exist.");
+
+
+ (*pAttach) = (email_attachment_data_t **)calloc( attachNum,sizeof(email_attachment_data_t*));
+ SysTryCatch(NID_MSG, *pAttach != null, r = E_OUT_OF_MEMORY, r, "Insufficient memory");
+
+ getMemory = (email_attachment_data_t *)calloc(attachNum,sizeof(email_attachment_data_t));
+ SysTryCatch(NID_MSG, getMemory != null, r = E_OUT_OF_MEMORY, r, "Insufficient memory");
+
+ for( int index = 0; index < attachNum ; index ++)
{
- delete pSmsMessage;
+ int startIndex = 0;
+ int findIndex = 0;
+ String* pAttachPath = null;
+ String tempString = null;
+ File file;
+ FileAttributes attr;
+
+ pAttachPath = dynamic_cast< String* >(pAttachmentList->GetAt(index));
+ SysTryCatch(NID_MSG, pAttachPath != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] email add attachment failed");
+
+ startIndex = pAttachPath->GetLength()-1;
+ if( E_SUCCESS == pAttachPath->LastIndexOf( L"/", startIndex, findIndex))
+ {
+ pAttachPath->SubString(findIndex+1, tempString);
+ }
+ else
+ {
+ tempString = *pAttachPath;
+ }
+
+ (*pAttach)[index] = getMemory + index;
+ memset((*pAttach)[index], 0 , sizeof(email_attachment_data_t));
+
+ r = File::GetAttributes(*pAttachPath, attr);
+ SysTryCatch(NID_MSG, r == E_SUCCESS , r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] email add attachment failed");
+
+ (*pAttach)[index]->attachment_name = _StringConverter::CopyToCharArrayN(tempString);
+ (*pAttach)[index]->attachment_path = _StringConverter::CopyToCharArrayN(*pAttachPath);
+ (*pAttach)[index]->attachment_size = attr.GetFileSize();
+ (*pAttach)[index]->save_status = 1;
+ pMail->attachment_count = index+1;
+ }
+
+ if (pAttachmentList)
+ {
+ if (pAttachmentList->GetCount() > 0)
+ {
+ pAttachmentList->RemoveAll(true);
+ }
+ delete pAttachmentList;
+ pAttachmentList = null;
}
+ return r;
- return NULL;
+CATCH:
+
+ if (pAttachmentList)
+ {
+ if (pAttachmentList->GetCount() > 0)
+ {
+ pAttachmentList->RemoveAll(true);
+ }
+ delete pAttachmentList;
+ pAttachmentList = null;
+ }
+
+ return r;
+
+}
+
+
+result
+_MsgUtil::AddEmailCallBackToDbus(void)
+{
+
+ DBusConnection* pConnection=NULL;
+ DBusError error = {0};
+ result r = E_SUCCESS;
+ static bool registerDbus = false;
+
+ SysTryCatch(NID_MSG, false == registerDbus ,, E_SUCCESS, "Dbus was already registered");
+
+ dbus_error_init(&error);
+
+ pConnection = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
+ SysTryCatch(NID_MSG, pConnection != null, r = E_STORAGE_FULL, r, "dbus handler is null");
+
+ dbus_connection_setup_with_g_main(pConnection, null);
+ dbus_bus_add_match(pConnection, "path='/User/Email/NetworkStatus',type='signal',interface='User.Email.NetworkStatus'", &error);
+ SysTryCatch(NID_MSG, !dbus_error_is_set(&error) ,dbus_error_free(&error);r = E_STORAGE_FULL, E_STORAGE_FULL, "[E_STORAGE_FULL] Fail to add match : %s",error.message);
+ SysTryCatch(NID_MSG, FALSE != dbus_connection_add_filter(pConnection, EmailNetworkCallBack, NULL, NULL) ,dbus_error_free(&error);r = E_STORAGE_FULL, E_STORAGE_FULL, "[E_STORAGE_FULL] Fail to add match : %s",error.message);
+
+ if (false == registerDbus)
+ {
+ registerDbus = true;
+ SysLog(NID_MSG, "Now. Dbus was registered");
+
+ }
+
+
+ return r;
+
+CATCH:
+
+ return r;
+
+}
+
+DBusHandlerResult
+_MsgUtil::EmailNetworkCallBack(DBusConnection* pConnection, DBusMessage* pMessage, void* pUserData)
+{
+ DBusError error ={0};
+
+ if(dbus_message_is_signal(pMessage, "User.Email.NetworkStatus", "email"))
+ {
+ dbus_error_init(&error);
+ int status=0;
+ int accountId=0;
+ char* fileId=NULL;
+ int mailId=0;
+ int errorCode=0;
+ unsigned int checkDbus;
+ checkDbus = dbus_message_get_args(pMessage, &error,
+ DBUS_TYPE_INT32, &status,
+ DBUS_TYPE_INT32, &accountId,
+ DBUS_TYPE_STRING, &fileId,
+ DBUS_TYPE_INT32, &mailId,
+ DBUS_TYPE_INT32, &errorCode,
+ DBUS_TYPE_INVALID);
+ SysLog(NID_MSG, "Dbus status [%d], msg [%d], err [%d]",status, mailId, errorCode);
+
+ if(checkDbus)
+ {
+ switch (status) {
+ case NOTI_SEND_START:
+ break;
+
+ case NOTI_SEND_FAIL:
+
+ switch(errorCode)
+ {
+ case EMAIL_ERROR_NO_SIM_INSERTED:
+ case EMAIL_ERROR_FLIGHT_MODE:
+ case EMAIL_ERROR_SMTP_SEND_FAILURE:
+ case EMAIL_ERROR_NO_SUCH_HOST:
+ case EMAIL_ERROR_CONNECTION_FAILURE:
+ case EMAIL_ERROR_CONNECTION_BROKEN:
+ case EMAIL_ERROR_INVALID_SERVER:
+ case EMAIL_ERROR_NO_RESPONSE:
+
+ break;
+
+ default:
+ break;
+ }
+ _EmailManagerImpl::SentEmailStatusCallback(mailId, (email_noti_on_network_event)status, errorCode);
+ return DBUS_HANDLER_RESULT_HANDLED;
+ break;
+
+ case NOTI_SEND_FINISH:
+ _EmailManagerImpl::SentEmailStatusCallback(mailId, (email_noti_on_network_event)status, errorCode);
+ return DBUS_HANDLER_RESULT_HANDLED;
+ break;
+
+ default:
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+ }
+ }
+ else
+ {
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ }
+
+ }
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+}
+
+result
+_MsgUtil::EmailConvertException(int err)
+{
+ result r = E_SUCCESS;
+ SysLog(NID_MSG,"Core Error [%d]", err);
+
+ switch (err)
+ {
+ case EMAIL_ERROR_NONE:
+ r = E_SUCCESS;
+ break;
+
+ case EMAIL_ERROR_INVALID_PARAM:
+ r = E_INVALID_ARG;
+ break;
+
+
+ case EMAIL_ERROR_INVALID_ACCOUNT:
+ case EMAIL_ERROR_ACCOUNT_NOT_FOUND:
+ r = E_INVALID_ACCOUNT;
+ break;
+
+ case EMAIL_ERROR_NULL_VALUE:
+ case EMAIL_ERROR_IPC_SOCKET_FAILURE:
+ r = E_ON_INITIALIZING;
+ break;
+
+ case EMAIL_ERROR_DB_FAILURE:
+ case EMAIL_ERROR_OUT_OF_MEMORY:
+ r = E_STORAGE_FULL;
+ break;
+
+ default:
+ r = E_INVALID_CONDITION;
+ break;
+ }
+
+ return r;
}
} } // Tizen::Messaging
projects / platform / framework / native / messaging.git / blobdiff