* 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;
_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;
}
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;
}
}
-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
projects / platform / framework / native / messaging.git / blobdiff