2 * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved
4 * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
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_NULL_CHECK(a) \
27 return MSG_ERR_NULL_POINTER; \
31 /*==================================================================================================
32 IMPLEMENTATION OF MsgHandle - Setting Member Functions
33 ==================================================================================================*/
35 msg_error_t MsgHandle::getSMSCOption(msg_struct_t msg_struct)
37 msg_struct_s *smsc_opt = (msg_struct_s *)msg_struct;
38 MSG_TYPE_CHECK(smsc_opt->type, MSG_STRUCT_SETTING_SMSC_OPT);
39 MSG_NULL_CHECK(smsc_opt->data);
41 /* Allocate Memory to Command Data */
42 int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T) + sizeof(msg_sim_slot_id_t);
45 bzero(cmdBuf, cmdSize);
46 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
48 /* Set Command Parameters */
49 pCmd->cmdType = MSG_CMD_GET_SMSC_OPT;
52 MSG_OPTION_TYPE_T opt_type = MSG_SMSC_LIST;
55 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
57 /* Copy Command Data */
58 memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
60 msg_sim_slot_id_t simIndex = ((MSG_SMSC_LIST_HIDDEN_S *)smsc_opt->data)->simIndex;
62 THROW(MsgException::INVALID_PARAM, "Invalid SIM Index");
64 memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN+sizeof(MSG_OPTION_TYPE_T)), &simIndex, sizeof(msg_sim_slot_id_t));
66 /* Send Command to Messaging FW */
67 char* pEventData = NULL;
68 unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
70 write((char*)pCmd, cmdSize, &pEventData);
73 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
75 if (pEvent->eventType != MSG_EVENT_GET_SMSC_OPT) {
76 THROW(MsgException::INVALID_RESULT, "Event Data Error");
79 if (pEvent->result == MSG_SUCCESS) {
80 MSG_SMSC_LIST_S smsc_list_tmp = {0, };
83 dataSize = sizeof(pEvent->data);
84 memcpy(&smsc_list_tmp, pEvent->data, dataSize);
86 MSG_SMSC_LIST_HIDDEN_S *pTmp = (MSG_SMSC_LIST_HIDDEN_S *)smsc_opt->data;
88 pTmp->selected = smsc_list_tmp.selected;
89 pTmp->smsc_list->nCount = smsc_list_tmp.totalCnt;
90 pTmp->index = smsc_list_tmp.selected;
91 pTmp->simIndex = smsc_list_tmp.simIndex;
93 msg_struct_s *pStructTmp = NULL;
95 for (int i = 0; i < pTmp->smsc_list->nCount; i++) {
96 pStructTmp = (msg_struct_s *)pTmp->smsc_list->msg_struct_info[i];
97 memset(pStructTmp->data, 0x00, sizeof(MSG_SMSC_DATA_S));
98 memcpy(pStructTmp->data, &(smsc_list_tmp.smscData[i]), sizeof(MSG_SMSC_DATA_S));
102 return pEvent->result;
106 msg_error_t MsgHandle::setSMSCOption(msg_struct_t msg_struct)
108 msg_struct_s *smsc_opt = (msg_struct_s *)msg_struct;
109 MSG_TYPE_CHECK(smsc_opt->type, MSG_STRUCT_SETTING_SMSC_OPT);
110 MSG_NULL_CHECK(smsc_opt->data);
112 /* Allocate Memory to Command Data */
113 MSG_OPTION_TYPE_T optionType = MSG_SMSC_LIST;
114 int cmdSize = getSettingCmdSize(optionType);
116 char cmdBuf[cmdSize];
117 bzero(cmdBuf, cmdSize);
118 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
121 msg_struct_s *pTmp = (msg_struct_s *)msg_struct;
122 MSG_SMSC_LIST_HIDDEN_S *pTmpList = (MSG_SMSC_LIST_HIDDEN_S *)pTmp->data;
124 MSG_SMSC_LIST_S smsc_list_tmp = {0, };
126 smsc_list_tmp.totalCnt = pTmpList->smsc_list->nCount;
127 smsc_list_tmp.selected = pTmpList->selected;
128 smsc_list_tmp.index = pTmpList->index;
129 smsc_list_tmp.simIndex = pTmpList->simIndex;
131 if (smsc_list_tmp.totalCnt > SMSC_LIST_MAX) {
132 MSG_ERR("SMSC count is invaild value[Max:%d, Input:%d]", SMSC_LIST_MAX, smsc_list_tmp.totalCnt);
133 return MSG_ERR_INVALID_PARAMETER;
136 MSG_DEBUG("SMSC totalcnt:%d selected:%d, index:%d ", smsc_list_tmp.totalCnt, smsc_list_tmp.selected, smsc_list_tmp.index);
138 msg_struct_s *pStructTmp = NULL;
140 for (i=0; i < smsc_list_tmp.totalCnt; i++) {
141 pStructTmp = (msg_struct_s *)pTmpList->smsc_list->msg_struct_info[i];
142 MSG_TYPE_CHECK(pStructTmp->type, MSG_STRUCT_SETTING_SMSC_INFO);
143 memcpy(&(smsc_list_tmp.smscData[i]), pStructTmp->data, sizeof(MSG_SMSC_DATA_S));
146 /* Set Command Parameters */
147 pCmd->cmdType = MSG_CMD_SET_SMSC_OPT;
150 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
152 MSG_SETTING_S pSetting = {0, };
154 pSetting.type = optionType;
155 memcpy(&(pSetting.option.smscList), &smsc_list_tmp, sizeof(MSG_SMSC_LIST_S));
157 /* Copy Command Data */
158 memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
160 /* Send Command to Messaging FW */
161 char* pEventData = NULL;
162 unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
164 write((char*)pCmd, cmdSize, &pEventData);
166 /* Get Return Data */
167 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
169 if (pEvent->eventType != MSG_EVENT_SET_SMSC_OPT) {
170 THROW(MsgException::INVALID_RESULT, "Event Data Error");
173 return pEvent->result;
177 msg_error_t MsgHandle::getCBOption(msg_struct_t msg_struct)
179 msg_struct_s *cb_opt = (msg_struct_s *)msg_struct;
180 MSG_TYPE_CHECK(cb_opt->type, MSG_STRUCT_SETTING_CB_OPT);
181 MSG_NULL_CHECK(cb_opt->data);
183 /* Allocate Memory to Command Data */
184 int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T) + sizeof(msg_sim_slot_id_t);
186 char cmdBuf[cmdSize];
187 bzero(cmdBuf, cmdSize);
188 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
190 /* Set Command Parameters */
191 pCmd->cmdType = MSG_CMD_GET_CB_OPT;
193 /* Set option type */
194 MSG_OPTION_TYPE_T opt_type = MSG_CBMSG_OPT;
197 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
199 /* Copy Command Data */
200 memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
202 msg_sim_slot_id_t simIndex = ((MSG_CBMSG_OPT_HIDDEN_S*)cb_opt->data)->simIndex;
203 memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN+sizeof(MSG_OPTION_TYPE_T)), &simIndex, sizeof(msg_sim_slot_id_t));
205 /* Send Command to Messaging FW */
206 char* pEventData = NULL;
207 unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
209 write((char*)pCmd, cmdSize, &pEventData);
211 /* Get Return Data */
212 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
214 if (pEvent->eventType != MSG_EVENT_GET_CB_OPT) {
215 THROW(MsgException::INVALID_RESULT, "Event Data Error");
218 if (pEvent->result == MSG_SUCCESS) {
220 MSG_CBMSG_OPT_S cb_opt_tmp = {0, };
221 memcpy(&cb_opt_tmp, pEvent->data, sizeof(pEvent->data));
223 MSG_CBMSG_OPT_HIDDEN_S *pTmp = (MSG_CBMSG_OPT_HIDDEN_S *)cb_opt->data;
224 pTmp->bReceive = cb_opt_tmp.bReceive;
225 pTmp->maxSimCnt = cb_opt_tmp.maxSimCnt;
226 pTmp->simIndex = cb_opt_tmp.simIndex;
228 for (i = 0; i < CB_LANG_TYPE_MAX; i++)
229 pTmp->bLanguage[i] = cb_opt_tmp.bLanguage[i];
231 pTmp->channelData->nCount = cb_opt_tmp.channelData.channelCnt;
233 msg_struct_s *pStructTmp = NULL;
235 for (i = 0; i < pTmp->channelData->nCount; i++) {
236 pStructTmp = (msg_struct_s *)pTmp->channelData->msg_struct_info[i];
237 memset(pStructTmp->data, 0x00, sizeof(MSG_CB_CHANNEL_INFO_S));
238 memcpy(pStructTmp->data, &(cb_opt_tmp.channelData.channelInfo[i]), sizeof(MSG_CB_CHANNEL_INFO_S));
242 return pEvent->result;
246 msg_error_t MsgHandle::setCBOption(msg_struct_t msg_struct)
248 msg_struct_s *cb_opt = (msg_struct_s *)msg_struct;
249 MSG_TYPE_CHECK(cb_opt->type, MSG_STRUCT_SETTING_CB_OPT);
250 MSG_NULL_CHECK(cb_opt->data);
252 /* Allocate Memory to Command Data */
253 MSG_OPTION_TYPE_T optionType = MSG_CBMSG_OPT;
254 int cmdSize = getSettingCmdSize(optionType);
256 char cmdBuf[cmdSize];
257 bzero(cmdBuf, cmdSize);
258 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
261 /* Set Command Parameters */
262 pCmd->cmdType = MSG_CMD_SET_CB_OPT;
265 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
267 /* Copy Command Data */
268 MSG_CBMSG_OPT_S cb_opt_tmp = {0, };
269 MSG_CBMSG_OPT_HIDDEN_S *cb_msg_opt = (MSG_CBMSG_OPT_HIDDEN_S *)cb_opt->data;
271 cb_opt_tmp.bReceive = cb_msg_opt->bReceive;
272 cb_opt_tmp.maxSimCnt = cb_msg_opt->maxSimCnt;
273 cb_opt_tmp.simIndex = cb_msg_opt->simIndex;
274 for (int i = 0; i < CB_LANG_TYPE_MAX; i++)
275 cb_opt_tmp.bLanguage[i] = cb_msg_opt->bLanguage[i];
277 msg_struct_list_s *cb_ch_list = cb_msg_opt->channelData;
278 msg_struct_s *pStructTmp = NULL;
280 cb_opt_tmp.channelData.channelCnt = cb_ch_list->nCount;
282 for (i = 0; i < cb_opt_tmp.channelData.channelCnt; i++) {
283 pStructTmp = (msg_struct_s *)cb_ch_list->msg_struct_info[i];
284 memcpy(&(cb_opt_tmp.channelData.channelInfo[i]), pStructTmp->data, sizeof(MSG_CB_CHANNEL_INFO_S));
287 MSG_SETTING_S pSetting = {0, };
288 pSetting.type = optionType;
290 memcpy(&(pSetting.option.cbMsgOpt), &cb_opt_tmp, sizeof(MSG_CBMSG_OPT_S));
292 /* Copy Command Data */
293 memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
295 /* Send Command to Messaging FW */
296 char* pEventData = NULL;
297 unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
299 write((char*)pCmd, cmdSize, &pEventData);
301 /* Get Return Data */
302 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
304 if (pEvent->eventType != MSG_EVENT_SET_CB_OPT) {
305 THROW(MsgException::INVALID_RESULT, "Event Data Error");
308 return pEvent->result;
312 msg_error_t MsgHandle::getSmsSendOpt(msg_struct_t msg_struct)
314 msg_struct_s *sms_send_opt = (msg_struct_s *)msg_struct;
315 MSG_TYPE_CHECK(sms_send_opt->type, MSG_STRUCT_SETTING_SMS_SEND_OPT);
316 MSG_NULL_CHECK(sms_send_opt->data);
318 /* Allocate Memory to Command Data */
319 int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T);
321 char cmdBuf[cmdSize];
322 bzero(cmdBuf, cmdSize);
323 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
325 /* Set Command Parameters */
326 pCmd->cmdType = MSG_CMD_GET_SMS_SEND_OPT;
328 /* Set option type */
329 MSG_OPTION_TYPE_T opt_type = MSG_SMS_SENDOPT;
332 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
334 /* Copy Command Data */
335 memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
337 /* Send Command to Messaging FW */
338 char* pEventData = NULL;
339 unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
341 write((char*)pCmd, cmdSize, &pEventData);
343 /* Get Return Data */
344 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
346 if (pEvent->eventType != MSG_EVENT_GET_SMS_SEND_OPT) {
347 THROW(MsgException::INVALID_RESULT, "Event Data Error");
350 if (pEvent->result == MSG_SUCCESS) {
351 memcpy(sms_send_opt->data, pEvent->data, sizeof(pEvent->data));
354 return pEvent->result;
358 msg_error_t MsgHandle::setSmsSendOpt(msg_struct_t msg_struct)
360 msg_struct_s *sms_send_opt = (msg_struct_s *)msg_struct;
361 MSG_TYPE_CHECK(sms_send_opt->type, MSG_STRUCT_SETTING_SMS_SEND_OPT);
362 MSG_NULL_CHECK(sms_send_opt->data);
364 /* Allocate Memory to Command Data */
365 MSG_OPTION_TYPE_T optionType = MSG_SMS_SENDOPT;
366 int cmdSize = getSettingCmdSize(optionType);
368 char cmdBuf[cmdSize];
369 bzero(cmdBuf, cmdSize);
370 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
372 /* Set Command Parameters */
373 pCmd->cmdType = MSG_CMD_SET_SMS_SEND_OPT;
376 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
378 /* Copy Command Data */
379 MSG_SETTING_S pSetting = {0, };
380 pSetting.type = optionType;
382 memcpy(&(pSetting.option.smsSendOpt), sms_send_opt->data, sizeof(MSG_SMS_SENDOPT_S));
385 memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
387 /* Send Command to Messaging FW */
388 char* pEventData = NULL;
389 unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
391 write((char*)pCmd, cmdSize, &pEventData);
393 /* Get Return Data */
394 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
396 if (pEvent->eventType != MSG_EVENT_SET_SMS_SEND_OPT) {
397 THROW(MsgException::INVALID_RESULT, "Event Data Error");
400 return pEvent->result;
404 msg_error_t MsgHandle::getMmsSendOpt(msg_struct_t msg_struct)
406 msg_struct_s *mms_send_opt = (msg_struct_s *)msg_struct;
407 MSG_TYPE_CHECK(mms_send_opt->type, MSG_STRUCT_SETTING_MMS_SEND_OPT);
408 MSG_NULL_CHECK(mms_send_opt->data);
410 /* Allocate Memory to Command Data */
411 int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T);
413 char cmdBuf[cmdSize];
414 bzero(cmdBuf, cmdSize);
415 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
417 /* Set Command Parameters */
418 pCmd->cmdType = MSG_CMD_GET_MMS_SEND_OPT;
420 /* Set option type */
421 MSG_OPTION_TYPE_T opt_type = MSG_MMS_SENDOPT;
424 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
426 /* Copy Command Data */
427 memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
429 /* Send Command to Messaging FW */
430 char* pEventData = NULL;
431 unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
433 write((char*)pCmd, cmdSize, &pEventData);
435 /* Get Return Data */
436 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
438 if (pEvent->eventType != MSG_EVENT_GET_MMS_SEND_OPT) {
439 THROW(MsgException::INVALID_RESULT, "Event Data Error");
442 if (pEvent->result == MSG_SUCCESS) {
443 memcpy(mms_send_opt->data, pEvent->data, sizeof(pEvent->data));
446 return pEvent->result;
450 msg_error_t MsgHandle::setMmsSendOpt(msg_struct_t msg_struct)
452 msg_struct_s *mms_send_opt = (msg_struct_s *)msg_struct;
453 MSG_TYPE_CHECK(mms_send_opt->type, MSG_STRUCT_SETTING_MMS_SEND_OPT);
454 MSG_NULL_CHECK(mms_send_opt->data);
456 /* Allocate Memory to Command Data */
457 MSG_OPTION_TYPE_T optionType = MSG_MMS_SENDOPT;
458 int cmdSize = getSettingCmdSize(optionType);
460 char cmdBuf[cmdSize];
461 bzero(cmdBuf, cmdSize);
462 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
464 /* Set Command Parameters */
465 pCmd->cmdType = MSG_CMD_SET_MMS_SEND_OPT;
468 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
470 /* Copy Command Data */
471 MSG_SETTING_S pSetting = {0, };
472 pSetting.type = optionType;
474 memcpy(&(pSetting.option.mmsSendOpt), mms_send_opt->data, sizeof(MSG_MMS_SENDOPT_S));
476 /* Copy Command Data */
477 memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
479 /* Send Command to Messaging FW */
480 char* pEventData = NULL;
481 unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
483 write((char*)pCmd, cmdSize, &pEventData);
485 /* Get Return Data */
486 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
488 if (pEvent->eventType != MSG_EVENT_SET_MMS_SEND_OPT) {
489 THROW(MsgException::INVALID_RESULT, "Event Data Error");
492 return pEvent->result;
496 msg_error_t MsgHandle::getMmsRecvOpt(msg_struct_t msg_struct)
498 msg_struct_s *mms_recv_opt = (msg_struct_s *)msg_struct;
499 MSG_TYPE_CHECK(mms_recv_opt->type, MSG_STRUCT_SETTING_MMS_RECV_OPT);
500 MSG_NULL_CHECK(mms_recv_opt->data);
502 /* Allocate Memory to Command Data */
503 int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T);
505 char cmdBuf[cmdSize];
506 bzero(cmdBuf, cmdSize);
507 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
509 /* Set Command Parameters */
510 pCmd->cmdType = MSG_CMD_GET_MMS_RECV_OPT;
512 /* Set option type */
513 MSG_OPTION_TYPE_T opt_type = MSG_MMS_RECVOPT;
516 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
518 /* Copy Command Data */
519 memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
521 /* Send Command to Messaging FW */
522 char* pEventData = NULL;
523 unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
525 write((char*)pCmd, cmdSize, &pEventData);
527 /* Get Return Data */
528 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
530 if (pEvent->eventType != MSG_EVENT_GET_MMS_RECV_OPT) {
531 THROW(MsgException::INVALID_RESULT, "Event Data Error");
534 if (pEvent->result == MSG_SUCCESS) {
535 memcpy(mms_recv_opt->data, pEvent->data, sizeof(pEvent->data));
538 return pEvent->result;
542 msg_error_t MsgHandle::setMmsRecvOpt(msg_struct_t msg_struct)
544 msg_struct_s *mms_recv_opt = (msg_struct_s *)msg_struct;
545 MSG_TYPE_CHECK(mms_recv_opt->type, MSG_STRUCT_SETTING_MMS_RECV_OPT);
546 MSG_NULL_CHECK(mms_recv_opt->data);
548 /* Allocate Memory to Command Data */
549 MSG_OPTION_TYPE_T optionType = MSG_MMS_RECVOPT;
550 int cmdSize = getSettingCmdSize(optionType);
552 char cmdBuf[cmdSize];
553 bzero(cmdBuf, cmdSize);
554 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
556 /* Set Command Parameters */
557 pCmd->cmdType = MSG_CMD_SET_MMS_RECV_OPT;
560 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
562 /* Copy Command Data */
563 MSG_SETTING_S pSetting = {0, };
564 pSetting.type = optionType;
566 memcpy(&(pSetting.option.mmsRecvOpt), mms_recv_opt->data, sizeof(MSG_MMS_RECVOPT_S));
568 /* Copy Command Data */
569 memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
571 /* Send Command to Messaging FW */
572 char* pEventData = NULL;
573 unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
575 write((char*)pCmd, cmdSize, &pEventData);
577 /* Get Return Data */
578 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
580 if (pEvent->eventType != MSG_EVENT_SET_MMS_RECV_OPT) {
581 THROW(MsgException::INVALID_RESULT, "Event Data Error");
584 return pEvent->result;
588 msg_error_t MsgHandle::getPushMsgOpt(msg_struct_t msg_struct)
590 msg_struct_s *push_opt = (msg_struct_s *)msg_struct;
591 MSG_TYPE_CHECK(push_opt->type, MSG_STRUCT_SETTING_PUSH_MSG_OPT);
592 MSG_NULL_CHECK(push_opt->data);
594 /* Allocate Memory to Command Data */
595 int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T);
597 char cmdBuf[cmdSize];
598 bzero(cmdBuf, cmdSize);
599 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
601 /* Set Command Parameters */
602 pCmd->cmdType = MSG_CMD_GET_PUSH_MSG_OPT;
604 /* Set option type */
605 MSG_OPTION_TYPE_T opt_type = MSG_PUSHMSG_OPT;
608 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
610 /* Copy Command Data */
611 memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
613 /* Send Command to Messaging FW */
614 char* pEventData = NULL;
615 unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
617 write((char*)pCmd, cmdSize, &pEventData);
619 /* Get Return Data */
620 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
622 if (pEvent->eventType != MSG_EVENT_GET_PUSH_MSG_OPT) {
623 THROW(MsgException::INVALID_RESULT, "Event Data Error");
626 if (pEvent->result == MSG_SUCCESS) {
627 memcpy(push_opt->data, pEvent->data, sizeof(MSG_PUSHMSG_OPT_S));
630 return pEvent->result;
634 msg_error_t MsgHandle::setPushMsgOpt(msg_struct_t msg_struct)
636 msg_struct_s *push_opt = (msg_struct_s *)msg_struct;
637 MSG_TYPE_CHECK(push_opt->type, MSG_STRUCT_SETTING_PUSH_MSG_OPT);
638 MSG_NULL_CHECK(push_opt->data);
640 /* Allocate Memory to Command Data */
641 MSG_OPTION_TYPE_T optionType = MSG_PUSHMSG_OPT;
642 int cmdSize = getSettingCmdSize(optionType);
644 char cmdBuf[cmdSize];
645 bzero(cmdBuf, cmdSize);
646 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
648 /* Set Command Parameters */
649 pCmd->cmdType = MSG_CMD_SET_PUSH_MSG_OPT;
652 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
654 /* Copy Command Data */
655 MSG_SETTING_S pSetting = {0, };
656 pSetting.type = optionType;
658 memcpy(&(pSetting.option.pushMsgOpt), push_opt->data, sizeof(MSG_PUSHMSG_OPT_S));
660 /* Copy Command Data */
661 memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
663 /* Send Command to Messaging FW */
664 char* pEventData = NULL;
665 unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
667 write((char*)pCmd, cmdSize, &pEventData);
669 /* Get Return Data */
670 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
672 if (pEvent->eventType != MSG_EVENT_SET_PUSH_MSG_OPT) {
673 THROW(MsgException::INVALID_RESULT, "Event Data Error");
676 return pEvent->result;
680 msg_error_t MsgHandle::getVoiceMsgOpt(msg_struct_t msg_struct)
682 msg_struct_s *voice_opt = (msg_struct_s *)msg_struct;
683 MSG_TYPE_CHECK(voice_opt->type, MSG_STRUCT_SETTING_VOICE_MSG_OPT);
684 MSG_NULL_CHECK(voice_opt->data);
686 /* Allocate Memory to Command Data */
687 int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T) + sizeof(msg_sim_slot_id_t);
689 char cmdBuf[cmdSize];
690 bzero(cmdBuf, cmdSize);
691 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
693 /* Set Command Parameters */
694 pCmd->cmdType = MSG_CMD_GET_VOICE_MSG_OPT;
696 /* Set option type */
697 MSG_OPTION_TYPE_T opt_type = MSG_VOICEMAIL_OPT;
700 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
702 /* Copy Command Data */
703 memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
705 msg_sim_slot_id_t simIndex = ((MSG_VOICEMAIL_OPT_S *)voice_opt->data)->simIndex;
707 THROW(MsgException::INVALID_PARAM, "Invalid SIM Index : [index=%d]", simIndex);
709 memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN+sizeof(MSG_OPTION_TYPE_T)), &simIndex, sizeof(msg_sim_slot_id_t));
711 /* Send Command to Messaging FW */
712 char* pEventData = NULL;
713 unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
715 write((char*)pCmd, cmdSize, &pEventData);
717 /* Get Return Data */
718 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
720 if (pEvent->eventType != MSG_EVENT_GET_VOICE_MSG_OPT) {
721 THROW(MsgException::INVALID_RESULT, "Event Data Error");
724 if (pEvent->result == MSG_SUCCESS) {
725 memcpy(voice_opt->data, pEvent->data, sizeof(MSG_VOICEMAIL_OPT_S));
728 return pEvent->result;
732 msg_error_t MsgHandle::setVoiceMsgOpt(msg_struct_t msg_struct)
734 msg_struct_s *voice_opt = (msg_struct_s *)msg_struct;
735 MSG_TYPE_CHECK(voice_opt->type, MSG_STRUCT_SETTING_VOICE_MSG_OPT);
736 MSG_NULL_CHECK(voice_opt->data);
738 /* Allocate Memory to Command Data */
739 MSG_OPTION_TYPE_T optionType = MSG_VOICEMAIL_OPT;
740 int cmdSize = getSettingCmdSize(optionType);
742 char cmdBuf[cmdSize];
743 bzero(cmdBuf, cmdSize);
744 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
746 /* Set Command Parameters */
747 pCmd->cmdType = MSG_CMD_SET_VOICE_MSG_OPT;
750 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
752 /* Copy Command Data */
753 MSG_SETTING_S pSetting = {0, };
754 pSetting.type = optionType;
756 memcpy(&(pSetting.option.voiceMailOpt), voice_opt->data, sizeof(MSG_VOICEMAIL_OPT_S));
758 /* Copy Command Data */
759 memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
761 /* Send Command to Messaging FW */
762 char* pEventData = NULL;
763 unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
765 write((char*)pCmd, cmdSize, &pEventData);
767 /* Get Return Data */
768 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
770 if (pEvent->eventType != MSG_EVENT_SET_VOICE_MSG_OPT) {
771 THROW(MsgException::INVALID_RESULT, "Event Data Error");
774 return pEvent->result;
778 msg_error_t MsgHandle::getGeneralOpt(msg_struct_t msg_struct)
780 msg_struct_s *general_opt = (msg_struct_s *)msg_struct;
781 MSG_TYPE_CHECK(general_opt->type, MSG_STRUCT_SETTING_GENERAL_OPT);
782 MSG_NULL_CHECK(general_opt->data);
784 /* Allocate Memory to Command Data */
785 int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T);
787 char cmdBuf[cmdSize];
788 bzero(cmdBuf, cmdSize);
789 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
791 /* Set Command Parameters */
792 pCmd->cmdType = MSG_CMD_GET_GENERAL_MSG_OPT;
794 /* Set option type */
795 MSG_OPTION_TYPE_T opt_type = MSG_GENERAL_OPT;
798 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
800 /* Copy Command Data */
801 memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
803 /* Send Command to Messaging FW */
804 char* pEventData = NULL;
805 unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
807 write((char*)pCmd, cmdSize, &pEventData);
809 /* Get Return Data */
810 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
812 if (pEvent->eventType != MSG_EVENT_GET_GENERAL_MSG_OPT) {
813 THROW(MsgException::INVALID_RESULT, "Event Data Error");
816 if (pEvent->result == MSG_SUCCESS) {
817 memcpy(general_opt->data, pEvent->data, sizeof(pEvent->data));
820 return pEvent->result;
824 msg_error_t MsgHandle::setGeneralOpt(msg_struct_t msg_struct)
826 msg_struct_s *general_opt = (msg_struct_s *)msg_struct;
827 MSG_TYPE_CHECK(general_opt->type, MSG_STRUCT_SETTING_GENERAL_OPT);
828 MSG_NULL_CHECK(general_opt->data);
830 /* Allocate Memory to Command Data */
831 MSG_OPTION_TYPE_T optionType = MSG_GENERAL_OPT;
832 int cmdSize = getSettingCmdSize(optionType);
834 char cmdBuf[cmdSize];
835 bzero(cmdBuf, cmdSize);
836 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
838 /* Set Command Parameters */
839 pCmd->cmdType = MSG_CMD_SET_GENERAL_MSG_OPT;
842 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
844 /* Copy Command Data */
845 MSG_SETTING_S pSetting = {0, };
846 pSetting.type = optionType;
848 memcpy(&(pSetting.option.generalOpt), general_opt->data, sizeof(MSG_GENERAL_OPT_S));
850 /* Copy Command Data */
851 memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
853 /* Send Command to Messaging FW */
854 char* pEventData = NULL;
855 unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
857 write((char*)pCmd, cmdSize, &pEventData);
859 /* Get Return Data */
860 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
862 if (pEvent->eventType != MSG_EVENT_SET_GENERAL_MSG_OPT) {
863 THROW(MsgException::INVALID_RESULT, "Event Data Error");
866 return pEvent->result;
870 msg_error_t MsgHandle::getMsgSizeOpt(msg_struct_t msg_struct)
872 msg_struct_s *msg_size_opt = (msg_struct_s *)msg_struct;
873 MSG_TYPE_CHECK(msg_size_opt->type, MSG_STRUCT_SETTING_MSGSIZE_OPT);
874 MSG_NULL_CHECK(msg_size_opt->data);
876 /* Allocate Memory to Command Data */
877 int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T);
879 char cmdBuf[cmdSize];
880 bzero(cmdBuf, cmdSize);
881 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
883 /* Set Command Parameters */
884 pCmd->cmdType = MSG_CMD_GET_MSG_SIZE_OPT;
886 /* Set option type */
887 MSG_OPTION_TYPE_T opt_type = MSG_MSGSIZE_OPT;
890 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
892 /* Copy Command Data */
893 memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
895 /* Send Command to Messaging FW */
896 char* pEventData = NULL;
897 unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
899 write((char*)pCmd, cmdSize, &pEventData);
901 /* Get Return Data */
902 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
904 if (pEvent->eventType != MSG_EVENT_GET_MSG_SIZE_OPT) {
905 THROW(MsgException::INVALID_RESULT, "Event Data Error");
908 if (pEvent->result == MSG_SUCCESS) {
909 memcpy(msg_size_opt->data, pEvent->data, sizeof(pEvent->data));
912 return pEvent->result;
916 msg_error_t MsgHandle::setMsgSizeOpt(msg_struct_t msg_struct)
918 msg_struct_s *msg_size_opt = (msg_struct_s *)msg_struct;
919 MSG_TYPE_CHECK(msg_size_opt->type, MSG_STRUCT_SETTING_MSGSIZE_OPT);
920 MSG_NULL_CHECK(msg_size_opt->data);
922 /* Allocate Memory to Command Data */
923 MSG_OPTION_TYPE_T optionType = MSG_MSGSIZE_OPT;
924 int cmdSize = getSettingCmdSize(optionType);
926 char cmdBuf[cmdSize];
927 bzero(cmdBuf, cmdSize);
928 MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
930 /* Set Command Parameters */
931 pCmd->cmdType = MSG_CMD_SET_MSG_SIZE_OPT;
934 memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
936 /* Copy Command Data */
937 MSG_SETTING_S pSetting = {0, };
938 pSetting.type = optionType;
940 memcpy(&(pSetting.option.msgSizeOpt), msg_size_opt->data, sizeof(MSG_MSGSIZE_OPT_S));
942 /* Copy Command Data */
943 memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
945 /* Send Command to Messaging FW */
946 char* pEventData = NULL;
947 unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
949 write((char*)pCmd, cmdSize, &pEventData);
951 /* Get Return Data */
952 MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
954 if (pEvent->eventType != MSG_EVENT_SET_MSG_SIZE_OPT) {
955 THROW(MsgException::INVALID_RESULT, "Event Data Error");
958 return pEvent->result;