2 * Copyright 2012-2013 Samsung Electronics Co., Ltd
4 * Licensed under the Flora License, Version 1.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.tizenopensource.org/license
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
18 #include "MsgUtilFunction.h"
19 #include "MsgCppTypes.h"
20 #include "MsgException.h"
21 #include "MsgHandle.h"
24 #define MSG_TYPE_CHECK(a, b) \
26 if(a != b) return MSG_ERR_INVALID_PARAMETER; \
29 #define MSG_NULL_CHECK(a) \
31 if(a == NULL) return MSG_ERR_NULL_POINTER; \
34 /*==================================================================================================
35 IMPLEMENTATION OF MsgHandle - Setting Member Functions
36 ==================================================================================================*/
38 msg_error_t MsgHandle::getSMSCOption(msg_struct_t msg_struct)
40 msg_struct_s *smsc_opt = (msg_struct_s *)msg_struct;
41 MSG_TYPE_CHECK(smsc_opt->type, MSG_STRUCT_SETTING_SMSC_OPT);
42 MSG_NULL_CHECK(smsc_opt->data);
44 // Allocate Memory to Command Data
45 int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T);
48 bzero(cmdBuf, cmdSize);
49 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
51 // Set Command Parameters
52 pCmd->cmdType = MSG_CMD_GET_SMSC_OPT;
55 MSG_OPTION_TYPE_T opt_type = MSG_SMSC_LIST;
58 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
61 memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
63 // Send Command to Messaging FW
64 char* pEventData = NULL;
65 AutoPtr<char> eventBuf(&pEventData);
67 write((char*)pCmd, cmdSize, &pEventData);
70 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
72 if (pEvent->eventType != MSG_EVENT_GET_SMSC_OPT)
74 THROW(MsgException::INVALID_RESULT, "Event Data Error");
77 if (pEvent->result == MSG_SUCCESS) {
78 MSG_SMSC_LIST_S smsc_list_tmp = {0,};
81 dataSize = sizeof(MSG_SMSC_LIST_S);
82 memcpy(&smsc_list_tmp, pEvent->data, dataSize);
84 MSG_SMSC_LIST_HIDDEN_S *pTmp = (MSG_SMSC_LIST_HIDDEN_S *)smsc_opt->data;
86 pTmp->selected = smsc_list_tmp.selected;
87 pTmp->smsc_list->nCount = smsc_list_tmp.totalCnt;
89 msg_struct_s *pStructTmp = NULL;
91 for (int i = 0; i < pTmp->smsc_list->nCount; i++) {
92 pStructTmp = (msg_struct_s *)pTmp->smsc_list->msg_struct_info[i];
93 memset(pStructTmp->data, 0x00, sizeof(MSG_SMSC_DATA_S));
94 memcpy(pStructTmp->data, &(smsc_list_tmp.smscData[i]), sizeof(MSG_SMSC_DATA_S));
98 return pEvent->result;
101 msg_error_t MsgHandle::setSMSCOption(msg_struct_t msg_struct)
103 msg_struct_s *smsc_opt = (msg_struct_s *)msg_struct;
104 MSG_TYPE_CHECK(smsc_opt->type, MSG_STRUCT_SETTING_SMSC_OPT);
105 MSG_NULL_CHECK(smsc_opt->data);
107 // Allocate Memory to Command Data
108 MSG_OPTION_TYPE_T optionType = MSG_SMSC_LIST;
109 int cmdSize = getSettingCmdSize(optionType);
111 char cmdBuf[cmdSize];
112 bzero(cmdBuf, cmdSize);
113 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
116 msg_struct_s *pTmp = (msg_struct_s *)msg_struct;
117 MSG_SMSC_LIST_HIDDEN_S *pTmpList = (MSG_SMSC_LIST_HIDDEN_S *)pTmp->data;
119 MSG_SMSC_LIST_S smsc_list_tmp = {0,};
121 smsc_list_tmp.totalCnt = pTmpList->smsc_list->nCount;
122 smsc_list_tmp.selected = pTmpList->selected;
124 msg_struct_s *pStructTmp = NULL;
126 for (i=0; i < smsc_list_tmp.totalCnt; i++) {
127 pStructTmp = (msg_struct_s *)pTmpList->smsc_list->msg_struct_info[i];
128 MSG_TYPE_CHECK(pStructTmp->type, MSG_STRUCT_SETTING_SMSC_INFO);
129 memcpy(&(smsc_list_tmp.smscData[i]), pStructTmp->data, sizeof(MSG_SMSC_DATA_S));
132 // Set Command Parameters
133 pCmd->cmdType = MSG_CMD_SET_SMSC_OPT;
136 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
138 MSG_SETTING_S pSetting = {0,};
140 pSetting.type = optionType;
141 memcpy(&(pSetting.option.smscList), &smsc_list_tmp, sizeof(MSG_SMSC_LIST_S));
144 memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
146 // Send Command to Messaging FW
147 char* pEventData = NULL;
148 AutoPtr<char> eventBuf(&pEventData);
150 write((char*)pCmd, cmdSize, &pEventData);
153 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
155 if (pEvent->eventType != MSG_EVENT_SET_SMSC_OPT)
157 THROW(MsgException::INVALID_RESULT, "Event Data Error");
160 return pEvent->result;
163 msg_error_t MsgHandle::getCBOption(msg_struct_t msg_struct)
165 msg_struct_s *cb_opt = (msg_struct_s *)msg_struct;
166 MSG_TYPE_CHECK(cb_opt->type, MSG_STRUCT_SETTING_CB_OPT);
167 MSG_NULL_CHECK(cb_opt->data);
169 // Allocate Memory to Command Data
170 int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T);
172 char cmdBuf[cmdSize];
173 bzero(cmdBuf, cmdSize);
174 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
176 // Set Command Parameters
177 pCmd->cmdType = MSG_CMD_GET_CB_OPT;
180 MSG_OPTION_TYPE_T opt_type = MSG_CBMSG_OPT;
183 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
186 memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
188 // Send Command to Messaging FW
189 char* pEventData = NULL;
190 AutoPtr<char> eventBuf(&pEventData);
192 write((char*)pCmd, cmdSize, &pEventData);
195 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
197 if (pEvent->eventType != MSG_EVENT_GET_CB_OPT)
199 THROW(MsgException::INVALID_RESULT, "Event Data Error");
202 if (pEvent->result == MSG_SUCCESS) {
204 MSG_CBMSG_OPT_S cb_opt_tmp = {0,};
205 memcpy(&cb_opt_tmp, pEvent->data, sizeof(MSG_CBMSG_OPT_S));
207 MSG_CBMSG_OPT_HIDDEN_S *pTmp = (MSG_CBMSG_OPT_HIDDEN_S *)cb_opt->data;
208 pTmp->bReceive = cb_opt_tmp.bReceive;
209 pTmp->maxSimCnt = cb_opt_tmp.maxSimCnt;
211 for (i = 0; i < CB_LANG_TYPE_MAX; i++)
212 pTmp->bLanguage[i] = cb_opt_tmp.bLanguage[i];
214 pTmp->channelData->nCount = cb_opt_tmp.channelData.channelCnt;
216 msg_struct_s *pStructTmp = NULL;
218 for (i = 0; i < pTmp->channelData->nCount; i++) {
219 pStructTmp = (msg_struct_s *)pTmp->channelData->msg_struct_info[i];
220 memset(pStructTmp->data, 0x00, sizeof(MSG_CB_CHANNEL_INFO_S));
221 memcpy(pStructTmp->data, &(cb_opt_tmp.channelData.channelInfo[i]), sizeof(MSG_CB_CHANNEL_INFO_S));
225 return pEvent->result;
228 msg_error_t MsgHandle::setCBOption(msg_struct_t msg_struct)
230 msg_struct_s *cb_opt = (msg_struct_s *)msg_struct;
231 MSG_TYPE_CHECK(cb_opt->type, MSG_STRUCT_SETTING_CB_OPT);
232 MSG_NULL_CHECK(cb_opt->data);
234 // Allocate Memory to Command Data
235 MSG_OPTION_TYPE_T optionType = MSG_CBMSG_OPT;
236 int cmdSize = getSettingCmdSize(optionType);
238 char cmdBuf[cmdSize];
239 bzero(cmdBuf, cmdSize);
240 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
243 // Set Command Parameters
244 pCmd->cmdType = MSG_CMD_SET_CB_OPT;
247 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
250 MSG_CBMSG_OPT_S cb_opt_tmp = {0,};
251 MSG_CBMSG_OPT_HIDDEN_S *cb_msg_opt = (MSG_CBMSG_OPT_HIDDEN_S *)cb_opt->data;
253 cb_opt_tmp.bReceive = cb_msg_opt->bReceive;
254 cb_opt_tmp.maxSimCnt = cb_msg_opt->maxSimCnt;
255 for (int i = 0; i < CB_LANG_TYPE_MAX; i++)
256 cb_opt_tmp.bLanguage[i] = cb_msg_opt->bLanguage[i];
258 msg_struct_list_s *cb_ch_list = cb_msg_opt->channelData;
259 msg_struct_s *pStructTmp = NULL;
261 cb_opt_tmp.channelData.channelCnt = cb_ch_list->nCount;
263 for (i = 0; i < cb_opt_tmp.channelData.channelCnt; i++) {
264 pStructTmp = (msg_struct_s *)cb_ch_list->msg_struct_info[i];
265 memcpy(&(cb_opt_tmp.channelData.channelInfo[i]), pStructTmp->data, sizeof(MSG_CB_CHANNEL_INFO_S));
268 MSG_SETTING_S pSetting = {0,};
269 pSetting.type = optionType;
271 memcpy(&(pSetting.option.cbMsgOpt), &cb_opt_tmp, sizeof(MSG_CBMSG_OPT_S));
274 memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
276 // Send Command to Messaging FW
277 char* pEventData = NULL;
278 AutoPtr<char> eventBuf(&pEventData);
280 write((char*)pCmd, cmdSize, &pEventData);
283 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
285 if (pEvent->eventType != MSG_EVENT_SET_CB_OPT)
287 THROW(MsgException::INVALID_RESULT, "Event Data Error");
290 return pEvent->result;
293 msg_error_t MsgHandle::getSmsSendOpt(msg_struct_t msg_struct)
295 msg_struct_s *sms_send_opt = (msg_struct_s *)msg_struct;
296 MSG_TYPE_CHECK(sms_send_opt->type, MSG_STRUCT_SETTING_SMS_SEND_OPT);
297 MSG_NULL_CHECK(sms_send_opt->data);
299 // Allocate Memory to Command Data
300 int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T);
302 char cmdBuf[cmdSize];
303 bzero(cmdBuf, cmdSize);
304 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
306 // Set Command Parameters
307 pCmd->cmdType = MSG_CMD_GET_SMS_SEND_OPT;
310 MSG_OPTION_TYPE_T opt_type = MSG_SMS_SENDOPT;
313 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
316 memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
318 // Send Command to Messaging FW
319 char* pEventData = NULL;
320 AutoPtr<char> eventBuf(&pEventData);
322 write((char*)pCmd, cmdSize, &pEventData);
325 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
327 if (pEvent->eventType != MSG_EVENT_GET_SMS_SEND_OPT)
329 THROW(MsgException::INVALID_RESULT, "Event Data Error");
332 if (pEvent->result == MSG_SUCCESS) {
333 memcpy(sms_send_opt->data, pEvent->data, sizeof(MSG_SMS_SENDOPT_S));
336 return pEvent->result;
339 msg_error_t MsgHandle::setSmsSendOpt(msg_struct_t msg_struct)
341 msg_struct_s *sms_send_opt = (msg_struct_s *)msg_struct;
342 MSG_TYPE_CHECK(sms_send_opt->type, MSG_STRUCT_SETTING_SMS_SEND_OPT);
343 MSG_NULL_CHECK(sms_send_opt->data);
345 // Allocate Memory to Command Data
346 MSG_OPTION_TYPE_T optionType = MSG_SMS_SENDOPT;
347 int cmdSize = getSettingCmdSize(optionType);
349 char cmdBuf[cmdSize];
350 bzero(cmdBuf, cmdSize);
351 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
353 // Set Command Parameters
354 pCmd->cmdType = MSG_CMD_SET_SMS_SEND_OPT;
357 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
360 MSG_SETTING_S pSetting = {0,};
361 pSetting.type = optionType;
363 memcpy(&(pSetting.option.smsSendOpt), sms_send_opt->data, sizeof(MSG_SMS_SENDOPT_S));
366 memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
368 // Send Command to Messaging FW
369 char* pEventData = NULL;
370 AutoPtr<char> eventBuf(&pEventData);
372 write((char*)pCmd, cmdSize, &pEventData);
375 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
377 if (pEvent->eventType != MSG_EVENT_SET_SMS_SEND_OPT)
379 THROW(MsgException::INVALID_RESULT, "Event Data Error");
382 return pEvent->result;
385 msg_error_t MsgHandle::getMmsSendOpt(msg_struct_t msg_struct)
387 msg_struct_s *mms_send_opt = (msg_struct_s *)msg_struct;
388 MSG_TYPE_CHECK(mms_send_opt->type, MSG_STRUCT_SETTING_MMS_SEND_OPT);
389 MSG_NULL_CHECK(mms_send_opt->data);
391 // Allocate Memory to Command Data
392 int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T);
394 char cmdBuf[cmdSize];
395 bzero(cmdBuf, cmdSize);
396 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
398 // Set Command Parameters
399 pCmd->cmdType = MSG_CMD_GET_MMS_SEND_OPT;
402 MSG_OPTION_TYPE_T opt_type = MSG_MMS_SENDOPT;
405 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
408 memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
410 // Send Command to Messaging FW
411 char* pEventData = NULL;
412 AutoPtr<char> eventBuf(&pEventData);
414 write((char*)pCmd, cmdSize, &pEventData);
417 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
419 if (pEvent->eventType != MSG_EVENT_GET_MMS_SEND_OPT)
421 THROW(MsgException::INVALID_RESULT, "Event Data Error");
424 if (pEvent->result == MSG_SUCCESS) {
425 memcpy(mms_send_opt->data, pEvent->data, sizeof(MSG_MMS_SENDOPT_S));
428 return pEvent->result;
431 msg_error_t MsgHandle::setMmsSendOpt(msg_struct_t msg_struct)
433 msg_struct_s *mms_send_opt = (msg_struct_s *)msg_struct;
434 MSG_TYPE_CHECK(mms_send_opt->type, MSG_STRUCT_SETTING_MMS_SEND_OPT);
435 MSG_NULL_CHECK(mms_send_opt->data);
437 // Allocate Memory to Command Data
438 MSG_OPTION_TYPE_T optionType = MSG_MMS_SENDOPT;
439 int cmdSize = getSettingCmdSize(optionType);
441 char cmdBuf[cmdSize];
442 bzero(cmdBuf, cmdSize);
443 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
445 // Set Command Parameters
446 pCmd->cmdType = MSG_CMD_SET_MMS_SEND_OPT;
449 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
452 MSG_SETTING_S pSetting = {0,};
453 pSetting.type = optionType;
455 memcpy(&(pSetting.option.mmsSendOpt), mms_send_opt->data, sizeof(MSG_MMS_SENDOPT_S));
458 memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
460 // Send Command to Messaging FW
461 char* pEventData = NULL;
462 AutoPtr<char> eventBuf(&pEventData);
464 write((char*)pCmd, cmdSize, &pEventData);
467 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
469 if (pEvent->eventType != MSG_EVENT_SET_MMS_SEND_OPT)
471 THROW(MsgException::INVALID_RESULT, "Event Data Error");
474 return pEvent->result;
477 msg_error_t MsgHandle::getMmsRecvOpt(msg_struct_t msg_struct)
479 msg_struct_s *mms_recv_opt = (msg_struct_s *)msg_struct;
480 MSG_TYPE_CHECK(mms_recv_opt->type, MSG_STRUCT_SETTING_MMS_RECV_OPT);
481 MSG_NULL_CHECK(mms_recv_opt->data);
483 // Allocate Memory to Command Data
484 int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T);
486 char cmdBuf[cmdSize];
487 bzero(cmdBuf, cmdSize);
488 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
490 // Set Command Parameters
491 pCmd->cmdType = MSG_CMD_GET_MMS_RECV_OPT;
494 MSG_OPTION_TYPE_T opt_type = MSG_MMS_RECVOPT;
497 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
500 memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
502 // Send Command to Messaging FW
503 char* pEventData = NULL;
504 AutoPtr<char> eventBuf(&pEventData);
506 write((char*)pCmd, cmdSize, &pEventData);
509 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
511 if (pEvent->eventType != MSG_EVENT_GET_MMS_RECV_OPT)
513 THROW(MsgException::INVALID_RESULT, "Event Data Error");
516 if (pEvent->result == MSG_SUCCESS) {
517 memcpy(mms_recv_opt->data, pEvent->data, sizeof(MSG_MMS_RECVOPT_S));
520 return pEvent->result;
523 msg_error_t MsgHandle::setMmsRecvOpt(msg_struct_t msg_struct)
525 msg_struct_s *mms_recv_opt = (msg_struct_s *)msg_struct;
526 MSG_TYPE_CHECK(mms_recv_opt->type, MSG_STRUCT_SETTING_MMS_RECV_OPT);
527 MSG_NULL_CHECK(mms_recv_opt->data);
529 // Allocate Memory to Command Data
530 MSG_OPTION_TYPE_T optionType = MSG_MMS_RECVOPT;
531 int cmdSize = getSettingCmdSize(optionType);
533 char cmdBuf[cmdSize];
534 bzero(cmdBuf, cmdSize);
535 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
537 // Set Command Parameters
538 pCmd->cmdType = MSG_CMD_SET_MMS_RECV_OPT;
541 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
544 MSG_SETTING_S pSetting = {0,};
545 pSetting.type = optionType;
547 memcpy(&(pSetting.option.mmsRecvOpt), mms_recv_opt->data, sizeof(MSG_MMS_RECVOPT_S));
550 memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
552 // Send Command to Messaging FW
553 char* pEventData = NULL;
554 AutoPtr<char> eventBuf(&pEventData);
556 write((char*)pCmd, cmdSize, &pEventData);
559 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
561 if (pEvent->eventType != MSG_EVENT_SET_MMS_RECV_OPT)
563 THROW(MsgException::INVALID_RESULT, "Event Data Error");
566 return pEvent->result;
569 msg_error_t MsgHandle::getPushMsgOpt(msg_struct_t msg_struct)
571 msg_struct_s *push_opt = (msg_struct_s *)msg_struct;
572 MSG_TYPE_CHECK(push_opt->type, MSG_STRUCT_SETTING_PUSH_MSG_OPT);
573 MSG_NULL_CHECK(push_opt->data);
575 // Allocate Memory to Command Data
576 int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T);
578 char cmdBuf[cmdSize];
579 bzero(cmdBuf, cmdSize);
580 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
582 // Set Command Parameters
583 pCmd->cmdType = MSG_CMD_GET_PUSH_MSG_OPT;
586 MSG_OPTION_TYPE_T opt_type = MSG_PUSHMSG_OPT;
589 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
592 memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
594 // Send Command to Messaging FW
595 char* pEventData = NULL;
596 AutoPtr<char> eventBuf(&pEventData);
598 write((char*)pCmd, cmdSize, &pEventData);
601 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
603 if (pEvent->eventType != MSG_EVENT_GET_PUSH_MSG_OPT)
605 THROW(MsgException::INVALID_RESULT, "Event Data Error");
608 if (pEvent->result == MSG_SUCCESS) {
609 memcpy(push_opt->data, pEvent->data, sizeof(MSG_PUSHMSG_OPT_S));
612 return pEvent->result;
615 msg_error_t MsgHandle::setPushMsgOpt(msg_struct_t msg_struct)
617 msg_struct_s *push_opt = (msg_struct_s *)msg_struct;
618 MSG_TYPE_CHECK(push_opt->type, MSG_STRUCT_SETTING_PUSH_MSG_OPT);
619 MSG_NULL_CHECK(push_opt->data);
621 // Allocate Memory to Command Data
622 MSG_OPTION_TYPE_T optionType = MSG_PUSHMSG_OPT;
623 int cmdSize = getSettingCmdSize(optionType);
625 char cmdBuf[cmdSize];
626 bzero(cmdBuf, cmdSize);
627 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
629 // Set Command Parameters
630 pCmd->cmdType = MSG_CMD_SET_PUSH_MSG_OPT;
633 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
636 MSG_SETTING_S pSetting = {0,};
637 pSetting.type = optionType;
639 memcpy(&(pSetting.option.pushMsgOpt), push_opt->data, sizeof(MSG_PUSHMSG_OPT_S));
642 memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
644 // Send Command to Messaging FW
645 char* pEventData = NULL;
646 AutoPtr<char> eventBuf(&pEventData);
648 write((char*)pCmd, cmdSize, &pEventData);
651 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
653 if (pEvent->eventType != MSG_EVENT_SET_PUSH_MSG_OPT)
655 THROW(MsgException::INVALID_RESULT, "Event Data Error");
658 return pEvent->result;
661 msg_error_t MsgHandle::getVoiceMsgOpt(msg_struct_t msg_struct)
663 msg_struct_s *voice_opt = (msg_struct_s *)msg_struct;
664 MSG_TYPE_CHECK(voice_opt->type, MSG_STRUCT_SETTING_VOICE_MSG_OPT);
665 MSG_NULL_CHECK(voice_opt->data);
667 // Allocate Memory to Command Data
668 int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T);
670 char cmdBuf[cmdSize];
671 bzero(cmdBuf, cmdSize);
672 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
674 // Set Command Parameters
675 pCmd->cmdType = MSG_CMD_GET_VOICE_MSG_OPT;
678 MSG_OPTION_TYPE_T opt_type = MSG_VOICEMAIL_OPT;
681 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
684 memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
686 // Send Command to Messaging FW
687 char* pEventData = NULL;
688 AutoPtr<char> eventBuf(&pEventData);
690 write((char*)pCmd, cmdSize, &pEventData);
693 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
695 if (pEvent->eventType != MSG_EVENT_GET_VOICE_MSG_OPT)
697 THROW(MsgException::INVALID_RESULT, "Event Data Error");
700 if (pEvent->result == MSG_SUCCESS) {
701 memcpy(voice_opt->data, pEvent->data, sizeof(MSG_VOICEMAIL_OPT_S));
704 return pEvent->result;
707 msg_error_t MsgHandle::setVoiceMsgOpt(msg_struct_t msg_struct)
709 msg_struct_s *voice_opt = (msg_struct_s *)msg_struct;
710 MSG_TYPE_CHECK(voice_opt->type, MSG_STRUCT_SETTING_VOICE_MSG_OPT);
711 MSG_NULL_CHECK(voice_opt->data);
713 // Allocate Memory to Command Data
714 MSG_OPTION_TYPE_T optionType = MSG_VOICEMAIL_OPT;
715 int cmdSize = getSettingCmdSize(optionType);
717 char cmdBuf[cmdSize];
718 bzero(cmdBuf, cmdSize);
719 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
721 // Set Command Parameters
722 pCmd->cmdType = MSG_CMD_SET_VOICE_MSG_OPT;
725 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
728 MSG_SETTING_S pSetting = {0,};
729 pSetting.type = optionType;
731 memcpy(&(pSetting.option.voiceMailOpt), voice_opt->data, sizeof(MSG_VOICEMAIL_OPT_S));
734 memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
736 // Send Command to Messaging FW
737 char* pEventData = NULL;
738 AutoPtr<char> eventBuf(&pEventData);
740 write((char*)pCmd, cmdSize, &pEventData);
743 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
745 if (pEvent->eventType != MSG_EVENT_SET_VOICE_MSG_OPT)
747 THROW(MsgException::INVALID_RESULT, "Event Data Error");
750 return pEvent->result;
753 msg_error_t MsgHandle::getGeneralOpt(msg_struct_t msg_struct)
755 msg_struct_s *general_opt = (msg_struct_s *)msg_struct;
756 MSG_TYPE_CHECK(general_opt->type, MSG_STRUCT_SETTING_GENERAL_OPT);
757 MSG_NULL_CHECK(general_opt->data);
759 // Allocate Memory to Command Data
760 int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T);
762 char cmdBuf[cmdSize];
763 bzero(cmdBuf, cmdSize);
764 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
766 // Set Command Parameters
767 pCmd->cmdType = MSG_CMD_GET_GENERAL_MSG_OPT;
770 MSG_OPTION_TYPE_T opt_type = MSG_GENERAL_OPT;
773 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
776 memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
778 // Send Command to Messaging FW
779 char* pEventData = NULL;
780 AutoPtr<char> eventBuf(&pEventData);
782 write((char*)pCmd, cmdSize, &pEventData);
785 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
787 if (pEvent->eventType != MSG_EVENT_GET_GENERAL_MSG_OPT)
789 THROW(MsgException::INVALID_RESULT, "Event Data Error");
792 if (pEvent->result == MSG_SUCCESS) {
793 memcpy(general_opt->data, pEvent->data, sizeof(MSG_GENERAL_OPT_S));
796 return pEvent->result;
799 msg_error_t MsgHandle::setGeneralOpt(msg_struct_t msg_struct)
801 msg_struct_s *general_opt = (msg_struct_s *)msg_struct;
802 MSG_TYPE_CHECK(general_opt->type, MSG_STRUCT_SETTING_GENERAL_OPT);
803 MSG_NULL_CHECK(general_opt->data);
805 // Allocate Memory to Command Data
806 MSG_OPTION_TYPE_T optionType = MSG_GENERAL_OPT;
807 int cmdSize = getSettingCmdSize(optionType);
809 char cmdBuf[cmdSize];
810 bzero(cmdBuf, cmdSize);
811 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
813 // Set Command Parameters
814 pCmd->cmdType = MSG_CMD_SET_GENERAL_MSG_OPT;
817 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
820 MSG_SETTING_S pSetting = {0,};
821 pSetting.type = optionType;
823 memcpy(&(pSetting.option.generalOpt), general_opt->data, sizeof(MSG_GENERAL_OPT_S));
826 memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
828 // Send Command to Messaging FW
829 char* pEventData = NULL;
830 AutoPtr<char> eventBuf(&pEventData);
832 write((char*)pCmd, cmdSize, &pEventData);
835 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
837 if (pEvent->eventType != MSG_EVENT_SET_GENERAL_MSG_OPT)
839 THROW(MsgException::INVALID_RESULT, "Event Data Error");
842 return pEvent->result;
845 msg_error_t MsgHandle::getMsgSizeOpt(msg_struct_t msg_struct)
847 msg_struct_s *msg_size_opt = (msg_struct_s *)msg_struct;
848 MSG_TYPE_CHECK(msg_size_opt->type, MSG_STRUCT_SETTING_MSGSIZE_OPT);
849 MSG_NULL_CHECK(msg_size_opt->data);
851 // Allocate Memory to Command Data
852 int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T);
854 char cmdBuf[cmdSize];
855 bzero(cmdBuf, cmdSize);
856 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
858 // Set Command Parameters
859 pCmd->cmdType = MSG_CMD_GET_MSG_SIZE_OPT;
862 MSG_OPTION_TYPE_T opt_type = MSG_MSGSIZE_OPT;
865 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
868 memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
870 // Send Command to Messaging FW
871 char* pEventData = NULL;
872 AutoPtr<char> eventBuf(&pEventData);
874 write((char*)pCmd, cmdSize, &pEventData);
877 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
879 if (pEvent->eventType != MSG_EVENT_GET_MSG_SIZE_OPT)
881 THROW(MsgException::INVALID_RESULT, "Event Data Error");
884 if (pEvent->result == MSG_SUCCESS) {
885 memcpy(msg_size_opt->data, pEvent->data, sizeof(MSG_MSGSIZE_OPT_S));
888 return pEvent->result;
891 msg_error_t MsgHandle::setMsgSizeOpt(msg_struct_t msg_struct)
893 msg_struct_s *msg_size_opt = (msg_struct_s *)msg_struct;
894 MSG_TYPE_CHECK(msg_size_opt->type, MSG_STRUCT_SETTING_MSGSIZE_OPT);
895 MSG_NULL_CHECK(msg_size_opt->data);
897 // Allocate Memory to Command Data
898 MSG_OPTION_TYPE_T optionType = MSG_MSGSIZE_OPT;
899 int cmdSize = getSettingCmdSize(optionType);
901 char cmdBuf[cmdSize];
902 bzero(cmdBuf, cmdSize);
903 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
905 // Set Command Parameters
906 pCmd->cmdType = MSG_CMD_SET_MSG_SIZE_OPT;
909 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
912 MSG_SETTING_S pSetting = {0,};
913 pSetting.type = optionType;
915 memcpy(&(pSetting.option.msgSizeOpt), msg_size_opt->data, sizeof(MSG_MSGSIZE_OPT_S));
918 memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
920 // Send Command to Messaging FW
921 char* pEventData = NULL;
922 AutoPtr<char> eventBuf(&pEventData);
924 write((char*)pCmd, cmdSize, &pEventData);
927 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
929 if (pEvent->eventType != MSG_EVENT_SET_MSG_SIZE_OPT)
931 THROW(MsgException::INVALID_RESULT, "Event Data Error");
934 return pEvent->result;