plugin/sms_plugin/SmsPluginCbMsgHandler.cpp

   1 /*
   2 *
   3 * Copyright (c) 2000-2012 Samsung Electronics Co., Ltd. All Rights Reserved.
   4 *
   5 * This file is part of msg-service.
   6 *
   7 * Contact: Jaeyun Jeong <jyjeong@samsung.com>
   8 *          Sangkoo Kim <sangkoo.kim@samsung.com>
   9 *          Seunghwan Lee <sh.cat.lee@samsung.com>
  10 *          SoonMin Jung <sm0415.jung@samsung.com>
  11 *          Jae-Young Lee <jy4710.lee@samsung.com>
  12 *          KeeBum Kim <keebum.kim@samsung.com>
  13 *
  14 * PROPRIETARY/CONFIDENTIAL
  15 *
  16 * This software is the confidential and proprietary information of
  17 * SAMSUNG ELECTRONICS ("Confidential Information"). You shall not
  18 * disclose such Confidential Information and shall use it only in
  19 * accordance with the terms of the license agreement you entered
  20 * into with SAMSUNG ELECTRONICS.
  21 *
  22 * SAMSUNG make no representations or warranties about the suitability
  23 * of the software, either express or implied, including but not limited
  24 * to the implied warranties of merchantability, fitness for a particular
  25 * purpose, or non-infringement. SAMSUNG shall not be liable for any
  26 * damages suffered by licensee as a result of using, modifying or
  27 * distributing this software or its derivatives.
  28 *
  29 */
  30
  31 #include <time.h>
  32
  33 #include "MsgDebug.h"
  34 #include "MsgCppTypes.h"
  35 #include "MsgException.h"
  36 #include "MsgGconfWrapper.h"
  37 #include "MsgUtilFile.h"
  38 #include "SmsPluginTextConvert.h"
  39 #include "SmsPluginUDCodec.h"
  40 #include "SmsPluginStorage.h"
  41 #include "SmsPluginEventHandler.h"
  42 #include "SmsPluginCbMsgHandler.h"
  43
  44
  45 /*==================================================================================================
  46                                      IMPLEMENTATION OF SmsPluginCbMsgHandler - Member Functions
  47 ==================================================================================================*/
  48 SmsPluginCbMsgHandler* SmsPluginCbMsgHandler::pInstance = NULL;
  49
  50
  51 SmsPluginCbMsgHandler::SmsPluginCbMsgHandler()
  52 {
  53         pageList.clear();
  54 }
  55
  56
  57 SmsPluginCbMsgHandler::~SmsPluginCbMsgHandler()
  58 {
  59
  60 }
  61
  62
  63 SmsPluginCbMsgHandler* SmsPluginCbMsgHandler::instance()
  64 {
  65         if (!pInstance)
  66                 pInstance = new SmsPluginCbMsgHandler();
  67
  68         return pInstance;
  69 }
  70
  71
  72 void SmsPluginCbMsgHandler::handleCbMsg(TelSmsCbMsg_t *pCbMsg)
  73 {
  74         MSG_BEGIN();
  75
  76         SMS_CB_NETWORK_TYPE_T type = pCbMsg->CbMsgType;
  77
  78         SMS_CBMSG_PAGE_S CbMsgPage = {0};
  79
  80         switch (type)
  81         {
  82                 case SMS_CB_NETWORK_TYPE_2G_GSM :
  83                         Decode2gCbMsg(pCbMsg, &CbMsgPage);
  84                 break;
  85
  86                 case SMS_CB_NETWORK_TYPE_3G_UMTS :
  87                         Decode3gCbMsg(pCbMsg, &CbMsgPage);
  88                 break;
  89         }
  90
  91         // Check CB Msg Options
  92         bool bJavaMsg = false;
  93
  94         if (!checkCbOpt(CbMsgPage, &bJavaMsg))
  95         {
  96                 MSG_DEBUG("The CB Msg is not supported by option.");
  97                 return;
  98         }
  99
 100         if (bJavaMsg == true)
 101         {
 102                 MSG_DEBUG("JAVA CB Msg.");
 103                 CbMsgPage.cbMsgType = SMS_CBMSG_TYPE_JAVACBS;
 104         }
 105
 106         // Check CB Pages
 107         unsigned char pageCnt = checkCbPage(CbMsgPage);
 108
 109         if (pageCnt == CbMsgPage.pageHeader.totalPages)
 110         {
 111                 MSG_DEBUG("RECEIVED LAST MSG : %d", pageCnt);
 112
 113                 SMS_CBMSG_S cbMsg = {};
 114                 MSG_MESSAGE_INFO_S msgInfo = {};
 115
 116                 // Make CB Msg Structure
 117                 MakeCbMsg(CbMsgPage, &cbMsg);
 118
 119                 // Convert to MSG_MESSAGE_INFO_S
 120                 convertCbMsgToMsginfo(cbMsg, &msgInfo);
 121
 122                 // Add CB Msg into DB
 123                 MSG_ERROR_T err = MSG_SUCCESS;
 124
 125                 err = SmsPluginStorage::instance()->addMessage(&msgInfo);
 126
 127                 if (err == MSG_SUCCESS)
 128                 {
 129                         // Callback
 130                         err = SmsPluginEventHandler::instance()->callbackMsgIncoming(&msgInfo);
 131
 132                         if (err != MSG_SUCCESS)
 133                         {
 134                                 MSG_DEBUG("callbackMsgIncoming() Error !! [%d]", err);
 135                         }
 136                 }
 137                 else
 138                 {
 139                         MSG_DEBUG("addMessage() Error !! [%d]", err);
 140                 }
 141
 142                 // Remove From List
 143                 removeFromPageList(CbMsgPage);
 144         }
 145         MSG_END();
 146 }
 147
 148
 149 void SmsPluginCbMsgHandler::Decode2gCbMsg(TelSmsCbMsg_t *pCbMsg, SMS_CBMSG_PAGE_S *pCbPage)
 150 {
 151         if (pCbMsg->Length > MAX_CBMSG_PAGE_SIZE)
 152                 THROW(MsgException::SMS_PLG_ERROR, "CB Msg Size is over MAX [%d]", pCbMsg->Length);
 153
 154         unsigned char cbData[pCbMsg->Length+1];
 155
 156         memset(cbData, 0x00, sizeof(cbData));
 157         memcpy(cbData, pCbMsg->szMsgData, pCbMsg->Length);
 158         cbData[pCbMsg->Length] = '\0';
 159
 160         pCbPage->cbMsgType = SMS_CBMSG_TYPE_CBS;
 161
 162         // Serial Number
 163         pCbPage->pageHeader.serialNum.geoScope = (cbData[0] & 0xC0) >> 6;
 164
 165         pCbPage->pageHeader.serialNum.msgCode = (cbData[0] & 0x3F) << 4;
 166         pCbPage->pageHeader.serialNum.msgCode |= (cbData[1] & 0xF0) >> 4;
 167
 168         pCbPage->pageHeader.serialNum.updateNum = cbData[1] & 0x0F;
 169
 170 MSG_DEBUG("geoScope : [%d], msgCode : [%d], updateNum : [%d]", pCbPage->pageHeader.serialNum.geoScope, pCbPage->pageHeader.serialNum.msgCode, pCbPage->pageHeader.serialNum.updateNum);
 171
 172         pCbPage->pageHeader.msgId = (cbData[2] << 8) | cbData[3];
 173
 174 MSG_DEBUG("MSG ID : [%d]", pCbPage->pageHeader.msgId);
 175
 176         // DCS
 177         decodeCbMsgDCS(cbData[4], (unsigned char*)cbData[6], &(pCbPage->pageHeader.dcs));
 178
 179         // Page Parameter
 180         pCbPage->pageHeader.totalPages = cbData[5] & 0x0F;
 181         pCbPage->pageHeader.page = (cbData[5] & 0xF0) >> 4;
 182
 183         if (pCbPage->pageHeader.totalPages > MAX_CBMSG_PAGE_NUM)
 184                 THROW(MsgException::SMS_PLG_ERROR, "CB Page Count is over MAX[%d]", pCbPage->pageHeader.totalPages);
 185
 186 MSG_DEBUG("Total Page : [%d], Page : [%d]", pCbPage->pageHeader.totalPages, pCbPage->pageHeader.page);
 187
 188         // Convert Language Type
 189         convertLangType(pCbPage->pageHeader.dcs.langType, &(pCbPage->pageHeader.langType));
 190
 191 MSG_DEBUG("In Language Type : [%d], Out Language Type : [%d]", pCbPage->pageHeader.dcs.langType, pCbPage->pageHeader.langType);
 192
 193         // Get Receive Time
 194         pCbPage->pageHeader.recvTime = getRecvTime();
 195
 196         // Decode CB Data
 197         int dataLen = pCbMsg->Length - 6;
 198
 199         switch (pCbPage->pageHeader.dcs.codingScheme)
 200         {
 201                 case SMS_CHARSET_7BIT :
 202                 {
 203                         MSG_DEBUG("GSM 7 BIT");
 204
 205                         dataLen = (dataLen*8) / 7;
 206
 207                         SmsPluginUDCodec udCodec;
 208                         int unpackLen = udCodec.unpack7bitChar(&cbData[6], dataLen, 0, pCbPage->pageData);
 209
 210 MSG_DEBUG("dataLen : [%d]", dataLen);
 211 MSG_DEBUG("unpackLen : [%d]", unpackLen);
 212
 213                         pCbPage->pageLength = unpackLen;
 214                         pCbPage->pageData[unpackLen] = '\0';
 215
 216                 }
 217                 break;
 218
 219                 case SMS_CHARSET_8BIT :
 220                 case SMS_CHARSET_UCS2 :
 221                 {
 222                         MSG_DEBUG("UCS2");
 223
 224                         memcpy(pCbPage->pageData, &cbData[6], dataLen);
 225
 226                         pCbPage->pageLength = strlen(pCbPage->pageData);
 227
 228                         pCbPage->pageData[pCbPage->pageLength] = '\0';
 229                 }
 230                 break;
 231         }
 232
 233 MSG_DEBUG("Page Length : [%d], Page Data : [%s]", pCbPage->pageLength, pCbPage->pageData);
 234 }
 235
 236
 237 void SmsPluginCbMsgHandler::Decode3gCbMsg(TelSmsCbMsg_t *pCbMsg, SMS_CBMSG_PAGE_S *pCbPage)
 238 {
 239         if (pCbMsg->Length > (MAX_CBMSG_PAGE_SIZE*MAX_CBMSG_PAGE_NUM))
 240                 THROW(MsgException::SMS_PLG_ERROR, "CB Msg Size is over MAX [%d]", pCbMsg->Length);
 241
 242         char cbData[(MAX_CBMSG_PAGE_SIZE*MAX_CBMSG_PAGE_NUM)+1];
 243
 244         memset(cbData, 0x00, sizeof(cbData));
 245         memcpy(cbData, pCbMsg->szMsgData, pCbMsg->Length);
 246         cbData[pCbMsg->Length] = '\0';
 247
 248         pCbPage->cbMsgType = (SMS_CBMSG_TYPE_T)cbData[0];
 249
 250         pCbPage->pageHeader.msgId = (cbData[1] << 8) | cbData[2];
 251
 252 MSG_DEBUG("MSG ID : [%d]", pCbPage->pageHeader.msgId);
 253
 254         // Serial Number
 255         pCbPage->pageHeader.serialNum.geoScope = (cbData[3] & 0xC0) >> 6;
 256
 257         pCbPage->pageHeader.serialNum.msgCode = (cbData[3] & 0x3F) << 4;
 258         pCbPage->pageHeader.serialNum.msgCode |= (cbData[4] & 0xF0) >> 4;
 259
 260         pCbPage->pageHeader.serialNum.updateNum = cbData[4] & 0x0F;
 261
 262 MSG_DEBUG("geoScope : [%d], msgCode : [%d], updateNum : [%d]", pCbPage->pageHeader.serialNum.geoScope, pCbPage->pageHeader.serialNum.msgCode, pCbPage->pageHeader.serialNum.updateNum);
 263
 264         // DCS
 265         decodeCbMsgDCS(cbData[5], (unsigned char*)cbData[6], &(pCbPage->pageHeader.dcs));
 266
 267         // Convert Language Type
 268         convertLangType(pCbPage->pageHeader.dcs.langType, &(pCbPage->pageHeader.langType));
 269
 270 MSG_DEBUG("In Language Type : [%d], Out Language Type : [%d]", pCbPage->pageHeader.dcs.langType, pCbPage->pageHeader.langType);
 271
 272         // Get Receive Time
 273         pCbPage->pageHeader.recvTime = getRecvTime();
 274
 275 }
 276
 277
 278 bool SmsPluginCbMsgHandler::checkCbOpt(SMS_CBMSG_PAGE_S CbPage, bool *pJavaMsg)
 279 {
 280         bool bReceive = false;
 281         MsgSettingGetBool(CB_RECEIVE, &bReceive);
 282
 283         // Receive CB Msg = FALSE
 284         if (!bReceive)
 285         {
 286                 MSG_DEBUG("RECEIVE CB = FALSE");
 287                 return false;
 288         }
 289
 290         char keyName[128];
 291
 292         // check Language
 293         memset(keyName, 0x00, sizeof(keyName));
 294         sprintf(keyName, "%s/%d", CB_LANGUAGE, MSG_CBLANG_TYPE_ALL);
 295
 296         bool bAllLang = false;
 297         MsgSettingGetBool(keyName, &bAllLang);
 298
 299         if (!bAllLang)
 300         {
 301                 MSG_DEBUG("ALL LANGUAGE = FALSE");
 302
 303                 memset(keyName, 0x00, sizeof(keyName));
 304                 sprintf(keyName, "%s/%d", CB_LANGUAGE, CbPage.pageHeader.langType);
 305
 306                 bool bLang = false;
 307
 308                 MsgSettingGetBool(keyName, &bLang);
 309
 310                 if (!bLang || CbPage.pageHeader.langType == MSG_CBLANG_TYPE_MAX)
 311                 {
 312                         MSG_DEBUG("LANGUAGE [%d] = FALSE", CbPage.pageHeader.langType);
 313                         return false;
 314                 }
 315         }
 316
 317         bool bAllChannel = false;
 318         MsgSettingGetBool(CB_ALL_CHANNEL, &bAllChannel);
 319
 320         // Receive All Channel = FALSE
 321         if (!bAllChannel)
 322         {
 323                 MSG_DEBUG("RECEIVE ALL CHANNEL = FALSE");
 324
 325                 int MsgIdCnt = MsgSettingGetInt(CB_CHANNEL_COUNT);
 326
 327                 bool bActivate = false;
 328                 int MsgId = 0;
 329
 330                 for (int i = 0; i < MsgIdCnt; i++)
 331                 {
 332                         memset(keyName, 0x00, sizeof(keyName));
 333                         sprintf(keyName, "%s/%d", CB_CHANNEL_ACTIVATE, i);
 334
 335                         MsgSettingGetBool(keyName, &bActivate);
 336
 337                         memset(keyName, 0x00, sizeof(keyName));
 338                         sprintf(keyName, "%s/%d", CB_CHANNEL_ID, i);
 339
 340                         MsgId = MsgSettingGetInt(keyName);
 341
 342                         if (bActivate == true && CbPage.pageHeader.msgId == MsgId)
 343                         {
 344                                 MSG_DEBUG("FIND CHANNEL = [%d]", MsgId);
 345                                 return true;
 346                         }
 347                 }
 348         }
 349         else    // Receive All Channel = TRUE
 350         {
 351                 MSG_DEBUG("RECEIVE ALL CHANNEL = TRUE");
 352                 return true;
 353         }
 354
 355         return false;
 356 }
 357
 358
 359 unsigned char SmsPluginCbMsgHandler::checkCbPage(SMS_CBMSG_PAGE_S CbPage)
 360 {
 361         unsigned char currPageCnt = 0;
 362
 363         bool bFind = false;
 364
 365         if (CbPage.pageHeader.totalPages > 1)
 366         {
 367                 for (unsigned int i = 0; i < pageList.size(); i++)
 368                 {
 369                         if (pageList[i].geoScope == CbPage.pageHeader.serialNum.geoScope && pageList[i].msgCode == CbPage.pageHeader.serialNum.msgCode)
 370                         {
 371                                 MSG_DEBUG("geoScope [%d], msgCode [%d]", pageList[i].geoScope, pageList[i].msgCode);
 372
 373                                 if (pageList[i].msgId == CbPage.pageHeader.msgId)
 374                                 {
 375                                         int updateNum = CbPage.pageHeader.serialNum.updateNum - pageList[i].updateNum;
 376
 377                                         if (updateNum > 0) // New Message Content
 378                                         {
 379                                                 break;
 380                                         }
 381                                         else if (updateNum == 0) // Same Message Content
 382                                         {
 383                                                 if (pageList[i].data.count(CbPage.pageHeader.page) != 0)
 384                                                 {
 385                                                         MSG_DEBUG("The Page Number already exists [%d]", CbPage.pageHeader.page);
 386                                                         return 0;
 387                                                 }
 388
 389                                                 pair<unsigned char, string> newData(CbPage.pageHeader.page, CbPage.pageData);
 390                                                 pageList[i].data.insert(newData);
 391
 392                                                 MSG_DEBUG("PAGE DATA : %s", CbPage.pageData);
 393                                                 MSG_DEBUG("PAIR DATA [%d] : %s", newData.first, newData.second.c_str());
 394
 395                                                 pageList[i].pageCnt++;
 396                                                 pageList[i].totalSize += CbPage.pageLength;
 397
 398                                                 currPageCnt = pageList[i].pageCnt;
 399
 400                                                 bFind = true;
 401
 402                                                 break;
 403                                         }
 404                                         else // Old Message Content
 405                                         {
 406                                                 return 0;
 407                                         }
 408                                 }
 409                         }
 410                 }
 411         }
 412
 413         if (bFind == false || CbPage.pageHeader.totalPages == 1)
 414         {
 415                 addToPageLiat(CbPage);
 416                 return 1;
 417         }
 418
 419         return currPageCnt;
 420 }
 421
 422
 423 void SmsPluginCbMsgHandler::MakeCbMsg(SMS_CBMSG_PAGE_S CbPage, SMS_CBMSG_S *pCbMsg)
 424 {
 425         pCbMsg->cbMsgType = CbPage.cbMsgType;
 426         pCbMsg->msgId = CbPage.pageHeader.msgId;
 427         pCbMsg->classType = CbPage.pageHeader.dcs.classType;
 428         pCbMsg->codingScheme = CbPage.pageHeader.dcs.codingScheme;
 429         pCbMsg->recvTime = CbPage.pageHeader.recvTime;
 430
 431         cbPageMap::iterator it;
 432         string tmpStr ("");
 433
 434         for (unsigned int i = 0; i < pageList.size(); i++)
 435         {
 436                 if (pageList[i].geoScope == CbPage.pageHeader.serialNum.geoScope && pageList[i].msgCode == CbPage.pageHeader.serialNum.msgCode)
 437                 {
 438                         MSG_DEBUG("geoScope [%d], msgCode [%d]", pageList[i].geoScope, pageList[i].msgCode);
 439
 440                         if (pageList[i].msgId == CbPage.pageHeader.msgId)
 441                         {
 442                                 for (it = pageList[i].data.begin(); it != pageList[i].data.end(); it++)
 443                                 {
 444                                         tmpStr += it->second;
 445                                 }
 446                         }
 447                 }
 448         }
 449
 450         pCbMsg->msgLength = tmpStr.size();
 451
 452         memcpy(pCbMsg->msgData, tmpStr.c_str(), tmpStr.size());
 453         pCbMsg->msgData[tmpStr.size()] = '\0';
 454
 455         MSG_DEBUG("SIZE : [%d] TOTAL MSG : %s", tmpStr.size(), tmpStr.c_str());
 456 }
 457
 458
 459 void SmsPluginCbMsgHandler::convertCbMsgToMsginfo(SMS_CBMSG_S cbMsg, MSG_MESSAGE_INFO_S *pMsgInfo)
 460 {
 461         pMsgInfo->msgId = (MSG_MESSAGE_ID_T)cbMsg.msgId;
 462
 463         pMsgInfo->folderId = MSG_CBMSGBOX_ID;
 464
 465         // Convert Type values
 466         pMsgInfo->msgType.mainType = MSG_SMS_TYPE;
 467
 468         if (cbMsg.cbMsgType == SMS_CBMSG_TYPE_CBS)
 469                 pMsgInfo->msgType.subType = MSG_CB_SMS;
 470         else if (cbMsg.cbMsgType == SMS_CBMSG_TYPE_JAVACBS)
 471                 pMsgInfo->msgType.subType = MSG_JAVACB_SMS;
 472
 473         switch(cbMsg.classType)
 474         {
 475                 case SMS_MSG_CLASS_0:
 476                         pMsgInfo->msgType.classType = MSG_CLASS_0;
 477                         break;
 478                 case SMS_MSG_CLASS_1:
 479                         pMsgInfo->msgType.classType = MSG_CLASS_1;
 480                         break;
 481                 case SMS_MSG_CLASS_2:
 482                         pMsgInfo->msgType.classType = MSG_CLASS_2;
 483                         break;
 484                 case SMS_MSG_CLASS_3:
 485                         pMsgInfo->msgType.classType = MSG_CLASS_3;
 486                         break;
 487                 default:
 488                         pMsgInfo->msgType.classType = MSG_CLASS_NONE;
 489         }
 490
 491         pMsgInfo->storageId = MSG_STORAGE_PHONE;
 492         pMsgInfo->networkStatus = MSG_NETWORK_RECEIVED;
 493         pMsgInfo->bRead = false;
 494         pMsgInfo->bProtected = false;
 495         pMsgInfo->priority = MSG_MESSAGE_PRIORITY_NORMAL;
 496         pMsgInfo->direction = MSG_DIRECTION_TYPE_MT;
 497
 498         // Temporary
 499         pMsgInfo->nAddressCnt = 1;
 500
 501         pMsgInfo->addressList[0].addressType = MSG_ADDRESS_TYPE_UNKNOWN;
 502         pMsgInfo->addressList[0].recipientType = MSG_RECIPIENTS_TYPE_UNKNOWN;
 503
 504         getDisplayName(cbMsg.msgId, pMsgInfo->addressList[0].addressVal);
 505         MSG_DEBUG("%s", pMsgInfo->addressList[0].addressVal);
 506
 507         pMsgInfo->msgPort.valid = false;
 508         pMsgInfo->msgPort.dstPort = 0;
 509         pMsgInfo->msgPort.srcPort = 0;
 510
 511         pMsgInfo->displayTime = cbMsg.recvTime;
 512         MSG_DEBUG("recvTime is %s", ctime(&pMsgInfo->displayTime));
 513
 514         int bufSize = cbMsg.msgLength*2;
 515
 516         char tmpBuf[bufSize];
 517         memset(tmpBuf, 0x00, sizeof(tmpBuf));
 518
 519         MSG_DEBUG("LENGTH %d CB MSG %s", cbMsg.msgLength, cbMsg.msgData);
 520
 521         SMS_LANG_INFO_S langInfo = {0};
 522
 523         langInfo.bSingleShift = false;
 524         langInfo.bLockingShift = false;
 525
 526         // Convert Data values
 527         if (cbMsg.codingScheme == SMS_CHARSET_7BIT)
 528                 pMsgInfo->dataSize = SmsPluginTextConvert::instance()->convertGSM7bitToUTF8((unsigned char*)tmpBuf, bufSize, (unsigned char*)cbMsg.msgData, cbMsg.msgLength, &langInfo);
 529         else if (cbMsg.codingScheme == SMS_CHARSET_UCS2)
 530                 pMsgInfo->dataSize = SmsPluginTextConvert::instance()->convertUCS2ToUTF8((unsigned char*)tmpBuf, bufSize, (unsigned char*)cbMsg.msgData, cbMsg.msgLength);
 531
 532         if (pMsgInfo->dataSize > MAX_MSG_TEXT_LEN)
 533         {
 534                 pMsgInfo->bTextSms = false;
 535
 536                 // Save Message Data into File
 537                 char fileName[MAX_COMMON_INFO_SIZE+1];
 538                 memset(fileName, 0x00, sizeof(fileName));
 539
 540                 if (MsgCreateFileName(fileName) == false)
 541                         THROW(MsgException::FILE_ERROR, "MsgCreateFileName error");
 542
 543                 MSG_DEBUG("Save Message Data into file : size[%d] name[%s]\n", pMsgInfo->dataSize, fileName);
 544                 if (MsgWriteIpcFile(fileName, tmpBuf, pMsgInfo->dataSize) == false)
 545                         THROW(MsgException::FILE_ERROR, "MsgWriteIpcFile error");
 546
 547                 strncpy(pMsgInfo->msgData, fileName, MAX_MSG_DATA_LEN);
 548         }
 549         else
 550         {
 551                 pMsgInfo->bTextSms = true;
 552
 553                 memset(pMsgInfo->msgText, 0x00, sizeof(pMsgInfo->msgText));
 554                 memcpy(pMsgInfo->msgText, tmpBuf, pMsgInfo->dataSize);
 555         }
 556 }
 557
 558
 559 void SmsPluginCbMsgHandler::addToPageLiat(SMS_CBMSG_PAGE_S CbPage)
 560 {
 561         CB_PAGE_INFO_S tmpInfo;
 562
 563         tmpInfo.geoScope = CbPage.pageHeader.serialNum.geoScope;
 564         tmpInfo.msgCode = CbPage.pageHeader.serialNum.msgCode;
 565         tmpInfo.updateNum = CbPage.pageHeader.serialNum.updateNum;
 566         tmpInfo.msgId = CbPage.pageHeader.msgId;
 567         tmpInfo.totalPages = CbPage.pageHeader.totalPages;
 568
 569         tmpInfo.pageCnt = 1;
 570         tmpInfo.totalSize = CbPage.pageLength;
 571
 572         pair<unsigned char, string> newData(CbPage.pageHeader.page, CbPage.pageData);
 573         tmpInfo.data.insert(newData);
 574
 575         MSG_DEBUG("MSG DATA : %s", CbPage.pageData);
 576         MSG_DEBUG("PAIR DATA [%d] : %s", newData.first, newData.second.c_str());
 577
 578         pageList.push_back(tmpInfo);
 579 }
 580
 581
 582 void SmsPluginCbMsgHandler::removeFromPageList(SMS_CBMSG_PAGE_S CbPage)
 583 {
 584         unsigned int index;
 585
 586         for (index = 0; index < pageList.size(); index++)
 587         {
 588                 if (pageList[index].geoScope == CbPage.pageHeader.serialNum.geoScope && pageList[index].msgCode == CbPage.pageHeader.serialNum.msgCode)
 589                 {
 590                         MSG_DEBUG("geoScope [%d], msgCode [%d]", pageList[index].geoScope, pageList[index].msgCode);
 591
 592                         if (pageList[index].msgId == CbPage.pageHeader.msgId) break;
 593                 }
 594         }
 595
 596         MSG_DEBUG("remove index [%d]", index);
 597
 598         pageList.erase(pageList.begin()+index);
 599 }
 600
 601
 602 void SmsPluginCbMsgHandler::decodeCbMsgDCS(unsigned char dcsData, const unsigned char *pMsgData, SMS_CBMSG_DCS_S* pDcs)
 603 {
 604         pDcs->codingGroup = SMS_CBMSG_CODGRP_GENERAL_DCS;
 605         pDcs->classType = SMS_MSG_CLASS_NONE;
 606         pDcs->bCompressed = false;
 607         pDcs->codingScheme = SMS_CHARSET_7BIT;
 608         pDcs->langType = SMS_CBMSG_LANG_UNSPECIFIED;
 609         memset(pDcs->iso639Lang, 0x00, sizeof(pDcs->iso639Lang));
 610         pDcs->bUDH = false;
 611         pDcs->rawData = dcsData;
 612
 613         unsigned char codingGrp = (dcsData & 0xF0) >> 4;
 614
 615         switch (codingGrp)
 616         {
 617                 case 0x00 :
 618                 case 0x02 :
 619                 case 0x03 :
 620                 {
 621                         pDcs->codingGroup = SMS_CBMSG_CODGRP_GENERAL_DCS;
 622                         pDcs->langType = (SMS_CBMSG_LANG_TYPE_T)dcsData;
 623                 }
 624                 break;
 625
 626                 case 0x01 :
 627                 {
 628                         if (dcsData == 0x10 || dcsData == 0x11)
 629                         {
 630                                 pDcs->codingGroup = SMS_CBMSG_CODGRP_GENERAL_DCS;
 631                                 pDcs->codingScheme = (dcsData & 0x01) ? SMS_CHARSET_UCS2 : SMS_CHARSET_7BIT;
 632                                 pDcs->langType = SMS_CBMSG_LANG_ISO639;
 633
 634                                 if (pMsgData != NULL)
 635                                 {
 636                                         pDcs->iso639Lang[0] = pMsgData[0] & 0x7F;
 637                                         pDcs->iso639Lang[1] = (pMsgData[0] & 0x80) >> 7;
 638                                         pDcs->iso639Lang[1] |= (pMsgData[1] & 0x3F) << 1;
 639                                         pDcs->iso639Lang[2]  = 0x13; /* CR char in GSM 7-bit Alphabet */
 640                                 }
 641                                 else
 642                                 {
 643                                         /* Default it to English if pMsgData is NULL */
 644                                         pDcs->iso639Lang[0] = 0x45;  /* E */
 645                                         pDcs->iso639Lang[1] = 0x4E;  /* N */
 646                                         pDcs->iso639Lang[2] = 0x13;  /* CR */
 647                                 }
 648                         }
 649                 }
 650                 break;
 651
 652                 case 0x04 :
 653                 case 0x05 :
 654                 case 0x06 :
 655                 case 0x07 :
 656                 {
 657                         pDcs->codingGroup = SMS_CBMSG_CODGRP_GENERAL_DCS;
 658
 659                         pDcs->bCompressed = (dcsData & 0x20) ? true : false;
 660
 661                         if (dcsData & 0x10)
 662                                 pDcs->classType = (SMS_MSG_CLASS_T)(dcsData & 0x03);
 663
 664                         pDcs->codingScheme = (SMS_CODING_SCHEME_T)(dcsData & 0x0C);
 665                 }
 666                 break;
 667
 668                 case 0x09 :
 669                 {
 670                         pDcs->bUDH = true;
 671                 }
 672                 break;
 673
 674                 case 0x14 :
 675                 {
 676                         pDcs->codingGroup = SMS_CBMSG_CODGRP_WAP;
 677                 }
 678                 break;
 679
 680                 case 0x15 :
 681                 {
 682                         pDcs->codingGroup = SMS_CBMSG_CODGRP_CLASS_CODING;
 683                         pDcs->codingScheme = (dcsData & 0x04) ? SMS_CHARSET_UCS2 : SMS_CHARSET_7BIT;
 684                         pDcs->classType = (MSG_CLASS_TYPE_T)(dcsData & 0x03);
 685                 }
 686                 break;
 687         }
 688 }
 689
 690
 691 void SmsPluginCbMsgHandler::convertLangType(SMS_CBMSG_LANG_TYPE_T InType , MSG_CB_LANGUAGE_TYPE_T *pOutType)
 692 {
 693         switch (InType)
 694         {
 695                 case SMS_CBMSG_LANG_GERMAN :
 696                         *pOutType = MSG_CBLANG_TYPE_GER;
 697                 break;
 698
 699                 case SMS_CBMSG_LANG_ENGLISH :
 700                         *pOutType = MSG_CBLANG_TYPE_ENG;
 701                 break;
 702
 703                 case SMS_CBMSG_LANG_ITALIAN :
 704                         *pOutType = MSG_CBLANG_TYPE_ITA;
 705                 break;
 706
 707                 case SMS_CBMSG_LANG_FRENCH :
 708                         *pOutType = MSG_CBLANG_TYPE_FRE;
 709                 break;
 710
 711                 case SMS_CBMSG_LANG_SPANISH :
 712                         *pOutType = MSG_CBLANG_TYPE_SPA;
 713                 break;
 714
 715                 case SMS_CBMSG_LANG_DUTCH :
 716                         *pOutType = MSG_CBLANG_TYPE_NED;
 717                 break;
 718
 719                 case SMS_CBMSG_LANG_SWEDISH :
 720                         *pOutType = MSG_CBLANG_TYPE_SWE;
 721                 break;
 722
 723                 case SMS_CBMSG_LANG_PORTUGUESE :
 724                         *pOutType = MSG_CBLANG_TYPE_POR;
 725                 break;
 726
 727                 case SMS_CBMSG_LANG_TURKISH :
 728                         *pOutType = MSG_CBLANG_TYPE_TUR;
 729                 break;
 730
 731                 default :
 732                         *pOutType = MSG_CBLANG_TYPE_MAX;
 733                 break;
 734         }
 735 }
 736
 737
 738 unsigned long SmsPluginCbMsgHandler::getRecvTime()
 739 {
 740         time_t recvTime;
 741
 742         recvTime = time(NULL);
 743
 744         return (unsigned long)recvTime;
 745 }
 746
 747
 748 void SmsPluginCbMsgHandler::getDisplayName(unsigned short       MsgId, char *pDisplayName)
 749 {
 750         int MsgIdCnt = MsgSettingGetInt(CB_CHANNEL_COUNT);
 751
 752         char keyName[128];
 753         char strTmp[CB_CHANNEL_NAME_MAX+1];
 754
 755         for (int i = 0; i < MsgIdCnt; i++)
 756         {
 757                 memset(keyName, 0x00, sizeof(keyName));
 758                 sprintf(keyName, "%s/%d", CB_CHANNEL_ID, i);
 759
 760                 if (MsgId == MsgSettingGetInt(keyName))
 761                 {
 762                         char *channelName = NULL;
 763                         MSG_DEBUG("FIND MSG ID = [%d]", MsgId);
 764
 765                         memset(keyName, 0x00, sizeof(keyName));
 766                         sprintf(keyName, "%s/%d", CB_CHANNEL_NAME, i);
 767
 768                         memset(strTmp, 0x00, sizeof(strTmp));
 769
 770                         channelName = MsgSettingGetString(keyName);
 771
 772                         strncpy(strTmp, channelName, CB_CHANNEL_NAME_MAX);
 773
 774                         if (channelName) {
 775                                 free(channelName);
 776                                 channelName = NULL;
 777                         }
 778
 779                         if (strlen(strTmp) > 0)
 780                                 sprintf(pDisplayName, "[%s]", strTmp);
 781                         else
 782                                 sprintf(pDisplayName, "[%d]", MsgId);
 783
 784                         return;
 785                 }
 786         }
 787
 788         sprintf(pDisplayName, "[%d]", MsgId);
 789 }
 790