X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2FFMsg_SmsMmsCallbackHandler.cpp;h=450a8ab85288f0de2b47f65478b75def1e024807;hb=6df7cd727b770f7dc9d46505ef1d55f4b2d932a4;hp=9d44b41cd979160e26d42d99a6e259ca86620bb3;hpb=99006b32cdbd042dbd5bdd9984914a61f6cae600;p=platform%2Fframework%2Fnative%2Fmessaging.git

diff --git a/src/FMsg_SmsMmsCallbackHandler.cpp b/src/FMsg_SmsMmsCallbackHandler.cpp
index 9d44b41..450a8ab 100644
--- a/src/FMsg_SmsMmsCallbackHandler.cpp
+++ b/src/FMsg_SmsMmsCallbackHandler.cpp
@@ -21,17 +21,23 @@
  * This file contains the implementation of the %_SmsMmsCallbackHandler class.
  */
 
-#include <messages.h>
-#include <email.h>
+#include <msg.h>
+#include <msg_transport.h>
+#include <msg_storage.h>
+#include <dbus/dbus.h>
+#include <email-api.h>
+#include <FMsgSmsManager.h>
 #include <FBaseInteger.h>
 #include <FBaseSysLog.h>
 #include <FMsgEtwsPrimaryNotification.h>
+#include <FBase_StringConverter.h>
 #include "FMsg_SmsEvent.h"
 #include "FMsg_SmsEventArg.h"
 #include "FMsg_MmsEvent.h"
 #include "FMsg_MmsEventArg.h"
 #include "FMsg_MsgUtil.h"
 #include "FMsg_SmsMmsCallbackHandler.h"
+#include "FMsg_CbsChannelImpl.h"
 
 using namespace Tizen::Base;
 using namespace Tizen::Base::Collection;
@@ -45,39 +51,93 @@ _SmsMmsCallbackHandler* _SmsMmsCallbackHandler::__pMessageCallbackHandler = 0;
 _SmsMmsCallbackHandler::_SmsMmsCallbackHandler(void)
 	: __msgHandle(0)
 	, __cbsSettingsHandle(0)
+	, __pCbsChannelList(0)
+	, __pTempCbsChannelList(0)
+	, __callbackRegistered(false)
+	, __incomingSmsCallbackRegistered(true)
+	, __pCbsUserEvent(null)
+	, __pEtwsUserEvent(null)
 {
+}
+
+result
+_SmsMmsCallbackHandler::Construct()
+{
+	result r = E_SUCCESS;
+
+	r = __messageMap.Construct();
 
+	if (r == E_SUCCESS)
+	{
+		r = __msgMutex.Create();
+	}
+
+	return r;
 }
 
 _SmsMmsCallbackHandler::~_SmsMmsCallbackHandler(void)
 {
 	if (__msgHandle)
 	{
-		messages_close_service(__msgHandle);
+		msg_close_msg_handle(&__msgHandle);
 		__msgHandle = 0;
 	}
 
+	if (__messageMap.GetCount())
+	{
+		__messageMap.RemoveAll(true);
+	}
+
+	if (__cbsSettingsHandle)
+	{
+		msg_release_struct(&__cbsSettingsHandle);
+		__cbsSettingsHandle = 0;
+	}
+
+	if (__pTempCbsChannelList)
+	{
+		if (__pTempCbsChannelList->GetCount() > 0)
+		{
+			__pTempCbsChannelList->RemoveAll(true);
+		}
+		delete __pTempCbsChannelList;
+		__pTempCbsChannelList = null;
+	}
 }
 
 _SmsMmsCallbackHandler*
 _SmsMmsCallbackHandler::GetInstance(void)
 {
+	result r = E_SUCCESS;
+
 	if (!__pMessageCallbackHandler)
 	{
 		__pMessageCallbackHandler = new (std::nothrow) _SmsMmsCallbackHandler();
+                SysTryReturn(NID_MSG, __pMessageCallbackHandler != NULL, null, E_SYSTEM, "failed to create instance");
+
+		if (__pMessageCallbackHandler)
+		{
+			r = __pMessageCallbackHandler->Construct();
+
+			if (r != E_SUCCESS)
+			{
+				delete __pMessageCallbackHandler;
+				 __pMessageCallbackHandler = 0;
+			}
+		}
 	}
 
 	return __pMessageCallbackHandler;
 }
 
 int
-_SmsMmsCallbackHandler::OpenMessageHandle(messages_service_h& messageHandle)
+_SmsMmsCallbackHandler::OpenMessageHandle(msg_handle_t& messageHandle)
 {
-	int err = MESSAGES_ERROR_NONE;
+	int err = MSG_SUCCESS;
 
 	if (!__msgHandle)
 	{
-		err = messages_open_service(&__msgHandle);
+		err = msg_open_msg_handle(&__msgHandle);
 	}
 
 	messageHandle = __msgHandle;
@@ -85,220 +145,706 @@ _SmsMmsCallbackHandler::OpenMessageHandle(messages_service_h& messageHandle)
 }
 
 int
-_SmsMmsCallbackHandler::OpenCbsSettingsHandle(messages_cb_settings_h& cbsSettingsHandle)
+_SmsMmsCallbackHandler::OpenCbsSettingsHandle(msg_struct_t& cbsSettingsHandle)
 {
-	int err = MESSAGES_ERROR_NONE;
+	int err = MSG_SUCCESS;
 
 	if (!__cbsSettingsHandle)
 	{
-		err = messages_cb_load_settings(__msgHandle, &__cbsSettingsHandle);
+		__cbsSettingsHandle = msg_create_struct(MSG_STRUCT_SETTING_CB_OPT);
+		if (__cbsSettingsHandle && __msgHandle)
+		{
+			err = msg_get_cb_opt(__msgHandle, __cbsSettingsHandle);
+		}
 	}
 
 	cbsSettingsHandle = __cbsSettingsHandle;
 	return err;
 }
 
-int
-_SmsMmsCallbackHandler::CloseMessageHandle()
+result
+_SmsMmsCallbackHandler::AddCbsChannel(int from, int to, Tizen::Base::String& name, bool activate)
 {
-	int err = MESSAGES_ERROR_NONE;
+	int err = MSG_SUCCESS;
+	result r = E_SUCCESS;
+	CbsChannel* pCbsChannel = NULL;
 
-	if (__msgHandle)
+	pCbsChannel = _CbsChannelImpl::GetCbsChannelN(from, to, name);
+	SysTryReturn(NID_MSG, pCbsChannel != null, r = E_SYSTEM, E_SYSTEM, "Failed to get the channel.");
+
+	if (activate)
 	{
-		err = messages_close_service(__msgHandle);
-		__msgHandle = 0;
+		_CbsChannelImpl::GetInstance(*pCbsChannel)->SetCbsChannelState(activate);
 	}
 
-	return err;
+	r =__pTempCbsChannelList->Add(*pCbsChannel);
+
+	err = SaveCbsSettings();
+	r = ConvertException(err);
+
+	return r;
 }
 
-void
-_SmsMmsCallbackHandler::SentSmsMessageStatusCallback(messages_sending_result_e status, void* pUserEvent)
+result
+_SmsMmsCallbackHandler::RemoveCbsChannel(int from, int to)
 {
+	int err = MSG_SUCCESS;
 	result r = E_SUCCESS;
-	_SmsEvent* pSmsEvent = static_cast <_SmsEvent*>(pUserEvent);
-	_SmsEventArg* pSmsEventArg = null;
+	int fromId = 0;
+	int toId = 0;
+	bool channelFound = false;
+	CbsChannel* pCbsChannel = NULL;
+
+	for (int index = 0; index < __pTempCbsChannelList->GetCount(); index++)
+	{
+		pCbsChannel = dynamic_cast< Tizen::Messaging::CbsChannel* >(__pTempCbsChannelList->GetAt(index));
+		SysTryReturn(NID_MSG, pCbsChannel != null, r = E_SYSTEM, E_SYSTEM, "Failed to get the channel.");
+
+		pCbsChannel->GetRange(fromId, toId);
+		if (from == fromId && to == toId)
+		{
+			channelFound = true;  // found channel to be removed.
+			__pTempCbsChannelList->RemoveAt(index);
 
-	SysLog(NID_MSG, "SMS message sent status[%d]", status);
+			err = SaveCbsSettings();
+			r = ConvertException(err);
+			delete pCbsChannel;
+			break;
+		}
+	}
 
-	switch (status)
+        if (!channelFound)
 	{
-	case MESSAGES_SENDING_SUCCEEDED:      // Message is sent successfully
-		SysLog(NID_MSG, "MESSAGES_SENDING_SUCCEEDED -> E_SUCCESS");
-		r = E_SUCCESS;
-		break;
+		return E_OBJ_NOT_FOUND;
+	}
 
-	case MESSAGES_SENDING_FAILED:         // Message is not sending
-		SysLog(NID_MSG, "MESSAGES_SENDING_FAILED -> E_FAILURE");
-		r = E_FAILURE;
-		SysLog(NID_MSG, "Failed to send the SMS message. error cause: Message is not sending");
-		break;
+	return r;
+}
 
-	default:
-		SysLog(NID_MSG, "default -> E_FAILURE");
-		r = E_FAILURE;
-		SysLog(NID_MSG, "Failed to send the SMS message. error cause: Unknown");
-		break;
+result
+_SmsMmsCallbackHandler::SearchCbsChannel(int from, int to, int& index)
+{
+	result r = E_SUCCESS;
+	int fromId = 0;
+	int toId = 0;
+	bool channelFound = false;
+	CbsChannel* pCbsChannel = NULL;
+
+	for (int tempIndex = 0; tempIndex < __pTempCbsChannelList->GetCount(); tempIndex++)
+	{
+		pCbsChannel = dynamic_cast< Tizen::Messaging::CbsChannel* >(__pTempCbsChannelList->GetAt(tempIndex));
+		SysTryReturn(NID_MSG, pCbsChannel != null, r = E_SYSTEM, E_SYSTEM, "Failed to get the channel.");
+
+		pCbsChannel->GetRange(fromId, toId);
+		if (from == fromId && to == toId)
+		{
+			channelFound = true;
+			index = tempIndex;
+			break;  // found channel to be searched.
+		}
 	}
 
-	if (pSmsEvent)
+        if (!channelFound)
 	{
-		pSmsEventArg = new (std::nothrow) _SmsEventArg(r);
-		if (pSmsEventArg)
+		return E_OBJ_NOT_FOUND;
+	}
+
+	return r;
+}
+
+result
+_SmsMmsCallbackHandler::UpdateCbsChannel(int from, int to, Tizen::Base::String name, bool activate)
+{
+	int err = MSG_SUCCESS;
+	result r = E_SUCCESS;
+	int fromId = 0;
+	int toId = 0;
+	bool channelFound = false;
+	CbsChannel* pCbsChannel = NULL;
+
+	for (int index = 0; index < __pTempCbsChannelList->GetCount(); index++)
+	{
+		pCbsChannel = dynamic_cast< Tizen::Messaging::CbsChannel* >(__pTempCbsChannelList->GetAt(index));
+		SysTryReturn(NID_MSG, pCbsChannel != null, r = E_SYSTEM, E_SYSTEM, "Failed to get the channel.");
+
+		pCbsChannel->GetRange(fromId, toId);
+		if (from == fromId && to == toId)
 		{
-			pSmsEvent->Fire(*pSmsEventArg);
+			channelFound = true;
+			break;  // found channel to be updated.
+		}
+	}
+
+        if (!channelFound)
+	{
+		return E_OBJ_NOT_FOUND;
+	}
+
+	// set cbs channel name
+	_CbsChannelImpl::GetInstance(*pCbsChannel)->SetCbsChannelName(name);
+
+	if (activate)
+	{
+		_CbsChannelImpl::GetInstance(*pCbsChannel)->SetCbsChannelState(activate);
+	}
+	else
+	{
+		_CbsChannelImpl::GetInstance(*pCbsChannel)->SetCbsChannelState(false);
+	}
+
+	err = SaveCbsSettings();
+	r = ConvertException(err);
+	return r;
+}
+
+result
+_SmsMmsCallbackHandler::GetCbsChannel(int index, int& from, int& to, Tizen::Base::String& name, bool& activate)
+{
+	result r = E_SUCCESS;
+	CbsChannel* pCbsChannel = NULL;
+
+	pCbsChannel = dynamic_cast< Tizen::Messaging::CbsChannel* >(__pTempCbsChannelList->GetAt(index));
+	SysTryReturn(NID_MSG, pCbsChannel != null, r = E_SYSTEM, E_SYSTEM, "Failed to get the channel.");
+
+	pCbsChannel->GetRange(from, to);
+	name = pCbsChannel->GetName();
+	if (pCbsChannel->IsActivated())
+	{
+		activate = true;
+	}
+	else
+	{
+		activate = false;
+	}
+	return r;
+}
+
+result
+_SmsMmsCallbackHandler::GetCbsChannelsCount(int& count)
+{
+	result r = E_SUCCESS;
+
+	if (__pTempCbsChannelList)
+	{
+		count = __pTempCbsChannelList->GetCount();
+	}
+
+	return r;
+}
+
+result
+_SmsMmsCallbackHandler::SaveCbsSettings()
+{
+	int err = MSG_SUCCESS;
+	result r = E_SUCCESS;
+	int fromId = 0;
+	int toId = 0;
+	bool isChannelActive = false;
+	String channelName;
+	char* pTempChannelName = null;
+
+	SysTryReturn(NID_MSG, __pTempCbsChannelList != null, r = E_SYSTEM, E_SYSTEM, "Failed to save the channel.");
+	err = msg_get_list_handle(__cbsSettingsHandle, MSG_CB_CHANNEL_LIST_STRUCT, (void **)&__pCbsChannelList);
+
+	// save Channel List
+	for (int index = 0; index < __pTempCbsChannelList->GetCount(); index++)
+	{
+		Tizen::Messaging::CbsChannel* pCbsChannel = dynamic_cast< Tizen::Messaging::CbsChannel* >(__pTempCbsChannelList->GetAt(index));
+		SysTryReturn(NID_MSG, pCbsChannel != null, r = E_SYSTEM, E_SYSTEM, "Failed to get the channel.");
+		pCbsChannel->GetRange(fromId, toId);
+		channelName = pCbsChannel->GetName();
+		if (pCbsChannel->IsActivated())
+		{
+			isChannelActive = true;
+		}
+
+		pTempChannelName = _StringConverter::CopyToCharArrayN(channelName);
+		SysTryReturn(NID_MSG, pTempChannelName != null, r = E_OUT_OF_MEMORY, r, "Memory allocation failed.");
+
+		msg_set_bool_value(__pCbsChannelList->msg_struct_info[index], MSG_CB_CHANNEL_ACTIVATE_BOOL, isChannelActive);
+		msg_set_int_value(__pCbsChannelList->msg_struct_info[index], MSG_CB_CHANNEL_ID_FROM_INT, fromId);
+		msg_set_int_value(__pCbsChannelList->msg_struct_info[index], MSG_CB_CHANNEL_ID_TO_INT, toId);
+		msg_set_str_value(__pCbsChannelList->msg_struct_info[index], MSG_CB_CHANNEL_NAME_STR,
+					 pTempChannelName,CB_CHANNEL_NAME_MAX);
+
+		if (pTempChannelName)
+		{
+			delete[] pTempChannelName;
+			pTempChannelName = null;
 		}
 	}
+
+	err = msg_set_cb_opt(__msgHandle, __cbsSettingsHandle);
+	r = ConvertException(err);
+	return r;
 }
 
-void
-_SmsMmsCallbackHandler::SentMmsMessageStatusCallback(messages_sending_result_e status, void* pUserEvent)
+result
+_SmsMmsCallbackHandler::LoadCbsSettings()
 {
+	int err = MSG_SUCCESS;
 	result r = E_SUCCESS;
-	_MmsEvent* pMmsEvent = static_cast <_MmsEvent*>(pUserEvent);
-	_MmsEventArg* pMmsEventArg = null;
+	CbsChannel* pCbsChannel = NULL;
+	int fromId = 0;
+	int toId = 0;
+	bool isChannelActive = false;
+	char channelName[CB_CHANNEL_NAME_MAX + 1] = {0,};
 
-	SysLog(NID_MSG, "MMS message sent status[%d]", status);
+	__pTempCbsChannelList = new (std::nothrow) ArrayList();
+	SysTryCatch(NID_MSG, __pTempCbsChannelList != null, r = E_OUT_OF_MEMORY, r, "memory allocation failed");
 
-	switch (status)
+	// make a list
+	r = __pTempCbsChannelList->Construct();
+	SysTryCatch(NID_MSG, r == E_SUCCESS, , r, "Failed to construct an ArrayList");
+
+	if (__cbsSettingsHandle)
 	{
-	case MESSAGES_SENDING_SUCCEEDED:      // Message is sent successfully
-		SysLog(NID_MSG, "MESSAGES_SENDING_SUCCEEDED -> E_SUCCESS");
-		r = E_SUCCESS;
-		break;
+		// Load Channel List
+		err = msg_get_list_handle(__cbsSettingsHandle, MSG_CB_CHANNEL_LIST_STRUCT, (void **)&__pCbsChannelList);
+		for (int index = 0; index < __pCbsChannelList->nCount; index++)
+		{
+			msg_get_bool_value(__pCbsChannelList->msg_struct_info[index], MSG_CB_CHANNEL_ACTIVATE_BOOL, &isChannelActive);
+			msg_get_int_value(__pCbsChannelList->msg_struct_info[index], MSG_CB_CHANNEL_ID_FROM_INT, &fromId);
+			msg_get_int_value(__pCbsChannelList->msg_struct_info[index], MSG_CB_CHANNEL_ID_TO_INT, &toId);
+			msg_get_str_value(__pCbsChannelList->msg_struct_info[index], MSG_CB_CHANNEL_NAME_STR,
+						 channelName,CB_CHANNEL_NAME_MAX);
+
+			pCbsChannel = _CbsChannelImpl::GetCbsChannelN(fromId, toId, String(channelName));
+			SysTryCatch(NID_MSG, pCbsChannel != null, r = E_SYSTEM, r, "Failed to get the channel.");
+			if (isChannelActive)
+			{
+				_CbsChannelImpl::GetInstance(*pCbsChannel)->SetCbsChannelState(isChannelActive);
+			}
+			__pTempCbsChannelList->Add(*pCbsChannel);
+		}
+	}
 
-	case MESSAGES_SENDING_FAILED:         // Message is not sending
-		SysLog(NID_MSG, "MESSAGES_SENDING_SUCCEEDED -> E_FAILURE");
-		r = E_FAILURE;
-		break;
+	r = ConvertException(err);
+	return r;
 
-	default:
-		SysLog(NID_MSG, "default -> E_FAILURE");
-		r = E_FAILURE;
-		break;
+CATCH:
+	if (__pTempCbsChannelList)
+	{
+		if (__pTempCbsChannelList->GetCount() > 0)
+		{
+			__pTempCbsChannelList->RemoveAll(true);
+		}
+		delete __pTempCbsChannelList;
+		__pTempCbsChannelList = null;
+	}
+
+	return r;
+}
+
+int
+_SmsMmsCallbackHandler::RegisterMessageCallback()
+{
+	int err = MSG_SUCCESS;
+
+	if (__msgHandle && !__callbackRegistered)
+	{
+		err = msg_reg_sent_status_callback(__msgHandle, &_SmsMmsCallbackHandler::SentMessageStatusCallback, null);
+		__callbackRegistered = true;
+	}
+
+	return err;
+}
+
+int
+_SmsMmsCallbackHandler::CloseMessageHandle()
+{
+	int err = MSG_SUCCESS;
+
+	if (__msgHandle)
+	{
+		err = msg_close_msg_handle(&__msgHandle);
+		__msgHandle = 0;
+	}
+
+	return err;
+}
+
+int
+_SmsMmsCallbackHandler::CloseCbsSettingsHandle()
+{
+	int err = MSG_SUCCESS;
+
+	if (__cbsSettingsHandle)
+	{
+		err = msg_release_struct(&__cbsSettingsHandle);
+		__cbsSettingsHandle = 0;
 	}
 
-	if (pMmsEvent)
+	if (__pTempCbsChannelList)
 	{
-		pMmsEventArg = new (std::nothrow) _MmsEventArg(r);
-		if (pMmsEventArg)
+		if (__pTempCbsChannelList->GetCount() > 0)
 		{
-			pMmsEvent->Fire(*pMmsEventArg);
+			__pTempCbsChannelList->RemoveAll(true);
 		}
+		delete __pTempCbsChannelList;
+		__pTempCbsChannelList = null;
 	}
+
+	return err;
 }
 
 void
-_SmsMmsCallbackHandler::IncomingSmsMessageCallback(messages_message_h incomingMsg, void* pUserParam)
+_SmsMmsCallbackHandler::SetInComingSmsCallback(bool incomingSmsCallbackRegistered)
 {
-	_SmsEvent* pSmsEvent = static_cast <_SmsEvent*>(pUserParam);
-	_SmsEventArg* pSmsEventArg = null;
-	char* pMsgBody = null;
-	char* pMsgAddress = null;
-	time_t tempReceivedTime = 0;
-	int port = 0;
-	DateTime receivedTime;
-	messages_recipient_type_e recipientType = MESSAGES_RECIPIENT_TO;
+	__incomingSmsCallbackRegistered = incomingSmsCallbackRegistered;
+}
+
+void
+_SmsMmsCallbackHandler::SetCbsAndEtwsUserEvent(_MessageType msgType, Tizen::Base::Object* pEvent)
+{
+	if (msgType == _MSG_CBS)
+	{
+		__pCbsUserEvent = pEvent;
+	}
+	else
+	{
+		__pEtwsUserEvent = pEvent;
+	}
+}
 
-	messages_get_text(incomingMsg, &pMsgBody);
-	messages_get_time(incomingMsg, &tempReceivedTime);   // get msg time
-	messages_get_message_port(incomingMsg, &port);   // get port number
-	messages_get_address(incomingMsg, 0, &pMsgAddress, &recipientType);
+result
+_SmsMmsCallbackHandler::AddToMessageMap(int reqId, _MessageType msgType, Tizen::Base::Object* pEvent)
+{
+	result r = E_SUCCESS;
 
-	String message(pMsgBody);       // porting char* to String
-	String senderAddress(pMsgAddress);
+	Integer* pReqId = new (std::nothrow) Integer(reqId);
+	SysTryReturn(NID_MSG, pReqId != null, E_OUT_OF_MEMORY, r = E_OUT_OF_MEMORY, "memory allocation failed.");
+	Integer* pMsgType = new (std::nothrow) Integer(msgType);
+	SysTryReturn(NID_MSG, pMsgType != null, E_OUT_OF_MEMORY, r = E_OUT_OF_MEMORY, "memory allocation failed.");
 
-	receivedTime = _MsgUtil::ConvertTime(&tempReceivedTime);
+	__msgMutex.Acquire();
 
-	SysLog(NID_MSG, "incoming sms msg_body: [%s]", pMsgBody);
-	SysLog(NID_MSG, "incoming sms port: [%d]", port);
-	SysLog(NID_MSG, "incoming sms received time: [%s]", ctime(&tempReceivedTime));
+	r = __messageMap.Add(*pReqId, *pMsgType);
+	r = __messageMap.Add(*pReqId, *pEvent);
 
-	free(pMsgBody);
-	pMsgBody = null;
-	free(pMsgAddress);
-	pMsgAddress = null;
+	__msgMutex.Release();
 
-	if (pSmsEvent)
+	return r;
+}
+
+result
+_SmsMmsCallbackHandler::GetAndRemoveFromMessageMap(int reqId, _MessageType& msgType, Tizen::Base::Object** pUserEvent)
+{
+	result r = E_SUCCESS;
+
+	Integer* pReqId = new (std::nothrow) Integer(reqId);
+	SysTryReturn(NID_MSG, pReqId != null, E_OUT_OF_MEMORY, r = E_OUT_OF_MEMORY, "memory allocation failed.");
+	Integer* pKey = null;
+	Integer* pMsgType = null;
+	Tizen::Base::Object* pEvent = null;
+	IEnumerator* pValueEnum = null;
+	IMapEnumerator* pMapEnum = null;
+
+	__msgMutex.Acquire();
+
+	pValueEnum = __messageMap.GetValuesN(*pReqId);
+
+	if (pValueEnum)
 	{
-		if (port == 0)  // normal incoming SMS message case
+		if (pValueEnum->MoveNext() == E_SUCCESS)
 		{
-			pSmsEventArg = new (std::nothrow) _SmsEventArg(message, senderAddress, receivedTime);
-			SysTryReturnVoidResult(NID_MSG, pSmsEventArg != null, E_OUT_OF_MEMORY, "memory allocation failed.");
+			pMsgType = static_cast <Integer*>(pValueEnum->GetCurrent());
+
+			if (pValueEnum->MoveNext() == E_SUCCESS)
+			{
+				pEvent = static_cast <Tizen::Base::Object*>(pValueEnum->GetCurrent());
+			}
 		}
-		else			// SMS trigger message case
+	}
+
+	*pUserEvent = pEvent;
+
+	if (pMsgType)
+	{
+		if (pMsgType->ToInt() == _MSG_SMS)
 		{
-			pSmsEventArg = new (std::nothrow) _SmsEventArg(port, receivedTime, message);
-			SysTryReturnVoidResult(NID_MSG, pSmsEventArg != null, E_OUT_OF_MEMORY, "memory allocation failed.");
+			msgType = _MSG_SMS;
 		}
+		else
+		{
+			msgType = _MSG_MMS;
+		}
+	}
 
-		pSmsEvent->Fire(*pSmsEventArg);
+	//Manually getting and deleting the key value
+	pMapEnum = __messageMap.GetMapEnumeratorN();
+
+	if (pMapEnum)
+	{
+		while (pMapEnum->MoveNext() == E_SUCCESS)
+		{
+			pKey = static_cast <Integer*>(pMapEnum->GetKey());
+			if (pKey)
+			{
+				if (!(pKey->CompareTo(*pReqId)))
+				{
+					break;
+				}
+			}
+		}
+	}
+
+	r = __messageMap.Remove(*pReqId, false);
+
+	delete pMapEnum;
+	delete pValueEnum;
+	delete pMsgType;
+	delete pReqId;
+	delete pKey;
+
+	__msgMutex.Release();
+
+	return r;
+}
+
+void
+_SmsMmsCallbackHandler::SentMessageStatusCallback(msg_handle_t hMsgHandle, msg_struct_t msgStatus, void* pUserParam)
+{
+	result r = E_SUCCESS;
+	_MessageType msgType = (_MessageType) -1;
+	Tizen::Base::Object* pUserEvent = null;
+	int status = MSG_NETWORK_SEND_FAIL;
+	int reqId = 0;
+
+	msg_get_int_value(msgStatus, MSG_SENT_STATUS_REQUESTID_INT, &reqId);
+	msg_get_int_value(msgStatus, MSG_SENT_STATUS_NETWORK_STATUS_INT, &status);
+
+	_SmsMmsCallbackHandler::GetInstance()->GetAndRemoveFromMessageMap(reqId, msgType, &pUserEvent);
+
+	SysLog(NID_MSG, "hMsgHandle[%d]", hMsgHandle);
+	SysLog(NID_MSG, "req[%d]", reqId);
+	SysLog(NID_MSG, "msgType[%d]", msgType);
+	SysLog(NID_MSG, "pUserEvent[%d]", pUserEvent);
+
+	if (status == MSG_NETWORK_SEND_SUCCESS)
+	{
+		r = E_SUCCESS;
+		SysLog(NID_MSG, "Message is sent successfully");
+	}
+	else
+	{
+		r = E_FAILURE;
+		SysLog(NID_MSG, "Failed to send the message. error cause: Message is not sending");
+	}
+
+	if (msgType == _MSG_SMS)
+	{
+		_SmsEvent* pSmsEvent = dynamic_cast <_SmsEvent*>(pUserEvent);
+		_SmsEventArg* pSmsEventArg = null;
+
+		if (pSmsEvent)
+		{
+			pSmsEventArg = new (std::nothrow) _SmsEventArg(r);
+			if (pSmsEventArg)
+			{
+				pSmsEvent->Fire(*pSmsEventArg);
+			}
+		}
+	}
+	else
+	{
+		if (msgType == _MSG_MMS)
+        	{
+			_MmsEvent* pMmsEvent = dynamic_cast <_MmsEvent*>(pUserEvent);
+			_MmsEventArg* pMmsEventArg = null;
+
+				if (pMmsEvent)
+				{
+					pMmsEventArg = new (std::nothrow) _MmsEventArg(r);
+						if (pMmsEventArg)
+						{
+							pMmsEvent->Fire(*pMmsEventArg);
+						}
+				}
+		}
 	}
+
 }
 
 void
-_SmsMmsCallbackHandler::IncomingCbsMessageCallback(messages_cb_message_h incomingMsg, void* pUserParam)
+_SmsMmsCallbackHandler::IncomingSmsMessageCallback(msg_handle_t hMsgHandle, msg_struct_t newMsg, void* pUserParam)
 {
 	_SmsEvent* pSmsEvent = static_cast <_SmsEvent*>(pUserParam);
 	_SmsEventArg* pSmsEventArg = null;
-	char* pMsgBody = null;
-	time_t tempReceivedTime = 0;
+
+	int msgSize = 0;
+	msg_get_int_value(newMsg, MSG_MESSAGE_DATA_SIZE_INT, &msgSize);
+	char msgText[msgSize + 1];
+	memset(msgText, 0, msgSize + 1);
+	msg_get_str_value(newMsg, MSG_MESSAGE_SMS_DATA_STR, msgText, msgSize);
+	String message(msgText);
+
+	int port = -1;
+	msg_get_int_value(newMsg, MSG_MESSAGE_DEST_PORT_INT, &port);
+
+	int displayTime = -1;
+	msg_get_int_value(newMsg, MSG_MESSAGE_DISPLAY_TIME_INT, &displayTime);
+	DateTime receivedTime = _MsgUtil::ConvertTime((time_t *) &displayTime);
+
+	char address[MAX_ADDRESS_VAL_LEN] = {0, };
+	msg_struct_list_s* pAddrList = NULL;
+	msg_struct_t addrInfo = NULL;
+	msg_get_list_handle(newMsg, MSG_MESSAGE_ADDR_LIST_STRUCT, (void **)&pAddrList);
+	addrInfo = pAddrList->msg_struct_info[0];
+	msg_get_str_value(addrInfo, MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, address, MAX_ADDRESS_VAL_LEN);
+	String senderAddress(address);
+
+	SysLog(NID_MSG, "hMsgHandle: [%d]", hMsgHandle);
+	SysLog(NID_MSG, "msg_body: [%s]", msgText);
+	SysLog(NID_MSG, "port: [%d]", port);
+	//SysLog(NID_MSG, "received time: [%s]", ctime(pReceivedTime));
+
+	if (_SmsMmsCallbackHandler::GetInstance()->__incomingSmsCallbackRegistered)
+	{
+		if (pSmsEvent)
+		{
+			if (port == 0)  // normal incoming SMS message case
+			{
+				pSmsEventArg = new (std::nothrow) _SmsEventArg(message, senderAddress, receivedTime);
+			        SysTryReturnVoidResult(NID_MSG, pSmsEventArg != null, E_OUT_OF_MEMORY, "memory allocation failed.");
+			}
+			else            // SMS trigger message case
+			{
+				pSmsEventArg = new (std::nothrow) _SmsEventArg(port, receivedTime, message, senderAddress);
+			        SysTryReturnVoidResult(NID_MSG, pSmsEventArg != null, E_OUT_OF_MEMORY, "memory allocation failed.");
+			}
+			pSmsEvent->Fire(*pSmsEventArg);
+		}
+	}
+}
+
+void
+_SmsMmsCallbackHandler::IncomingCbsMessageCallback(msg_handle_t hMsgHandle, msg_struct_t newMsg, void* pUserParam)
+{
+	_SmsEventArg* pSmsEventArg = null;
+	int tempReceivedTime = 0;
 	DateTime receivedTime;
 	bool etwsNotifiation = false;
 	int messgeId = 0;
 	int serialNumber = 0;
 	int length = 0;
-	int dataCodingScheme = 0;
-	messages_message_type_e cbsType;
+	int cbsType = -1;
 	Tizen::Base::ByteBuffer msgSerialNumber;
 
-	messages_cb_get_text(incomingMsg, &pMsgBody);
-	messages_cb_get_time(incomingMsg, &tempReceivedTime);
-	messages_cb_get_message_id(incomingMsg, &messgeId);
-	messages_cb_get_serial_number(incomingMsg, &serialNumber);
-	messages_cb_get_message_type(incomingMsg, &cbsType);
-	messages_cb_get_dcs(incomingMsg, &dataCodingScheme);
+	msg_get_int_value(newMsg, MSG_CB_MSG_RECV_TIME_INT, &tempReceivedTime);
+	receivedTime = _MsgUtil::ConvertTime((time_t *) &tempReceivedTime);
 
-	Tizen::Base::Integer  serialno(serialNumber);
+	msg_get_int_value(newMsg, MSG_CB_MSG_MSG_ID_INT, &messgeId);
+	msg_get_int_value(newMsg, MSG_CB_MSG_SERIAL_NUM_INT, &serialNumber);
+	msg_get_int_value(newMsg, MSG_CB_MSG_TYPE_INT, &cbsType);
+
+	Tizen::Base::Integer serialno(serialNumber);
 	length = serialno.ToString().GetLength();
 
 	msgSerialNumber.Construct(length);
 	msgSerialNumber.SetInt(0, serialNumber);
 	msgSerialNumber.SetPosition(0);
 
-	String message(pMsgBody);       // porting char* to String
+	if (cbsType == MSG_TYPE_SMS_ETWS_PRIMARY || cbsType == MSG_TYPE_SMS_ETWS_SECONDARY)
+	{
+		int etwsWarningType;
+		char etwsWarningInfo[MESSAGES_ETWS_WARNING_INFO_LEN];
+		Tizen::Base::ByteBuffer msgSecurityInfo;
+		Tizen::Base::ByteBuffer etwsMsgWarningType;
+		msg_get_int_value(newMsg, MSG_CB_MSG_ETWS_WARNING_TYPE_INT, &etwsWarningType);
+		msg_get_str_value(newMsg, MSG_CB_MSG_ETWS_WARNING_SECU_INFO_STR, etwsWarningInfo, MESSAGES_ETWS_WARNING_INFO_LEN);
+
+		String etwsSecurityInfo(etwsWarningInfo);
+		length = etwsSecurityInfo.GetLength();
+		msgSecurityInfo.Construct(length);
+		msgSecurityInfo.SetArray((byte*) etwsWarningInfo, 0, length);
+		msgSecurityInfo.SetPosition(0);
+
+		Tizen::Base::Integer warningtype(etwsWarningType);
+		length = warningtype.ToString().GetLength();
+
+		etwsMsgWarningType.Construct(length);
+		etwsMsgWarningType.SetInt(0, etwsWarningType);
+		etwsMsgWarningType.SetPosition(0);
 
-	receivedTime = _MsgUtil::ConvertTime(&tempReceivedTime);
+		etwsNotifiation = true;
+		_SmsEvent* pSmsEvent = static_cast <_SmsEvent*>(_SmsMmsCallbackHandler::GetInstance()->__pEtwsUserEvent);
 
-	Tizen::Base::Integer dataCodingSchemeTemp(dataCodingScheme);
+		SysLog(NID_MSG, "cbs etwsWarningType: [%d]", etwsWarningType);
 
-	if (cbsType == MESSAGES_TYPE_SMS_ETWS_PRIMARY || cbsType == MESSAGES_TYPE_SMS_ETWS_SECONDARY)
-	{
-		etwsNotifiation = true;
+		if (pSmsEvent)
+		{
+			pSmsEventArg = new (std::nothrow) _SmsEventArg(receivedTime, msgSerialNumber, msgSecurityInfo, messgeId,
+									 etwsMsgWarningType, _SMS_EVENT_TYPE_ETWS_RECEIVE_RESULT);
+			SysTryReturnVoidResult(NID_MSG, pSmsEventArg != null, E_OUT_OF_MEMORY, "memory allocation failed.");
+			pSmsEvent->Fire(*pSmsEventArg);
+		}
 	}
-
-	if (pMsgBody)
+	else
 	{
-		free(pMsgBody);
-		pMsgBody = null;
+		_SmsEvent* pSmsEvent = static_cast <_SmsEvent*>(_SmsMmsCallbackHandler::GetInstance()->__pCbsUserEvent);
+		int dataCodingScheme = 0;
+		int msgSize = 0;
+
+		msg_get_int_value(newMsg, MSG_CB_MSG_CB_TEXT_LEN_INT, &msgSize);
+		char msgBody[msgSize + 1];
+		memset(msgBody, 0, msgSize + 1);
+		msg_get_str_value(newMsg, MSG_CB_MSG_CB_TEXT_STR, msgBody, msgSize + 1);
+		String message(msgBody);       // porting char* to String
+
+		msg_get_int_value(newMsg, MSG_CB_MSG_DCS_INT, &dataCodingScheme);
+		Tizen::Base::Integer dataCodingSchemeTemp(dataCodingScheme);
+
+		//language type of cbs message
+		String messageLanguage(L"");
+		byte higherNibble = dataCodingScheme & 0xf0;
+		byte lowerNibble = dataCodingScheme & 0x0f;
+
+		//check higher nibble
+		// if higher nibble 0000
+		if (higherNibble == 0x00)
+		{		
+			messageLanguage = GetCbsLanguageType(lowerNibble);
+		}
+		else if (higherNibble == 0x01)
+		{
+			// if higher nibble is 0001, get language type from framework
+			int len = 15;
+			char type[len + 1];
+			memset(type, 0, len + 1);
+			msg_get_str_value(newMsg, MSG_CB_MSG_LANGUAGE_TYPE_STR, type, len);
+			messageLanguage = String(type);
+		}
+		else if (higherNibble == 0x20 && lowerNibble == 0x00)
+		{
+			// if 0010 0000		
+			messageLanguage = String(L"CS");		
+		}
+		else
+		{
+			// use empty string
+		}
+
+		if (pSmsEvent)
+		{
+			pSmsEventArg = new (std::nothrow) _SmsEventArg(message, msgSerialNumber, receivedTime, messgeId, etwsNotifiation,
+					 ((byte) dataCodingSchemeTemp.ToChar()),messageLanguage, _SMS_EVENT_TYPE_CBS_RECEIVE_RESULT);
+			SysTryReturnVoidResult(NID_MSG, pSmsEventArg != null, E_OUT_OF_MEMORY, "memory allocation failed.");
+			pSmsEvent->Fire(*pSmsEventArg);
+		}
+
+		SysLog(NID_MSG, "cbs msg_body: [%s]", msgBody);
+		SysLog(NID_MSG, "cbs dataCodingScheme: [%d]", dataCodingScheme);
+		SysLog(NID_MSG, "cbs languageType: [%s]", messageLanguage.GetPointer());
 	}
-	SysLog(NID_MSG, "cbs msg_body: [%s]", pMsgBody);
+
 	SysLog(NID_MSG, "cbs msg_id: [%d]", messgeId);
 	SysLog(NID_MSG, "cbs serialNumber: [%d]", serialNumber);
-	SysLog(NID_MSG, "cbs received time: [%s]", ctime(&tempReceivedTime));
 	SysLog(NID_MSG, "cbs etwsNotifiation: [%d]", etwsNotifiation);
-	SysLog(NID_MSG, "cbs dataCodingScheme: [%d]", dataCodingScheme);
-
-	if (pSmsEvent)
-	{
-		pSmsEventArg = new (std::nothrow) _SmsEventArg(message, msgSerialNumber, receivedTime, messgeId, etwsNotifiation, ((byte) dataCodingSchemeTemp.ToChar()), _SMS_EVENT_TYPE_CBS_RECEIVE_RESULT);
-		SysTryReturnVoidResult(NID_MSG, pSmsEventArg != null, E_OUT_OF_MEMORY, "memory allocation failed.");
-		pSmsEvent->Fire(*pSmsEventArg);
-	}
 }
 
 void
-_SmsMmsCallbackHandler::IncomingWapPushMessageCallback(const char* pHeader, const char* pBody, int bodyLength, void* pUserParam)
+_SmsMmsCallbackHandler::IncomingWapPushMessageCallback(msg_handle_t hMsgHandle, const char* pHeader, const char* pBody, int bodyLength, void* pUserParam)
 {
 	_SmsEvent* pSmsEvent = static_cast <_SmsEvent*>(pUserParam);
 	_SmsEventArg* pSmsEventArg = null;
@@ -320,56 +866,111 @@ _SmsMmsCallbackHandler::IncomingWapPushMessageCallback(const char* pHeader, cons
 	}
 }
 
-void
-_SmsMmsCallbackHandler::IncomingEtwsMessageCallback(messages_cb_message_h incomingMsg, int etwsWarningType, const char* pEtwsSecurityInfo, void* pUserParam)
+Tizen::Base::String
+_SmsMmsCallbackHandler::GetCbsLanguageType(byte codingScheme)
 {
-	_SmsEvent* pSmsEvent = static_cast <_SmsEvent*>(pUserParam);
-	_SmsEventArg* pSmsEventArg = null;
-	time_t tempReceivedTime = 0;
-	DateTime receivedTime;
-	int messgeId = 0;
-	int serialNumber = 0;
-	int length = 0;
-	Tizen::Base::ByteBuffer msgSerialNumber;
-	Tizen::Base::ByteBuffer msgSecurityInfo;
-	Tizen::Base::ByteBuffer etwsMsgWarningType;
+	String languageType(L"");
 
-	messages_cb_get_time(incomingMsg, &tempReceivedTime);
-	messages_cb_get_message_id(incomingMsg, &messgeId);
-	messages_cb_get_serial_number(incomingMsg, &serialNumber);
+	switch(codingScheme)
+	{
+	case 0x00:
+		languageType = String(L"DE");
+		break;
+	case 0x01:
+		languageType = String(L"EN");
+		break;
+	case 0x02:
+		languageType = String(L"IT");
+		break;
+	case 0x03:
+		languageType = String(L"FR");
+		break;
+	case 0x04:
+		languageType = String(L"ES");
+		break;
+	case 0x05:
+		languageType = String(L"NL");
+		break;
+	case 0x06:
+		languageType = String(L"SV");
+		break;
+	case 0x07:
+		languageType = String(L"DA");
+		break;
+	case 0x08:
+		languageType = String(L"PT");
+		break;
+	case 0x09:
+		languageType = String(L"FI");
+		break;
+	case 0x0a:
+		languageType = String(L"NO");
+		break;
+	case 0x0b:
+		languageType = String(L"EL");
+		break;
+	case 0x0c:
+		languageType = String(L"TR");
+		break;
+	case 0x0d:
+		languageType = String(L"HU");
+		break;
+	case 0x0e:
+		languageType = String(L"PL");
+		break;
+	case 0x0f:
+		languageType = String(L"");
+		SysLog(NID_MSG, "Language unspecified.");
+		break;
+	default:
+		break;
+	};
+	
+	return languageType;
+}
 
-	Tizen::Base::Integer  serialno(serialNumber);
-	length = serialno.ToString().GetLength();
+result
+_SmsMmsCallbackHandler::ConvertException(int err) const
+{
+	result r = E_SUCCESS;
 
-	msgSerialNumber.Construct(length);
-	msgSerialNumber.SetInt(0, serialNumber);
-	msgSerialNumber.SetPosition(0);
+	switch (err)
+	{
+	case MSG_SUCCESS:
+		r = E_SUCCESS;
+		break;
 
-	String etwsSecurityInfo(pEtwsSecurityInfo);
-	length = etwsSecurityInfo.GetLength();
-	msgSecurityInfo.Construct(length);
-	msgSecurityInfo.SetArray((byte*) pEtwsSecurityInfo, 0, length);
-	msgSecurityInfo.SetPosition(0);
+	case MSG_ERR_INVALID_PARAMETER:
+	case MSG_ERR_INVALID_MESSAGE:
+	case MSG_ERR_NULL_POINTER:
+	case MSG_ERR_NULL_MESSAGE:
+		r = E_INVALID_ARG;
+		break;
 
-	Tizen::Base::Integer  warningtype(etwsWarningType);
-	length = warningtype.ToString().GetLength();
+	case MSG_ERR_MEMORY_ERROR:
+		r = E_OUT_OF_MEMORY;
+		break;
 
-	etwsMsgWarningType.Construct(length);
-	etwsMsgWarningType.SetInt(0, etwsWarningType);
-	etwsMsgWarningType.SetPosition(0);
+	case MSG_ERR_SERVER_NOT_READY:
+	case MSG_ERR_TRANSPORT_ERROR:
+	case MSG_ERR_COMMUNICATION_ERROR:
+		r = E_NETWORK_UNAVAILABLE;
+		break;
 
-	receivedTime = _MsgUtil::ConvertTime(&tempReceivedTime);
+	case MSG_ERR_NO_SIM:
+		r = E_DEVICE_UNAVAILABLE;
+		break;
 
-	SysLog(NID_MSG, "cbs msg_id: [%d]", messgeId);
-	SysLog(NID_MSG, "cbs received time: [%s]", ctime(&tempReceivedTime));
-	SysLog(NID_MSG, "cbs etwsWarningType: [%d]", etwsWarningType);
+	case MSG_ERR_PLUGIN_TAPI_FAILED:
+		r = E_FAILURE;
+		break;
 
-	if (pSmsEvent)
-	{
-		pSmsEventArg = new (std::nothrow) _SmsEventArg(receivedTime, msgSerialNumber, msgSecurityInfo, messgeId, etwsMsgWarningType, _SMS_EVENT_TYPE_ETWS_RECEIVE_RESULT);
-		SysTryReturnVoidResult(NID_MSG, pSmsEventArg != null, E_OUT_OF_MEMORY, "memory allocation failed.");
-		pSmsEvent->Fire(*pSmsEventArg);
+	default:
+		r = E_SYSTEM;
+		break;
 	}
+
+	return r;
 }
 
 } } // Tizen::Messaging