plugin/sms_plugin/SmsPluginCbMsgHandler.cpp

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