plugin/sms_plugin/SmsPluginCbMsgHandler.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved
   3  *
   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
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15 */
  16
  17 #include <time.h>
  18
  19 #include "MsgDebug.h"
  20 #include "MsgCppTypes.h"
  21 #include "MsgException.h"
  22 #include "MsgGconfWrapper.h"
  23 #include "MsgUtilFile.h"
  24 #include "MsgUtilStorage.h"
  25 #include "SmsPluginUDCodec.h"
  26 #include "SmsPluginStorage.h"
  27 #include "SmsPluginEventHandler.h"
  28 #include "SmsPluginCbMsgHandler.h"
  29 #include "SmsPluginDSHandler.h"
  30
  31 /*==================================================================================================
  32                                      IMPLEMENTATION OF SmsPluginCbMsgHandler - Member Functions
  33 ==================================================================================================*/
  34 SmsPluginCbMsgHandler* SmsPluginCbMsgHandler::pInstance = NULL;
  35
  36
  37 SmsPluginCbMsgHandler::SmsPluginCbMsgHandler()
  38 {
  39         pageList.clear();
  40 }
  41
  42
  43 SmsPluginCbMsgHandler::~SmsPluginCbMsgHandler()
  44 {
  45
  46 }
  47
  48
  49 SmsPluginCbMsgHandler* SmsPluginCbMsgHandler::instance()
  50 {
  51         if (!pInstance)
  52                 pInstance = new SmsPluginCbMsgHandler();
  53
  54         return pInstance;
  55 }
  56
  57
  58 void SmsPluginCbMsgHandler::handleCbMsg(TapiHandle *handle, TelSmsCbMsg_t *pCbMsg)
  59 {
  60         MSG_BEGIN();
  61
  62 #if 0
  63         char temp[1000]= {0x01, 0xa4, 0x1f, 0x51, 0x10, 0x11, 0x02, 0xea, 0x30, 0x30, 0xa8, 0x30, 0xea, 0x30, 0xa2, 0x30, 0xe1, 0x30, 0xfc, 0x30, 0xeb, 0x91, 0x4d, 0x4f, 0xe1, 0x30, 0xc6, 0x30, 0xb9, 0x30, 0xc8, 0x00, 0x0d, 0x00, 0x0a, 0x30, 0x53, 0x30, 0x8c, 0x30, 0x6f, 0x8a, 0x66, 0x9a, 0x13, 0x75, 0x28, 0x30, 0x6e, 0x30, 0xe1, 0x30, 0xc3, 0x30, 0xbb, 0x30, 0xfc, 0x30, 0xb8, 0x30, 0x67, 0x30, 0x59, 0x30, 0x02, 0x00, 0x0d, 0x00, 0x0a, 0xff, 0x08, 0x00, 0x32, 0x00, 0x30, 0x00, 0x31, 0x00, 0x33, 0x00, 0x2f, 0x00, 0x31, 0x00, 0x31, 0x00, 0x2f, 0x00, 0x32, 0x52, 0xea, 0x30, 0x00, 0x37, 0x00, 0x20, 0x00, 0x31, 0x00, 0x35, 0x00, 0x3a, 0x00, 0x34, 0x00, 0x34, 0xff, 0x09, 0x00, 0x0d, 0x00, 0x0a, 0xff, 0x08, 0x30, 0xa8, 0x30, 0xea, 0x30, 0xa2, 0x5e, 0x02, 0xff, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22};
  64         TelSmsEtwsMsg_t *pCbMsg = (TelSmsEtwsMsg_t *)calloc(1, sizeof(TelSmsEtwsMsg_t));
  65         pCbMsg->Length = 173;
  66         pCbMsg->EtwsMsgType = (TelSmsEtwsMsgType_t)2;
  67         memcpy(pCbMsg->szMsgData, temp, pCbMsg->Length);
  68
  69         SMS_CB_NETWORK_TYPE_T type = pCbMsg->EtwsMsgType;
  70         SMS_CBMSG_PAGE_S CbMsgPage = {0};
  71
  72         switch (type)
  73         {
  74                 case SMS_CB_NETWORK_TYPE_2G_GSM :
  75                         Decode2gCbMsg((TelSmsCbMsg_t *)pCbMsg, &CbMsgPage);
  76                 break;
  77
  78                 case SMS_CB_NETWORK_TYPE_3G_UMTS :
  79                         Decode3gCbMsg((TelSmsCbMsg_t *)pCbMsg, &CbMsgPage);
  80                 break;
  81
  82         }
  83 #else
  84         SMS_CB_NETWORK_TYPE_T type = pCbMsg->CbMsgType;
  85         SMS_CBMSG_PAGE_S CbMsgPage = {0};
  86
  87         switch (type)
  88         {
  89                 case SMS_CB_NETWORK_TYPE_2G_GSM :
  90                         Decode2gCbMsg(pCbMsg, &CbMsgPage);
  91                 break;
  92
  93                 case SMS_CB_NETWORK_TYPE_3G_UMTS :
  94                         Decode3gCbMsg(pCbMsg, &CbMsgPage);
  95                 break;
  96
  97         }
  98 #endif
  99         // Check CB Msg Options
 100         bool bJavaMsg = false;
 101
 102         int simIndex = SmsPluginDSHandler::instance()->getSimIndex(handle);
 103
 104         if (!checkCbOpt(&CbMsgPage, &bJavaMsg, simIndex))
 105         {
 106                 MSG_DEBUG("The CB Msg is not supported by option.");
 107                 return;
 108         }
 109
 110         if (bJavaMsg == true)
 111         {
 112                 MSG_DEBUG("JAVA CB Msg.");
 113                 CbMsgPage.cbMsgType = SMS_CBMSG_TYPE_JAVACBS;
 114         }
 115
 116
 117         // Check CB Pages
 118         unsigned char pageCnt = checkCbPage(&CbMsgPage);
 119
 120         if (pageCnt == CbMsgPage.pageHeader.totalPages)
 121         {
 122                 MSG_DEBUG("RECEIVED LAST MSG : %d", pageCnt);
 123
 124                 SMS_CBMSG_S *cbMsg = NULL;
 125                 unique_ptr<SMS_CBMSG_S*, void(*)(SMS_CBMSG_S**)> buf(&cbMsg, unique_ptr_deleter);
 126                 cbMsg = (SMS_CBMSG_S *)new char[sizeof(SMS_CBMSG_S)];
 127                 memset(cbMsg, 0x00, sizeof(SMS_CBMSG_S));
 128
 129                 MSG_MESSAGE_INFO_S msgInfo;
 130
 131                 /** initialize msgInfo */
 132                 memset(&msgInfo, 0x00, sizeof(MSG_MESSAGE_INFO_S));
 133
 134                 msgInfo.addressList = NULL;
 135                 unique_ptr<MSG_ADDRESS_INFO_S*, void(*)(MSG_ADDRESS_INFO_S**)> addressListBuf(&msgInfo.addressList, unique_ptr_deleter);
 136
 137                 // Make CB Msg Structure
 138                 MakeCbMsg(&CbMsgPage, cbMsg);
 139
 140                 // Convert to MSG_MESSAGE_INFO_S
 141                 convertCbMsgToMsginfo(cbMsg, &msgInfo, simIndex);
 142
 143                 // Add CB Msg into DB
 144                 msg_error_t err = MSG_SUCCESS;
 145
 146                 err = SmsPluginStorage::instance()->checkMessage(&msgInfo);
 147
 148                 if (err == MSG_SUCCESS)
 149                 {
 150                         MSG_CB_MSG_S cbOutMsg = {0, };
 151
 152                         cbOutMsg.type = MSG_CB_SMS;
 153                         cbOutMsg.receivedTime = cbMsg->recvTime;
 154                         cbOutMsg.serialNum = encodeCbSerialNum (CbMsgPage.pageHeader.serialNum);
 155                         cbOutMsg.messageId = cbMsg->msgId;
 156                         cbOutMsg.dcs = CbMsgPage.pageHeader.dcs.rawData;
 157                         memset (cbOutMsg.cbText, 0x00, sizeof(cbOutMsg.cbText));
 158
 159                         cbOutMsg.cbTextLen= convertTextToUtf8((unsigned char*)cbOutMsg.cbText, sizeof(cbOutMsg.cbText), cbMsg);
 160                         memset(cbOutMsg.language_type, 0x00, sizeof(cbOutMsg.language_type));
 161                         memcpy(cbOutMsg.language_type, CbMsgPage.pageHeader.dcs.iso639Lang, 3);
 162                         err = SmsPluginEventHandler::instance()->callbackCBMsgIncoming(&cbOutMsg, &msgInfo);
 163                         if (err != MSG_SUCCESS)
 164                         {
 165                                 MSG_DEBUG("callbackMsgIncoming() Error !! [%d]", err);
 166                         }
 167                 }
 168                 else
 169                 {
 170                         MSG_DEBUG("checkMessage() Error !! [%d]", err);
 171                 }
 172
 173 #if 0
 174                 // insert message-id to internal CB message table
 175                 SmsPluginStorage *storageHandler = SmsPluginStorage::instance();
 176                 err = storageHandler->insertReceivedCBMessage(CbMsgPage);
 177                 if (err != MSG_SUCCESS)
 178                 {
 179                         MSG_DEBUG("insertReceivedCBMessage() Error !! [%d]", err);
 180                 }
 181 #endif
 182                 // Remove From List
 183                 removeFromPageList(&CbMsgPage);
 184         }
 185         MSG_END();
 186 }
 187
 188
 189 void SmsPluginCbMsgHandler::handleEtwsMsg(TapiHandle *handle, TelSmsEtwsMsg_t *pEtwsMsg)
 190 {
 191         MSG_BEGIN();
 192         msg_error_t err = MSG_SUCCESS;
 193         TelSmsEtwsMsgType_t type = pEtwsMsg->EtwsMsgType;
 194         //MSG_MESSAGE_INFO_S msgInfo = {};
 195         SMS_ETWS_PRIMARY_S              etwsPn = {0, };
 196         MSG_CB_MSG_S                    cbOutMsg = {0, };
 197
 198         if(type != TAPI_NETTEXT_ETWS_PRIMARY)
 199         {
 200                 MSG_DEBUG("The Etws secondary Message");
 201                 handleCbMsg(handle, (TelSmsCbMsg_t *)pEtwsMsg);
 202                 return;
 203         }
 204         DecodeEtwsMsg(pEtwsMsg, &etwsPn);
 205         //convertEtwsMsgToMsginfo(&CbMsgPage, &msgInfo, simIndex);
 206
 207         cbOutMsg.type = MSG_ETWS_SMS;
 208         cbOutMsg.receivedTime = etwsPn.recvTime;
 209         cbOutMsg.serialNum = encodeCbSerialNum (etwsPn.serialNum);
 210         cbOutMsg.messageId = etwsPn.msgId;
 211         cbOutMsg.etwsWarningType = etwsPn.warningType;
 212         memcpy (cbOutMsg.etwsWarningSecurityInfo, etwsPn.warningSecurityInfo, sizeof(cbOutMsg.etwsWarningSecurityInfo));
 213
 214         err = SmsPluginEventHandler::instance()->callbackCBMsgIncoming(&cbOutMsg, NULL);
 215         if (err != MSG_SUCCESS)
 216         {
 217                 MSG_DEBUG("callbackMsgIncoming() Error !! [%d]", err);
 218         }
 219
 220         MSG_END();
 221 }
 222
 223
 224 void SmsPluginCbMsgHandler::Decode2gCbMsg(TelSmsCbMsg_t *pCbMsg, SMS_CBMSG_PAGE_S *pCbPage)
 225 {
 226         unsigned char cbData[pCbMsg->Length+1];
 227
 228         memset(cbData, 0x00, sizeof(cbData));
 229         memcpy(cbData, pCbMsg->szMsgData, pCbMsg->Length);
 230         cbData[pCbMsg->Length] = '\0';
 231
 232         // print cb data
 233         MSG_INFO("Received CB length:%d", pCbMsg->Length);
 234         char cbDataTmp[(pCbMsg->Length*2)+1];
 235         memset(cbDataTmp, 0x00, sizeof(cbDataTmp));
 236
 237         for (int i = 0; i < pCbMsg->Length; i++) {
 238                 snprintf(cbDataTmp+(i*2), sizeof(cbDataTmp)-(i*2), "%02X", cbData[i]);
 239         }
 240         MSG_INFO("[%s]", cbDataTmp);
 241
 242         pCbPage->cbMsgType = SMS_CBMSG_TYPE_CBS;
 243
 244         // Serial Number
 245         pCbPage->pageHeader.serialNum.geoScope = (cbData[0] & 0xC0) >> 6;
 246
 247         pCbPage->pageHeader.serialNum.msgCode = (cbData[0] & 0x3F) << 4;
 248         pCbPage->pageHeader.serialNum.msgCode |= (cbData[1] & 0xF0) >> 4;
 249
 250         pCbPage->pageHeader.serialNum.updateNum = cbData[1] & 0x0F;
 251
 252         MSG_DEBUG("geoScope : [%d], msgCode : [%d], updateNum : [%d]", pCbPage->pageHeader.serialNum.geoScope, pCbPage->pageHeader.serialNum.msgCode, pCbPage->pageHeader.serialNum.updateNum);
 253
 254         pCbPage->pageHeader.msgId = (cbData[2] << 8) | cbData[3];
 255
 256         MSG_DEBUG("MSG ID : [%d]", pCbPage->pageHeader.msgId);
 257
 258         // DCS
 259         decodeCbMsgDCS(cbData[4], (unsigned char*)cbData + 6, &(pCbPage->pageHeader.dcs));
 260
 261         // Page Parameter
 262         pCbPage->pageHeader.totalPages = cbData[5] & 0x0F;
 263         pCbPage->pageHeader.page = (cbData[5] & 0xF0) >> 4;
 264
 265         if (pCbPage->pageHeader.totalPages > MAX_CBMSG_PAGE_NUM)
 266                 THROW(MsgException::SMS_PLG_ERROR, "CB Page Count is over MAX[%d]", pCbPage->pageHeader.totalPages);
 267
 268         MSG_DEBUG("Total Page : [%d], Page : [%d]", pCbPage->pageHeader.totalPages, pCbPage->pageHeader.page);
 269
 270         // Convert Language Type
 271         convertLangType(pCbPage->pageHeader.dcs.langType, &(pCbPage->pageHeader.langType));
 272
 273         MSG_DEBUG("In Language Type : [%d], Out Language Type : [%d]", pCbPage->pageHeader.dcs.langType, pCbPage->pageHeader.langType);
 274         MSG_DEBUG("iso639Lang : [%s]", pCbPage->pageHeader.dcs.iso639Lang);
 275         // Get Receive Time
 276         pCbPage->pageHeader.recvTime = getRecvTime();
 277
 278         // Decode CB Data
 279         int dataLen = pCbMsg->Length - 6;
 280
 281         MSG_DEBUG("codingScheme:[%d]", pCbPage->pageHeader.dcs.codingScheme);
 282
 283         switch (pCbPage->pageHeader.dcs.codingScheme)
 284         {
 285                 case SMS_CHARSET_7BIT :
 286                 {
 287                         MSG_DEBUG("GSM 7 BIT");
 288
 289                         dataLen = (dataLen*8) / 7;
 290
 291                         SmsPluginUDCodec udCodec;
 292                         char pageData[MAX_CBMSG_PAGE_SIZE+1];
 293                         int unpackLen = udCodec.unpack7bitChar(&cbData[6], dataLen, 0, pageData);
 294
 295                         if(pCbPage->pageHeader.dcs.iso639Lang[0])
 296                         {
 297                                 unpackLen = unpackLen - 3;
 298                                 if (unpackLen > 0)
 299                                         memcpy(pCbPage->pageData, &pageData[3], unpackLen);
 300                                 else
 301                                         unpackLen = 0;
 302                         } else {
 303                                 memcpy(pCbPage->pageData, &pageData, unpackLen);
 304                         }
 305
 306                         MSG_DEBUG("unpackLen : [%d]", unpackLen);
 307
 308                         pCbPage->pageLength = unpackLen;
 309                         pCbPage->pageData[unpackLen] = '\0';
 310                 }
 311                 break;
 312
 313                 case SMS_CHARSET_8BIT :
 314                 case SMS_CHARSET_UCS2 :
 315                 {
 316                         MSG_DEBUG("UCS2 or 8BIT");
 317
 318                         if(pCbPage->pageHeader.dcs.iso639Lang[0])
 319                         {
 320                                 memcpy(pCbPage->pageData, &cbData[8], dataLen - 2);
 321                                 pCbPage->pageLength = dataLen - 2;
 322                         } else {
 323                                 memcpy(pCbPage->pageData, &cbData[6], dataLen);
 324                                 pCbPage->pageLength = dataLen;
 325                         }
 326                 }
 327                 break;
 328         }
 329
 330         MSG_DEBUG("Page Length : [%d], Page Data : [%s]", pCbPage->pageLength, pCbPage->pageData);
 331 }
 332
 333
 334 void SmsPluginCbMsgHandler::DecodeEtwsMsg(TelSmsEtwsMsg_t *pEtwsMsg, SMS_ETWS_PRIMARY_S *pEtwsPn)
 335 {
 336         if ( !pEtwsMsg || !pEtwsPn )
 337                 return;
 338
 339         if (pEtwsMsg->Length > MAX_ETWS_SIZE)
 340                 THROW(MsgException::SMS_PLG_ERROR, "ETWS Msg Size is over MAX [%d]", pEtwsMsg->Length);
 341
 342         unsigned char EtwsData[pEtwsMsg->Length+1];
 343
 344         memset(EtwsData, 0x00, sizeof(EtwsData));
 345         memcpy(EtwsData, pEtwsMsg->szMsgData, pEtwsMsg->Length);
 346         EtwsData[pEtwsMsg->Length] = '\0';
 347
 348         // print received msg data
 349         MSG_INFO("Received Etws length:%d", pEtwsMsg->Length);
 350         char EtwsDataTmp[(pEtwsMsg->Length*2)+1];
 351         memset(EtwsDataTmp, 0x00, sizeof(EtwsDataTmp));
 352
 353         for (int i = 0; i < pEtwsMsg->Length; i++) {
 354                 snprintf(EtwsDataTmp+(i*2), sizeof(EtwsDataTmp)-(i*2), "%02X", EtwsData[i]);
 355         }
 356         MSG_INFO("[%s]", EtwsDataTmp);
 357
 358         // received time
 359         pEtwsPn->recvTime = getRecvTime();
 360
 361         // Serial Number
 362         pEtwsPn->serialNum.geoScope = (EtwsData[0] & 0xC0) >> 6;
 363         pEtwsPn->serialNum.msgCode = (EtwsData[0] & 0x3F) << 4;
 364         pEtwsPn->serialNum.msgCode |= (EtwsData[1] & 0xF0) >> 4;
 365         pEtwsPn->serialNum.updateNum = EtwsData[1] & 0x0F;
 366
 367         MSG_DEBUG("geoScope : [%d], msgCode : [%d], updateNum : [%d]", pEtwsPn->serialNum.geoScope, pEtwsPn->serialNum.msgCode, pEtwsPn->serialNum.updateNum);
 368
 369         // Message Identifier
 370         pEtwsPn->msgId = (EtwsData[2] << 8) | EtwsData[3];
 371         MSG_DEBUG("MSG ID : [%d]", pEtwsPn->msgId);
 372
 373         // warning type
 374         pEtwsPn->warningType = (EtwsData[4] << 8) | EtwsData[5];
 375         MSG_DEBUG("warningType : [0x%04x]", pEtwsPn->msgId);
 376
 377         // warning security information
 378         memcpy(pEtwsPn->warningSecurityInfo, &EtwsData[6], sizeof(pEtwsPn->warningSecurityInfo));       // 50bytes
 379         for (unsigned int i = 0; i < sizeof(pEtwsPn->warningSecurityInfo); i++)
 380         {
 381                 MSG_DEBUG("warning secu info [%02x]", pEtwsPn->warningSecurityInfo[i] );
 382         }
 383 }
 384
 385 void SmsPluginCbMsgHandler::Decode3gCbMsg(TelSmsCbMsg_t *pCbMsg, SMS_CBMSG_PAGE_S *pCbPage)
 386 {
 387         unsigned char cbData[(MAX_CBMSG_PAGE_SIZE*MAX_CBMSG_PAGE_NUM)+1];
 388
 389         memset(cbData, 0x00, sizeof(cbData));
 390         memcpy(cbData, pCbMsg->szMsgData, pCbMsg->Length);
 391         cbData[pCbMsg->Length] = '\0';
 392
 393         // print cb data
 394         MSG_INFO("Received CB length:%d", pCbMsg->Length);
 395         char cbDataTmp[(pCbMsg->Length*2)+1];
 396         memset(cbDataTmp, 0x00, sizeof(cbDataTmp));
 397
 398         for (int i = 0; i < pCbMsg->Length; i++) {
 399                 snprintf(cbDataTmp+(i*2), sizeof(cbDataTmp)-(i*2), "%02X", cbData[i]);
 400         }
 401         MSG_INFO("[%s]", cbDataTmp);
 402
 403         pCbPage->cbMsgType = (SMS_CBMSG_TYPE_T)cbData[0];
 404
 405         pCbPage->pageHeader.msgId = (cbData[1] << 8) | cbData[2];
 406
 407         MSG_DEBUG("MSG ID : [%d]", pCbPage->pageHeader.msgId);
 408
 409         // Serial Number
 410         pCbPage->pageHeader.serialNum.geoScope = (cbData[3] & 0xC0) >> 6;
 411
 412         pCbPage->pageHeader.serialNum.msgCode = (cbData[3] & 0x3F) << 4;
 413         pCbPage->pageHeader.serialNum.msgCode |= (cbData[4] & 0xF0) >> 4;
 414
 415         pCbPage->pageHeader.serialNum.updateNum = cbData[4] & 0x0F;
 416
 417         MSG_DEBUG("geoScope : [%d], msgCode : [%d], updateNum : [%d]", pCbPage->pageHeader.serialNum.geoScope, pCbPage->pageHeader.serialNum.msgCode, pCbPage->pageHeader.serialNum.updateNum);
 418
 419         // DCS
 420         decodeCbMsgDCS(cbData[5], (unsigned char*)cbData + 6, &(pCbPage->pageHeader.dcs));
 421
 422         // Convert Language Type
 423         convertLangType(pCbPage->pageHeader.dcs.langType, &(pCbPage->pageHeader.langType));
 424
 425         MSG_DEBUG("In Language Type : [%d], Out Language Type : [%d]", pCbPage->pageHeader.dcs.langType, pCbPage->pageHeader.langType);
 426
 427         // Get Receive Time
 428         pCbPage->pageHeader.recvTime = getRecvTime();
 429         pCbPage->pageHeader.totalPages = cbData[6];
 430
 431         // Decode CB Data
 432         int dataLen = 0;
 433         int offset = 0;
 434
 435         switch (pCbPage->pageHeader.dcs.codingScheme)
 436         {
 437                 case SMS_CHARSET_7BIT :
 438                 {
 439                         for(int i = 0; i < pCbPage->pageHeader.totalPages; ++i)
 440                         {
 441                                 char cbMessage[MAX_CBMSG_PAGE_SIZE]= {0,};
 442                                 dataLen = cbData[7+(i+1)*82 + i];
 443                                 memcpy(cbMessage, &cbData[7+(i*82)+ i], dataLen);
 444
 445                                 dataLen = (dataLen*8) / 7;
 446
 447                                 if (dataLen > MAX_CBMSG_PAGE_SIZE)
 448                                         THROW(MsgException::SMS_PLG_ERROR, "CB Msg Size is over MAX [%d]", dataLen);
 449
 450                                 SmsPluginUDCodec udCodec;
 451                                 int unpackLen = udCodec.unpack7bitChar((const unsigned char *)cbMessage, dataLen, 0, pCbPage->pageData + offset);
 452                                 offset += unpackLen;
 453                         }
 454                         pCbPage->pageLength = offset;
 455                 }
 456                 break;
 457
 458                 case SMS_CHARSET_8BIT :
 459                 case SMS_CHARSET_UCS2 :
 460                 {
 461 #if 0
 462                         char cbMessage[MAX_CBMSG_PAGE_SIZE]= {0,};
 463
 464                         for(int i = 0; i < pCbPage->pageHeader.totalPages; ++i)
 465                         {
 466                                 dataLen = cbData[7+(i+1)*82 + i];
 467                                 memcpy(cbMessage + offset, &cbData[7+(i*82)+ i], dataLen);
 468                                 offset += dataLen;
 469                         }
 470                         dataLen = offset;
 471
 472                         if(pCbPage->pageHeader.dcs.iso639Lang[0])
 473                         {
 474                                 int tmpDataLen = (dataLen > 2)?(dataLen - 2):0;
 475                                 memcpy(pCbPage->pageData, cbMessage + 2, tmpDataLen);
 476                                 pCbPage->pageLength = tmpDataLen;
 477                         } else {
 478                                 memcpy(pCbPage->pageData, cbMessage, dataLen);
 479                                 pCbPage->pageLength = dataLen;
 480                         }
 481 #else
 482                         char cbMessage[MAX_CBMSG_PAGE_SIZE]= {0,};
 483
 484                         for(int i = 0; i < pCbPage->pageHeader.totalPages; ++i)
 485                         {
 486                                 if(pCbPage->pageHeader.dcs.iso639Lang[0])
 487                                 {
 488                                         dataLen = cbData[7+(i+1)*82 + i] - 2;
 489                                         memcpy(cbMessage + offset, &cbData[7+(i*82)+ i + 2], dataLen);
 490                                         offset += dataLen;
 491                                 } else {
 492                                         dataLen = cbData[7+(i+1)*82 + i];
 493                                         memcpy(cbMessage + offset, &cbData[7+(i*82)+ i], dataLen);
 494                                         offset += dataLen;
 495                                 }
 496                         }
 497                         dataLen = offset;
 498                         memcpy(pCbPage->pageData, cbMessage, dataLen);
 499                         pCbPage->pageLength = dataLen;
 500 #endif
 501                 }
 502                 break;
 503         }
 504         pCbPage->pageHeader.totalPages = 1;
 505
 506         MSG_DEBUG("Page Length : [%d], Page Data : [%s]", pCbPage->pageLength, pCbPage->pageData);
 507 }
 508
 509 unsigned short SmsPluginCbMsgHandler::encodeCbSerialNum ( SMS_CBMSG_SERIAL_NUM_S snFields )
 510 {
 511         unsigned short serialNum = 0;
 512
 513         serialNum = ((snFields.geoScope & 0x03) << 14) | ((snFields.msgCode&0x03FF) << 4) | (snFields.updateNum&0x0F);
 514         MSG_DEBUG ("serialNum (%x), geo(%x), mc(%x), un(%x)\n", serialNum, snFields.geoScope, snFields.msgCode, snFields.updateNum);
 515
 516         return serialNum;
 517 }
 518
 519 int SmsPluginCbMsgHandler::CMAS_class(unsigned short message_id)
 520 {
 521         int ret = 0;
 522
 523         switch (message_id)
 524         {
 525                 case 4370 :
 526                 case 4383 :
 527                         ret = MSG_CMAS_PRESIDENTIAL;
 528                         break;
 529                 case 4371 :
 530                 case 4372 :
 531                 case 4384 :
 532                 case 4385 :
 533                         ret = MSG_CMAS_EXTREME;
 534                         break;
 535                 case 4373 :
 536                 case 4374 :
 537                 case 4375 :
 538                 case 4376 :
 539                 case 4377 :
 540                 case 4378 :
 541                 case 4386 :
 542                 case 4387 :
 543                 case 4388 :
 544                 case 4389 :
 545                 case 4390 :
 546                 case 4391 :
 547                         ret = MSG_CMAS_SEVERE;
 548                         break;
 549                 case 4379 :
 550                 case 4392 :
 551                         ret = MSG_CMAS_AMBER;
 552                         break;
 553                 case 4380 :
 554                 case 4381 :
 555                 case 4393 :
 556                 case 4394 :
 557                         ret = MSG_CMAS_TEST;
 558                         break;
 559                 case 4382 :
 560                 case 4395 :
 561                         ret = MSG_CMAS_OPERATOR_DEFINED;
 562                         break;
 563                 default :
 564                         break;
 565         }
 566
 567         return ret;
 568 }
 569
 570 bool SmsPluginCbMsgHandler::checkCbOpt(SMS_CBMSG_PAGE_S *CbPage, bool *pJavaMsg, msg_sim_slot_id_t simIndex)
 571 {
 572         bool bReceive = false;
 573         char keyName[MAX_VCONFKEY_NAME_LEN];
 574         memset(keyName, 0x00, sizeof(keyName));
 575         snprintf(keyName, sizeof(keyName), "%s/%d", CB_RECEIVE, simIndex);
 576         MsgSettingGetBool(keyName, &bReceive);
 577
 578         // Receive CB Msg = FALSE
 579         if (!bReceive)
 580         {
 581                 MSG_DEBUG("RECEIVE CB = FALSE");
 582                 return false;
 583         }
 584
 585 #if 0
 586         char keyname[128];
 587         // check Language
 588         memset(keyName, 0x00, sizeof(keyName));
 589         snprintf(keyName, sizeof(keyname), "%s/%d", CB_LANGUAGE, MSG_CBLANG_TYPE_ALL);
 590
 591         bool bAllLang = false;
 592         MsgSettingGetBool(keyName, &bAllLang);
 593
 594         if (!bAllLang)
 595         {
 596                 MSG_DEBUG("ALL LANGUAGE = FALSE");
 597
 598                 memset(keyName, 0x00, sizeof(keyName));
 599                 snprintf(keyName, sizeof(keyname), "%s/%d", CB_LANGUAGE, CbPage.pageHeader.langType);
 600
 601                 bool bLang = false;
 602
 603                 MsgSettingGetBool(keyName, &bLang);
 604
 605                 if (!bLang || CbPage.pageHeader.langType == MSG_CBLANG_TYPE_MAX)
 606                 {
 607                         MSG_DEBUG("LANGUAGE [%d] = FALSE", CbPage.pageHeader.langType);
 608                         return false;
 609                 }
 610         }
 611 #endif
 612
 613         bool bActivate = false;
 614         int MsgId_from = 0, MsgId_to = 0;
 615         MSG_CB_CHANNEL_S cbChannelInfo = {0,};
 616         msg_error_t err = MSG_SUCCESS;
 617         MsgDbHandler *dbHandle = getDbHandle();
 618
 619         err = MsgStoGetCBChannelInfo(dbHandle, &cbChannelInfo, simIndex);
 620         if (err != MSG_SUCCESS)
 621                 MSG_ERR("Error value of MsgStoGetCBChannelInfo [%d]", err);
 622
 623         for (int i = 0; i < cbChannelInfo.channelCnt; i++)
 624         {
 625                 bActivate = cbChannelInfo.channelInfo[i].bActivate;
 626                 MsgId_from = cbChannelInfo.channelInfo[i].from;
 627                 MsgId_to = cbChannelInfo.channelInfo[i].to;
 628
 629                 if (bActivate == true && CbPage->pageHeader.msgId >= MsgId_from && CbPage->pageHeader.msgId <= MsgId_to)
 630                 {
 631                         MSG_DEBUG("FIND CHANNEL = [%d]", CbPage->pageHeader.msgId);
 632                         return true;
 633                 }
 634         }
 635
 636         return false;
 637 }
 638
 639 unsigned char SmsPluginCbMsgHandler::checkCbPage(SMS_CBMSG_PAGE_S *CbPage)
 640 {
 641         unsigned char currPageCnt = 0;
 642
 643         bool bFind = false;
 644
 645 #if 0
 646         msg_error_t err = MSG_SUCCESS;
 647
 648         SmsPluginStorage *storageHandler = SmsPluginStorage::instance();
 649         err = storageHandler->isReceivedCBMessage(CbPage);
 650         // check existing message with cb internal table;
 651         if(err != MSG_ERR_DB_NORECORD)
 652         {
 653                 MSG_DEBUG("already received message: [%d]", CbPage.pageHeader.msgId);
 654                 return 0;
 655         }
 656 #endif
 657
 658         if (CbPage->pageHeader.totalPages > 0)
 659         {
 660                 for (unsigned int i = 0; i < pageList.size(); i++)
 661                 {
 662                         if (pageList[i].geoScope == CbPage->pageHeader.serialNum.geoScope && pageList[i].msgCode == CbPage->pageHeader.serialNum.msgCode)
 663                         {
 664                                 MSG_DEBUG("geoScope [%d], msgCode [%d]", pageList[i].geoScope, pageList[i].msgCode);
 665
 666                                 if (pageList[i].msgId == CbPage->pageHeader.msgId)
 667                                 {
 668                                         int updateNum = CbPage->pageHeader.serialNum.updateNum - pageList[i].updateNum;
 669
 670                                         if (updateNum > 0) // New Message Content
 671                                         {
 672                                                 break;
 673                                         }
 674                                         else if (updateNum == 0) // Same Message Content
 675                                         {
 676                                                 if (pageList[i].data.count(CbPage->pageHeader.page) != 0)
 677                                                 {
 678                                                         MSG_DEBUG("The Page Number already exists [%d]", CbPage->pageHeader.page);
 679                                                         return 0;
 680                                                 }
 681
 682                                                 pair<unsigned char, SMS_CBMSG_PAGE_S> newData(CbPage->pageHeader.page, *CbPage);
 683                                                 pageList[i].data.insert(newData);
 684
 685                                                 MSG_DEBUG("PAGE DATA : %s", CbPage->pageData);
 686                                                 MSG_DEBUG("PAIR DATA [%d] : %s", newData.first, newData.second.pageData);
 687
 688                                                 pageList[i].pageCnt++;
 689                                                 pageList[i].totalSize += CbPage->pageLength;
 690
 691                                                 currPageCnt = pageList[i].pageCnt;
 692
 693                                                 bFind = true;
 694
 695                                                 break;
 696                                         }
 697                                         else // Old Message Content
 698                                         {
 699                                                 return 0;
 700                                         }
 701                                 }
 702                         }
 703                 }
 704         }
 705
 706         if (bFind == false || CbPage->pageHeader.totalPages == 1)
 707         {
 708                 addToPageList(CbPage);
 709                 return 1;
 710         }
 711
 712         return currPageCnt;
 713 }
 714
 715
 716 void SmsPluginCbMsgHandler::MakeCbMsg(SMS_CBMSG_PAGE_S *CbPage, SMS_CBMSG_S *pCbMsg)
 717 {
 718         pCbMsg->cbMsgType = CbPage->cbMsgType;
 719         pCbMsg->msgId = CbPage->pageHeader.msgId;
 720         pCbMsg->classType = CbPage->pageHeader.dcs.classType;
 721         pCbMsg->codingScheme = CbPage->pageHeader.dcs.codingScheme;
 722         pCbMsg->recvTime = CbPage->pageHeader.recvTime;
 723
 724         cbPageMap::iterator it;
 725         int offset = 0;
 726
 727         for (unsigned int i = 0; i < pageList.size(); i++)
 728         {
 729                 if (pageList[i].geoScope == CbPage->pageHeader.serialNum.geoScope && pageList[i].msgCode == CbPage->pageHeader.serialNum.msgCode)
 730                 {
 731                         MSG_DEBUG("geoScope [%d], msgCode [%d]", pageList[i].geoScope, pageList[i].msgCode);
 732
 733                         if (pageList[i].msgId == CbPage->pageHeader.msgId)
 734                         {
 735
 736                                 for (it = pageList[i].data.begin(); it != pageList[i].data.end(); it++)
 737                                 {
 738                                         memcpy(pCbMsg->msgData + offset, it->second.pageData, it->second.pageLength);
 739                                         pCbMsg->msgLength += it->second.pageLength;
 740                                         offset = pCbMsg->msgLength;
 741                                 }
 742                         }
 743                 }
 744         }
 745
 746 #if 0
 747         pCbMsg->msgLength = tmpStr.size();
 748
 749         memcpy(pCbMsg->msgData, tmpStr.c_str(), tmpStr.size());
 750         pCbMsg->msgData[tmpStr.size()] = '\0';
 751
 752         MSG_DEBUG("SIZE : [%d] TOTAL MSG : %s", tmpStr.size(), tmpStr.c_str());
 753 #endif
 754 }
 755
 756
 757 void SmsPluginCbMsgHandler::convertCbMsgToMsginfo(SMS_CBMSG_S *pCbMsg, MSG_MESSAGE_INFO_S *pMsgInfo, msg_sim_slot_id_t simIndex)
 758 {
 759         pMsgInfo->msgId = (msg_message_id_t)pCbMsg->msgId;
 760
 761         pMsgInfo->folderId = MSG_CBMSGBOX_ID;
 762
 763         // Convert Type values
 764         pMsgInfo->msgType.mainType = MSG_SMS_TYPE;
 765
 766         if (pCbMsg->cbMsgType == SMS_CBMSG_TYPE_CBS) {
 767                 int cmas_class = CMAS_class(pCbMsg->msgId);
 768
 769                 if (cmas_class == 0)
 770                         pMsgInfo->msgType.subType = MSG_CB_SMS;
 771                 else
 772                         pMsgInfo->msgType.subType = (MSG_SUB_TYPE_T)cmas_class;
 773         }
 774         else if (pCbMsg->cbMsgType == SMS_CBMSG_TYPE_JAVACBS) {
 775                 pMsgInfo->msgType.subType = MSG_JAVACB_SMS;
 776         }
 777
 778         switch(pCbMsg->classType)
 779         {
 780                 case SMS_MSG_CLASS_0:
 781                         pMsgInfo->msgType.classType = MSG_CLASS_0;
 782                         break;
 783                 case SMS_MSG_CLASS_1:
 784                         pMsgInfo->msgType.classType = MSG_CLASS_1;
 785                         break;
 786                 case SMS_MSG_CLASS_2:
 787                         pMsgInfo->msgType.classType = MSG_CLASS_2;
 788                         break;
 789                 case SMS_MSG_CLASS_3:
 790                         pMsgInfo->msgType.classType = MSG_CLASS_3;
 791                         break;
 792                 default:
 793                         pMsgInfo->msgType.classType = MSG_CLASS_NONE;
 794                         break;
 795         }
 796
 797         pMsgInfo->storageId = MSG_STORAGE_PHONE;
 798         pMsgInfo->networkStatus = MSG_NETWORK_RECEIVED;
 799         pMsgInfo->bRead = false;
 800         pMsgInfo->bProtected = false;
 801         pMsgInfo->priority = MSG_MESSAGE_PRIORITY_NORMAL;
 802         pMsgInfo->direction = MSG_DIRECTION_TYPE_MT;
 803
 804         // Temporary
 805         pMsgInfo->nAddressCnt = 1;
 806
 807         pMsgInfo->addressList =  (MSG_ADDRESS_INFO_S *)new char[sizeof(MSG_ADDRESS_INFO_S)];
 808         memset(pMsgInfo->addressList, 0x00, sizeof(MSG_ADDRESS_INFO_S));
 809
 810         pMsgInfo->addressList[0].addressType = MSG_ADDRESS_TYPE_UNKNOWN;
 811         pMsgInfo->addressList[0].recipientType = MSG_RECIPIENTS_TYPE_UNKNOWN;
 812         pMsgInfo->sim_idx = simIndex;
 813
 814         //      TODO :: MSG ID should be used to get CB message type
 815         getDisplayName(pCbMsg->msgId, pMsgInfo->addressList[0].addressVal, simIndex);
 816         MSG_SEC_DEBUG("%s", pMsgInfo->addressList[0].addressVal);
 817
 818
 819         pMsgInfo->msgPort.valid = false;
 820         pMsgInfo->msgPort.dstPort = 0;
 821         pMsgInfo->msgPort.srcPort = 0;
 822
 823         pMsgInfo->displayTime = pCbMsg->recvTime;
 824         MSG_DEBUG("recvTime is %d", pMsgInfo->displayTime);
 825
 826         int bufSize = pCbMsg->msgLength*2;
 827
 828         char tmpBuf[bufSize];
 829         memset(tmpBuf, 0x00, sizeof(tmpBuf));
 830
 831         while (pCbMsg->msgLength > 0) {
 832                 if (pCbMsg->msgData[pCbMsg->msgLength-1] == ' ' ||
 833                                 pCbMsg->msgData[pCbMsg->msgLength-1] == '\r' ||
 834                                 pCbMsg->msgData[pCbMsg->msgLength-1] == '\n') {
 835                         pCbMsg->msgLength--;
 836                 }
 837                 else {
 838                         break;
 839                 }
 840         }
 841         pCbMsg->msgData[pCbMsg->msgLength] = '\0';
 842
 843         MSG_DEBUG("LENGTH %d CB MSG %s", pCbMsg->msgLength, pCbMsg->msgData);
 844
 845         // Convert Data values
 846         pMsgInfo->dataSize = convertTextToUtf8((unsigned char*)tmpBuf, bufSize, pCbMsg);
 847
 848         if (pMsgInfo->dataSize > MAX_MSG_TEXT_LEN)
 849         {
 850                 pMsgInfo->bTextSms = false;
 851
 852                 // Save Message Data into File
 853                 char fileName[MSG_FILENAME_LEN_MAX+1];
 854                 memset(fileName, 0x00, sizeof(fileName));
 855
 856                 if (MsgCreateFileName(fileName) == false)
 857                         THROW(MsgException::FILE_ERROR, "MsgCreateFileName error");
 858
 859                 MSG_SEC_DEBUG("Save Message Data into file : size[%d] name[%s]\n", pMsgInfo->dataSize, fileName);
 860                 if (MsgWriteIpcFile(fileName, tmpBuf, pMsgInfo->dataSize) == false)
 861                         THROW(MsgException::FILE_ERROR, "MsgWriteIpcFile error");
 862
 863                 strncpy(pMsgInfo->msgData, fileName, MAX_MSG_DATA_LEN);
 864         }
 865         else
 866         {
 867                 pMsgInfo->bTextSms = true;
 868
 869                 memset(pMsgInfo->msgText, 0x00, sizeof(pMsgInfo->msgText));
 870                 memcpy(pMsgInfo->msgText, tmpBuf, pMsgInfo->dataSize);
 871                 pMsgInfo->dataSize = strlen(pMsgInfo->msgText);
 872                 MSG_SEC_DEBUG("CB MSG %s", pMsgInfo->msgText);
 873         }
 874 }
 875
 876
 877 void SmsPluginCbMsgHandler::convertEtwsMsgToMsginfo(SMS_CBMSG_PAGE_S *EtwsMsg, MSG_MESSAGE_INFO_S *pMsgInfo, msg_sim_slot_id_t simIndex)
 878 {
 879         pMsgInfo->msgId = (msg_message_id_t)EtwsMsg->pageHeader.msgId;
 880
 881         pMsgInfo->folderId = MSG_CBMSGBOX_ID;
 882
 883         // Convert Type values
 884         pMsgInfo->msgType.mainType = MSG_SMS_TYPE;
 885
 886         if (EtwsMsg->cbMsgType == SMS_CBMSG_TYPE_ETWS)
 887                 pMsgInfo->msgType.subType = MSG_ETWS_SMS;
 888
 889         pMsgInfo->storageId = MSG_STORAGE_PHONE;
 890         pMsgInfo->networkStatus = MSG_NETWORK_RECEIVED;
 891         pMsgInfo->bRead = false;
 892         pMsgInfo->bProtected = false;
 893         pMsgInfo->priority = MSG_MESSAGE_PRIORITY_NORMAL;
 894         pMsgInfo->direction = MSG_DIRECTION_TYPE_MT;
 895
 896         // Temporary
 897         pMsgInfo->nAddressCnt = 1;
 898
 899         pMsgInfo->addressList[0].addressType = MSG_ADDRESS_TYPE_UNKNOWN;
 900         pMsgInfo->addressList[0].recipientType = MSG_RECIPIENTS_TYPE_UNKNOWN;
 901
 902         getDisplayName(EtwsMsg->pageHeader.msgId, pMsgInfo->addressList[0].addressVal, simIndex);
 903         MSG_SEC_DEBUG("%s", pMsgInfo->addressList[0].addressVal);
 904
 905         pMsgInfo->msgPort.valid = false;
 906         pMsgInfo->msgPort.dstPort = 0;
 907         pMsgInfo->msgPort.srcPort = 0;
 908
 909         pMsgInfo->displayTime = EtwsMsg->pageHeader.recvTime;
 910         MSG_DEBUG("recvTime is %d", pMsgInfo->displayTime);
 911         MSG_DEBUG("LENGTH %d", EtwsMsg->pageLength);
 912         pMsgInfo->bTextSms = true;
 913         pMsgInfo->dataSize = EtwsMsg->pageLength;
 914         memset(pMsgInfo->msgData, 0x00, sizeof(pMsgInfo->msgData));
 915         memcpy(pMsgInfo->msgData, EtwsMsg->pageData, pMsgInfo->dataSize);
 916 }
 917
 918 int SmsPluginCbMsgHandler::convertTextToUtf8 (unsigned char* outBuf, int outBufSize, SMS_CBMSG_S* pCbMsg)
 919 {
 920         int     convertedTextSize = 0;
 921         MSG_LANG_INFO_S langInfo = {0,};
 922
 923         MsgTextConvert *textCvt = MsgTextConvert::instance();
 924
 925         if (!outBuf || !pCbMsg)
 926         {
 927                 MSG_DEBUG ("invalid param.\n");
 928                 return 0;
 929         }
 930
 931         langInfo.bSingleShift = false;
 932         langInfo.bLockingShift = false;
 933
 934
 935         // Convert Data values
 936         if (pCbMsg->codingScheme == SMS_CHARSET_7BIT)
 937                 convertedTextSize = textCvt->convertGSM7bitToUTF8(outBuf, outBufSize, (unsigned char*)pCbMsg->msgData, pCbMsg->msgLength, &langInfo);
 938         else if (pCbMsg->codingScheme == SMS_CHARSET_UCS2)
 939                 convertedTextSize = textCvt->convertUCS2ToUTF8(outBuf, outBufSize, (unsigned char*)pCbMsg->msgData, pCbMsg->msgLength);
 940
 941         return convertedTextSize;
 942 }
 943
 944 void SmsPluginCbMsgHandler::addToPageList(SMS_CBMSG_PAGE_S *CbPage)
 945 {
 946         CB_PAGE_INFO_S tmpInfo;
 947
 948         tmpInfo.geoScope = CbPage->pageHeader.serialNum.geoScope;
 949         tmpInfo.msgCode = CbPage->pageHeader.serialNum.msgCode;
 950         tmpInfo.updateNum = CbPage->pageHeader.serialNum.updateNum;
 951         tmpInfo.msgId = CbPage->pageHeader.msgId;
 952         tmpInfo.totalPages = CbPage->pageHeader.totalPages;
 953
 954         tmpInfo.pageCnt = 1;
 955         tmpInfo.totalSize = CbPage->pageLength;
 956
 957         pair<unsigned char, SMS_CBMSG_PAGE_S> newData(CbPage->pageHeader.page, *CbPage);
 958         tmpInfo.data.insert(newData);
 959
 960         MSG_DEBUG("MSG DATA : %s", CbPage->pageData);
 961         MSG_DEBUG("PAIR DATA [%d] : %s", newData.first, newData.second.pageData);
 962
 963         pageList.push_back(tmpInfo);
 964 }
 965
 966
 967 void SmsPluginCbMsgHandler::removeFromPageList(SMS_CBMSG_PAGE_S *CbPage)
 968 {
 969         unsigned int index;
 970
 971         for (index = 0; index < pageList.size(); index++)
 972         {
 973                 if (pageList[index].geoScope == CbPage->pageHeader.serialNum.geoScope && pageList[index].msgCode == CbPage->pageHeader.serialNum.msgCode)
 974                 {
 975                         MSG_DEBUG("geoScope [%d], msgCode [%d]", pageList[index].geoScope, pageList[index].msgCode);
 976
 977                         if (pageList[index].msgId == CbPage->pageHeader.msgId) break;
 978                 }
 979         }
 980
 981         MSG_DEBUG("remove index [%d]", index);
 982
 983         pageList.erase(pageList.begin()+index);
 984 }
 985
 986
 987 void SmsPluginCbMsgHandler::decodeCbMsgDCS(unsigned char dcsData, const unsigned char *pMsgData, SMS_CBMSG_DCS_S* pDcs)
 988 {
 989         pDcs->codingGroup = SMS_CBMSG_CODGRP_GENERAL_DCS;
 990         pDcs->classType = SMS_MSG_CLASS_NONE;
 991         pDcs->bCompressed = false;
 992         pDcs->codingScheme = SMS_CHARSET_7BIT;
 993         pDcs->langType = SMS_CBMSG_LANG_UNSPECIFIED;
 994         memset(pDcs->iso639Lang, 0x00, sizeof(pDcs->iso639Lang));
 995         pDcs->bUDH = false;
 996         pDcs->rawData = dcsData;
 997
 998         unsigned char codingGrp = (dcsData & 0xF0) >> 4;
 999
1000         switch (codingGrp)
1001         {
1002                 case 0x00 :
1003                 case 0x02 :
1004                 case 0x03 :
1005                 {
1006                         pDcs->codingGroup = SMS_CBMSG_CODGRP_GENERAL_DCS;
1007                         pDcs->langType = (SMS_CBMSG_LANG_TYPE_T)dcsData;
1008                 }
1009                 break;
1010
1011                 case 0x01 :
1012                 {
1013                         if (dcsData == 0x10 || dcsData == 0x11)
1014                         {
1015                                 pDcs->codingGroup = SMS_CBMSG_CODGRP_GENERAL_DCS;
1016                                 pDcs->codingScheme = (dcsData & 0x01) ? SMS_CHARSET_UCS2 : SMS_CHARSET_7BIT;
1017                                 pDcs->langType = SMS_CBMSG_LANG_ISO639;
1018                                 MSG_DEBUG("codingScheme: [%d]", pDcs->codingScheme);
1019                                 if (pMsgData[0] && pMsgData[1])
1020                                 {
1021                                         pDcs->iso639Lang[0] = pMsgData[0] & 0x7F;
1022                                         pDcs->iso639Lang[1] = (pMsgData[0] & 0X80) >> 7;
1023                                         pDcs->iso639Lang[1] |= (pMsgData[1] & 0X3F) << 1;
1024                                         pDcs->iso639Lang[2] = 0x13;  /* CR */
1025                                 }
1026                                 else
1027                                 {
1028                                         /* Default it to English if pMsgData is NULL */
1029                                         pDcs->iso639Lang[0] = 0x45;  /* E */
1030                                         pDcs->iso639Lang[1] = 0x4E;  /* N */
1031                                         pDcs->iso639Lang[2] = 0x13;  /* CR */
1032                                 }
1033                         }
1034                 }
1035                 break;
1036
1037                 case 0x04 :
1038                 case 0x05 :
1039                 case 0x06 :
1040                 case 0x07 :
1041                 {
1042                         pDcs->codingGroup = SMS_CBMSG_CODGRP_GENERAL_DCS;
1043
1044                         pDcs->bCompressed = (dcsData & 0x20) ? true : false;
1045
1046                         if (dcsData & 0x10)
1047                                 pDcs->classType = (SMS_MSG_CLASS_T)(dcsData & 0x03);
1048
1049                         unsigned char tmpScheme = (dcsData & 0x0C) >> 2;
1050
1051                         switch (tmpScheme) {
1052                                 case 0x00:
1053                                         pDcs->codingScheme = SMS_CHARSET_7BIT;
1054                                         break;
1055                                 case 0x01:
1056                                         pDcs->codingScheme = SMS_CHARSET_8BIT;
1057                                         break;
1058                                 case 0x02:
1059                                         pDcs->codingScheme = SMS_CHARSET_UCS2;
1060                                         break;
1061                                 default:
1062                                         MSG_DEBUG("tmpScheme: [%d]", tmpScheme);
1063                                         break;
1064                         }
1065                 }
1066                 break;
1067
1068                 case 0x09 :
1069                 {
1070                         pDcs->bUDH = true;
1071                         pDcs->classType = (MSG_CLASS_TYPE_T)(dcsData & 0x03);
1072                         pDcs->codingScheme = (SMS_CODING_SCHEME_T)((dcsData & 0x0C) >> 2);
1073                 }
1074                 break;
1075
1076                 case 0x0E :
1077                 {
1078                         pDcs->codingGroup = SMS_CBMSG_CODGRP_WAP;
1079                 }
1080                 break;
1081
1082                 case 0x0F :
1083                 {
1084                         pDcs->codingGroup = SMS_CBMSG_CODGRP_CLASS_CODING;
1085                         pDcs->codingScheme = (dcsData & 0x04) ? SMS_CHARSET_8BIT : SMS_CHARSET_7BIT;
1086                         pDcs->classType = (MSG_CLASS_TYPE_T)(dcsData & 0x03);
1087                 }
1088                 break;
1089                 default:
1090                         MSG_DEBUG("codingGrp: [0x%x]", codingGrp);
1091                 break;
1092         }
1093 }
1094
1095
1096 void SmsPluginCbMsgHandler::convertLangType(SMS_CBMSG_LANG_TYPE_T InType , MSG_CB_LANGUAGE_TYPE_T *pOutType)
1097 {
1098         switch (InType)
1099         {
1100                 case SMS_CBMSG_LANG_GERMAN :
1101                         *pOutType = MSG_CBLANG_TYPE_GER;
1102                 break;
1103
1104                 case SMS_CBMSG_LANG_ENGLISH :
1105                         *pOutType = MSG_CBLANG_TYPE_ENG;
1106                 break;
1107
1108                 case SMS_CBMSG_LANG_ITALIAN :
1109                         *pOutType = MSG_CBLANG_TYPE_ITA;
1110                 break;
1111
1112                 case SMS_CBMSG_LANG_FRENCH :
1113                         *pOutType = MSG_CBLANG_TYPE_FRE;
1114                 break;
1115
1116                 case SMS_CBMSG_LANG_SPANISH :
1117                         *pOutType = MSG_CBLANG_TYPE_SPA;
1118                 break;
1119
1120                 case SMS_CBMSG_LANG_DUTCH :
1121                         *pOutType = MSG_CBLANG_TYPE_NED;
1122                 break;
1123
1124                 case SMS_CBMSG_LANG_SWEDISH :
1125                         *pOutType = MSG_CBLANG_TYPE_SWE;
1126                 break;
1127
1128                 case SMS_CBMSG_LANG_PORTUGUESE :
1129                         *pOutType = MSG_CBLANG_TYPE_POR;
1130                 break;
1131
1132                 case SMS_CBMSG_LANG_TURKISH :
1133                         *pOutType = MSG_CBLANG_TYPE_TUR;
1134                 break;
1135
1136                 default :
1137                         *pOutType = MSG_CBLANG_TYPE_MAX;
1138                 break;
1139         }
1140 }
1141
1142
1143 unsigned long SmsPluginCbMsgHandler::getRecvTime()
1144 {
1145         time_t recvTime;
1146
1147         recvTime = time(NULL);
1148
1149         return (unsigned long)recvTime;
1150 }
1151
1152
1153 void SmsPluginCbMsgHandler::getDisplayName(unsigned short       MsgId, char *pDisplayName, msg_sim_slot_id_t simIndex)
1154 {
1155         MSG_CB_CHANNEL_S cbChannelInfo = {0,};
1156         msg_error_t err = MSG_SUCCESS;
1157         MsgDbHandler *dbHandle = getDbHandle();
1158
1159         err = MsgStoGetCBChannelInfo(dbHandle, &cbChannelInfo, simIndex);
1160         MSG_DEBUG("MsgStoGetCBChannelInfo [err = %d]", err);
1161
1162         for (int i = 0; i < cbChannelInfo.channelCnt; i++)
1163         {
1164                 if (MsgId >= cbChannelInfo.channelInfo[i].from && MsgId <= cbChannelInfo.channelInfo[i].to)
1165                 {
1166                         MSG_DEBUG("FIND MSG ID = [%d]", MsgId);
1167 #if 0
1168                         char strTmp[CB_CHANNEL_NAME_MAX + 1];
1169                         memset(strTmp, 0x00, sizeof(strTmp));
1170
1171                         strncpy(strTmp, cbChannelInfo.channelInfo[i].name, CB_CHANNEL_NAME_MAX);
1172
1173                         if (strlen(strTmp) > 0)
1174                                 snprintf(pDisplayName, sizeof(strTmp), "[%s]", strTmp);
1175                         else
1176                                 snprintf(pDisplayName, sizeof(unsigned short), "[%d]", MsgId);
1177 #else
1178
1179 #ifdef MSG_NOTI_INTEGRATION
1180                         snprintf(pDisplayName, MAX_ADDRESS_VAL_LEN + 1, "CB message");
1181 #else
1182                         snprintf(pDisplayName, MAX_ADDRESS_VAL_LEN + 1, "[%d]", MsgId);
1183 #endif
1184
1185 #endif
1186
1187                         return;
1188                 }
1189         }
1190
1191         snprintf(pDisplayName, MAX_ADDRESS_VAL_LEN + 1, "[%d]", MsgId);
1192 }
1193