framework/plugin-manager/MsgPluginManager.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 <stdio.h>
  32 #include <dlfcn.h>
  33
  34 #include "MsgDebug.h"
  35 #include "MsgUtilFile.h"
  36 #include "MsgException.h"
  37 #include "MsgIpcSocket.h"
  38 #include "MsgCmdTypes.h"
  39 #include "MsgGconfWrapper.h"
  40 #include "MsgPluginManager.h"
  41 #include "MsgMmsTypes.h"
  42
  43
  44 /*==================================================================================================
  45                                      FUNCTION IMPLEMENTATION
  46 ==================================================================================================*/
  47 void MsgSentStatusListener(MSG_SENT_STATUS_S *pSentStatus)
  48 {
  49         MSG_BEGIN();
  50
  51         MSG_DEBUG("SENT STATUS %d, %d", pSentStatus->reqId, pSentStatus->status);
  52
  53         // establish connection to msgfw daemon
  54         MsgIpcClientSocket client;
  55         client.connect(MSG_SOCKET_PATH);
  56
  57         // composing command
  58         int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_SENT_STATUS_S); // cmd type, MSG_SENT_STATUS
  59
  60         char cmdBuf[cmdSize];
  61         bzero(cmdBuf, cmdSize);
  62
  63         MSG_CMD_S* pCmd = (MSG_CMD_S*) cmdBuf;
  64
  65         // Set Command Parameters
  66         pCmd->cmdType = MSG_CMD_PLG_SENT_STATUS_CNF;
  67
  68         memset(pCmd->cmdCookie, 0x00, MAX_COOKIE_LEN);
  69
  70         memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), pSentStatus, sizeof(MSG_SENT_STATUS_S));
  71
  72         // Send Command to Transaction Manager
  73         client.write(cmdBuf, cmdSize);
  74
  75         // Receive result from Transaction Manager
  76         MSG_DEBUG("Waiting result for SENT STATUS");
  77
  78         char *temp = NULL;
  79         AutoPtr<char> wrap(&temp);
  80         int len;
  81         client.read(&temp, &len);
  82
  83         // close connection to msgfw daemon
  84         client.close();
  85
  86         MSG_END();
  87 }
  88
  89
  90 void MsgStorageChangeListener(MSG_STORAGE_CHANGE_TYPE_T storageChangeType, MSG_MESSAGE_INFO_S *pMsgInfo)
  91 {
  92         MSG_BEGIN();
  93
  94         MSG_DEBUG("StorageChangeType : [%d], msg ID : [%d]", storageChangeType, pMsgInfo->msgId);
  95
  96         // establish connection to msgfw daemon
  97         MsgIpcClientSocket client;
  98         client.connect(MSG_SOCKET_PATH);
  99
 100         // composing command
 101         int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_MESSAGE_INFO_S) + sizeof(MSG_STORAGE_CHANGE_TYPE_T);
 102
 103         char cmdBuf[cmdSize];
 104         bzero(cmdBuf, cmdSize);
 105
 106         MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
 107
 108         // Set Command Parameters
 109         pCmd->cmdType = MSG_CMD_PLG_STORAGE_CHANGE_IND;
 110
 111         memset(pCmd->cmdCookie, 0x00, MAX_COOKIE_LEN);
 112
 113         memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), pMsgInfo, sizeof(MSG_MESSAGE_INFO_S));
 114         memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN+sizeof(MSG_MESSAGE_INFO_S)), &storageChangeType, sizeof(MSG_STORAGE_CHANGE_TYPE_T));
 115
 116         // Send Command to Transaction Manager
 117         client.write(cmdBuf, cmdSize);
 118
 119         // Receive result from Transaction Manager
 120         MSG_DEBUG("Waiting result for STORAGE CHANGE");
 121
 122         char *temp = NULL;
 123         AutoPtr<char> wrap(&temp);
 124         int len;
 125         client.read(&temp, &len);
 126
 127         // close connection to msgfw daemon
 128         client.close();
 129
 130         MSG_END();
 131 }
 132
 133
 134 MSG_ERROR_T MsgIncomingMessageListener(MSG_MESSAGE_INFO_S *pMsg)
 135 {
 136         MSG_BEGIN();
 137
 138         // establish connection to msgfw daemon
 139         MsgIpcClientSocket client;
 140         client.connect(MSG_SOCKET_PATH);
 141
 142         // Check Invalid Message Structure
 143         if (pMsg == NULL)
 144         {
 145                 MSG_DEBUG("pMsg is NULL !!");
 146
 147                 return MSG_ERR_NULL_MESSAGE;
 148         }
 149
 150         // composing command
 151         int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_MESSAGE_INFO_S); // cmd type, MSG_MESSAGE_INFO_S
 152
 153         MSG_DEBUG("cmdSize: %d", cmdSize);
 154
 155         char cmdBuf[cmdSize];
 156         bzero(cmdBuf, cmdSize);
 157
 158         MSG_CMD_S* pCmd = (MSG_CMD_S*) cmdBuf;
 159
 160         // Set Command Parameters
 161         pCmd->cmdType = MSG_CMD_PLG_INCOMING_MSG_IND;
 162
 163         memset(pCmd->cmdCookie, 0x00, MAX_COOKIE_LEN);
 164
 165         memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), pMsg, sizeof(MSG_MESSAGE_INFO_S));
 166
 167         // Send Command to Messaging FW
 168         client.write(cmdBuf, cmdSize);
 169
 170         char* retBuf = NULL;
 171         AutoPtr<char> wrap(&retBuf);
 172         int retSize;
 173
 174         client.read(&retBuf, &retSize);
 175
 176         // close connection to msgfw daemon
 177         client.close();
 178
 179         // Decoding the result from FW and Returning it to plugin
 180         // the result is used for making delivery report
 181         MSG_EVENT_S* pEvent = (MSG_EVENT_S*)retBuf;
 182
 183         if (pEvent->eventType != MSG_EVENT_PLG_INCOMING_MSG_IND)
 184                 THROW(MsgException::INCOMING_MSG_ERROR, "Wrong result(evt type %d : %s) received", pEvent->eventType, MsgDbgEvtStr(pEvent->eventType));
 185
 186         MSG_END();
 187
 188         return (pEvent->result);
 189 }
 190
 191
 192 MSG_ERROR_T MsgIncomingSyncMLMessageListener(MSG_SYNCML_MESSAGE_DATA_S *pSyncMLData)
 193 {
 194         MSG_BEGIN();
 195
 196         // establish connection to msgfw daemon
 197         MsgIpcClientSocket client;
 198         client.connect(MSG_SOCKET_PATH);
 199
 200         // composing command
 201         int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_SYNCML_MESSAGE_DATA_S); // cmd type, MSG_SYNCML_MESSAGE_DATA_S
 202
 203         MSG_DEBUG("cmdSize: %d", cmdSize);
 204
 205         char cmdBuf[cmdSize];
 206         bzero(cmdBuf, cmdSize);
 207         MSG_CMD_S* pCmd = (MSG_CMD_S*) cmdBuf;
 208
 209         // Set Command Parameters
 210         pCmd->cmdType = MSG_CMD_PLG_INCOMING_SYNCML_IND;
 211
 212         memset(pCmd->cmdCookie, 0x00, MAX_COOKIE_LEN);
 213
 214         memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), pSyncMLData, sizeof(MSG_SYNCML_MESSAGE_DATA_S));
 215
 216         // Send Command to Messaging FW
 217         client.write(cmdBuf, cmdSize);
 218
 219         // Receive result from Transaction Manager
 220         char* retBuf = NULL;
 221         AutoPtr<char> wrap(&retBuf);
 222         int retSize;
 223         client.read(&retBuf, &retSize);
 224
 225         // close connection to msgfw daemon
 226         client.close();
 227
 228         // Decoding the result from FW and Returning it to plugin
 229         // the result is used for making delivery report
 230         MSG_EVENT_S* pEvent = (MSG_EVENT_S*)retBuf;
 231
 232         if (pEvent->eventType != MSG_EVENT_PLG_INCOMING_SYNCML_MSG_IND)
 233                 THROW(MsgException::INCOMING_MSG_ERROR, "Wrong result(evt type %d : %s) received", pEvent->eventType, MsgDbgEvtStr(pEvent->eventType));
 234
 235         MSG_END();
 236
 237         return (pEvent->result);
 238 }
 239
 240
 241 MSG_ERROR_T MsgIncomingLBSMessageListener(MSG_LBS_MESSAGE_DATA_S *pLBSData)
 242 {
 243         MSG_BEGIN();
 244
 245         // establish connection to msgfw daemon
 246         MsgIpcClientSocket client;
 247         client.connect(MSG_SOCKET_PATH);
 248
 249         // composing command
 250         int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_LBS_MESSAGE_DATA_S); // cmd type, MSG_LBS_MESSAGE_DATA_S
 251
 252         MSG_DEBUG("cmdSize: %d", cmdSize);
 253
 254         char cmdBuf[cmdSize];
 255         bzero(cmdBuf, cmdSize);
 256         MSG_CMD_S* pCmd = (MSG_CMD_S*) cmdBuf;
 257
 258         // Set Command Parameters
 259         pCmd->cmdType = MSG_CMD_PLG_INCOMING_LBS_IND;
 260
 261         memset(pCmd->cmdCookie, 0x00, MAX_COOKIE_LEN);
 262
 263         memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), pLBSData, sizeof(MSG_LBS_MESSAGE_DATA_S));
 264
 265         // Send Command to Messaging FW
 266         client.write(cmdBuf, cmdSize);
 267
 268         // Receive result from Transaction Manager
 269         char* retBuf = NULL;
 270         AutoPtr<char> wrap(&retBuf);
 271         int retSize;
 272         client.read(&retBuf, &retSize);
 273
 274         // close connection to msgfw daemon
 275         client.close();
 276
 277         // Decoding the result from FW and Returning it to plugin
 278         // the result is used for making delivery report
 279         MSG_EVENT_S* pEvent = (MSG_EVENT_S*)retBuf;
 280
 281         if (pEvent->eventType != MSG_EVENT_PLG_INCOMING_LBS_MSG_IND)
 282                 THROW(MsgException::INCOMING_MSG_ERROR, "Wrong result(evt type %d : %s) received", pEvent->eventType, MsgDbgEvtStr(pEvent->eventType));
 283
 284         MSG_END();
 285
 286         return (pEvent->result);
 287 }
 288
 289
 290 MSG_ERROR_T MsgInitSimBySatListener()
 291 {
 292         MSG_BEGIN();
 293
 294         // establish connection to msgfw daemon
 295         MsgIpcClientSocket client;
 296         client.connect(MSG_SOCKET_PATH);
 297
 298         // composing command
 299         int cmdSize = sizeof(MSG_CMD_S);
 300
 301         char cmdBuf[cmdSize];
 302         bzero(cmdBuf, cmdSize);
 303
 304         MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
 305
 306         // Set Command Parameters
 307         pCmd->cmdType = MSG_CMD_PLG_INIT_SIM_BY_SAT;
 308
 309         // Send Command to Transaction Manager
 310         client.write(cmdBuf, cmdSize);
 311
 312         // Receive result from Transaction Manager
 313         char* retBuf = NULL;
 314         AutoPtr<char> wrap(&retBuf);
 315         int retSize;
 316         client.read(&retBuf, &retSize);
 317
 318         // close connection to msgfw daemon
 319         client.close();
 320
 321         // Decoding the result from FW and Returning it to plugin
 322         MSG_EVENT_S* pEvent = (MSG_EVENT_S*)retBuf;
 323
 324         if (pEvent->eventType != MSG_EVENT_PLG_INIT_SIM_BY_SAT)
 325                 THROW(MsgException::INVALID_RESULT, "Wrong result(evt type %d : %s) received", pEvent->eventType, MsgDbgEvtStr(pEvent->eventType));
 326
 327         MSG_END();
 328
 329         return (pEvent->result);
 330 }
 331
 332 /* MMS_Incoming_listener */
 333 MSG_ERROR_T MsgMmsConfIncomingListener(MSG_MESSAGE_INFO_S *pMsg, MSG_REQUEST_ID_T *pReqId)
 334 {
 335         MSG_BEGIN();
 336         MSG_DEBUG("pMsg = %s, pReqId = %d ", pMsg->msgData, *pReqId);
 337
 338         // establish connection to msgfw daemon
 339         MsgIpcClientSocket client;
 340         client.connect(MSG_SOCKET_PATH);
 341
 342         // composing command
 343         int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_MESSAGE_INFO_S) + sizeof(MSG_REQUEST_ID_T); // cmd type, MSG_MESSAGE_INFO_S, MSG_REQUEST_ID_T
 344         MSG_DEBUG("cmdSize : %d", cmdSize);
 345
 346         char cmdBuf[cmdSize];
 347         bzero(cmdBuf, cmdSize);
 348
 349         MSG_CMD_S *pCmd = (MSG_CMD_S *)cmdBuf;
 350
 351         // Set Command Parameters
 352         pCmd->cmdType = MSG_CMD_PLG_INCOMING_MMS_CONF; // cmd type
 353
 354         memset(pCmd->cmdCookie, 0x00, MAX_COOKIE_LEN); // cmd cookie
 355
 356         // cmd data
 357         memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), pMsg, sizeof(MSG_MESSAGE_INFO_S));
 358         memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN+sizeof(MSG_MESSAGE_INFO_S)), pReqId, sizeof(MSG_REQUEST_ID_T));
 359
 360         // Send Command to Messaging FW
 361         client.write(cmdBuf, cmdSize);
 362
 363         // Receive result from Transaction Manager
 364         char *retBuf = NULL;
 365         AutoPtr<char> wrap(&retBuf);
 366         int retSize = 0;
 367         client.read(&retBuf, &retSize);
 368
 369         // close connection to msgfw daemon
 370         client.close();
 371
 372         //Decoding the result from FW and Returning it to plugin
 373         // the result is used for making delivery report
 374         MSG_EVENT_S *pEvent = (MSG_EVENT_S *)retBuf;
 375
 376         if(pEvent->eventType != MSG_EVENT_PLG_INCOMING_MMS_CONF && pEvent->eventType != MSG_EVENT_PLG_SENT_STATUS_CNF)
 377                 THROW(MsgException::INCOMING_MSG_ERROR, "Wrong result(evt type %d : %s) received", pEvent->eventType, MsgDbgEvtStr(pEvent->eventType));
 378
 379         MSG_END();
 380
 381         return (pEvent->result);
 382 }
 383
 384 /*==================================================================================================
 385                                      IMPLEMENTATION OF MsgPlugin - Member Functions
 386 ==================================================================================================*/
 387 MsgPlugin::MsgPlugin(MSG_MAIN_TYPE_T mainType, const char *libPath): mSupportedMsg(mainType)
 388 {
 389         MSG_DEBUG("msg type : [%d] library path : [%s]", mainType, libPath);
 390
 391         bzero(&mPlgHandler, sizeof(mPlgHandler));
 392
 393         if (libPath == NULL)
 394                 THROW(MsgException::INVALID_PARAM, "libPath NULL");
 395
 396         void* libHandle = NULL;
 397
 398         libHandle = dlopen(libPath, RTLD_NOW);
 399
 400         if (!libHandle)
 401                 THROW(MsgException::PLUGIN_ERROR, "ERROR dlopen library : [%s] [%s]", libPath, dlerror());
 402
 403         // Clear Error
 404         dlerror();
 405
 406         // assign the c function pointers
 407         MSG_ERROR_T(*pFunc)(MSG_PLUGIN_HANDLER_S*) = NULL;
 408
 409         pFunc = (MSG_ERROR_T(*)(MSG_PLUGIN_HANDLER_S*))dlsym(libHandle, "MsgPlgCreateHandle");
 410
 411         char *error = dlerror();
 412
 413         if (error != NULL)
 414                 THROW(MsgException::PLUGIN_ERROR, "ERROR dlsym library : [%s]", dlerror());
 415
 416         if ((*pFunc)(&mPlgHandler) != MSG_SUCCESS)
 417                 THROW(MsgException::PLUGIN_ERROR, "ERROR to create plugin handle");
 418
 419         // Initialize Plug-in
 420         if (initialize() != MSG_SUCCESS)
 421                 THROW(MsgException::PLUGIN_ERROR, "ERROR to initialize plugin");
 422
 423         MSG_PLUGIN_LISTENER_S fwListener = {0};
 424         fwListener.pfSentStatusCb                       = &MsgSentStatusListener;
 425         fwListener.pfStorageChangeCb            = &MsgStorageChangeListener;
 426         fwListener.pfMsgIncomingCb              = &MsgIncomingMessageListener;
 427         fwListener.pfInitSimBySatCb                     = &MsgInitSimBySatListener;
 428         fwListener.pfSyncMLMsgIncomingCb        = &MsgIncomingSyncMLMessageListener;
 429         fwListener.pfLBSMsgIncomingCb           = &MsgIncomingLBSMessageListener;
 430         fwListener.pfMmsConfIncomingCb = &MsgMmsConfIncomingListener;
 431
 432         if (registerListener(&fwListener) != MSG_SUCCESS)
 433                 THROW(MsgException::PLUGIN_ERROR, "ERROR to register listener");
 434
 435 //      dlclose(libHandle);
 436 }
 437
 438
 439 MsgPlugin::~MsgPlugin()
 440 {
 441
 442
 443 }
 444
 445
 446 MSG_ERROR_T MsgPlugin::initialize()
 447 {
 448         if ( mPlgHandler.pfInitialize != NULL)
 449                 return mPlgHandler.pfInitialize();
 450         else
 451                 return MSG_ERR_INVALID_PLUGIN_HANDLE;
 452 }
 453
 454
 455 void MsgPlugin::finalize()
 456 {
 457         if (mPlgHandler.pfFinalize != NULL)
 458                 mPlgHandler.pfFinalize();
 459 }
 460
 461
 462 MSG_ERROR_T MsgPlugin::submitReq(MSG_REQUEST_INFO_S *pReqInfo, bool bReqCb)
 463 {
 464         if (mPlgHandler.pfSubmitRequest != NULL)
 465                 return mPlgHandler.pfSubmitRequest(pReqInfo, bReqCb);
 466         else
 467                 return MSG_ERR_INVALID_PLUGIN_HANDLE;
 468 }
 469
 470
 471 MSG_ERROR_T MsgPlugin::registerListener(MSG_PLUGIN_LISTENER_S *pListener)
 472 {
 473         if (mPlgHandler.pfRegisterListener != NULL)
 474                 return mPlgHandler.pfRegisterListener(pListener);
 475         else
 476                 return MSG_ERR_INVALID_PLUGIN_HANDLE;
 477 }
 478
 479
 480 MSG_ERROR_T MsgPlugin::checkSimStatus(MSG_SIM_STATUS_T *pStatus)
 481 {
 482         if (mPlgHandler.pfRegisterListener != NULL)
 483                 return mPlgHandler.pfCheckSimStatus(pStatus);
 484         else
 485                 return MSG_ERR_INVALID_PLUGIN_HANDLE;
 486 }
 487
 488
 489 MSG_ERROR_T MsgPlugin::checkDeviceStatus()
 490 {
 491         if (mPlgHandler.pfRegisterListener != NULL)
 492                 return mPlgHandler.pfCheckDeviceStatus();
 493         else
 494                 return MSG_ERR_INVALID_PLUGIN_HANDLE;
 495 }
 496
 497
 498 MSG_ERROR_T MsgPlugin::initSimMessage()
 499 {
 500         if (mPlgHandler.pfInitSimMessage != NULL)
 501                 return mPlgHandler.pfInitSimMessage();
 502         else
 503                 return MSG_ERR_INVALID_PLUGIN_HANDLE;
 504 }
 505
 506
 507 MSG_ERROR_T MsgPlugin::saveSimMessage(MSG_MESSAGE_INFO_S *pMsgInfo, SMS_SIM_ID_LIST_S *pSimIdList)
 508 {
 509         if (mPlgHandler.pfSaveSimMessage != NULL)
 510                 return mPlgHandler.pfSaveSimMessage(pMsgInfo, pSimIdList);
 511         else
 512                 return MSG_ERR_INVALID_PLUGIN_HANDLE;
 513 }
 514
 515
 516 MSG_ERROR_T MsgPlugin::deleteSimMessage(MSG_SIM_ID_T SimMsgId)
 517 {
 518         if (mPlgHandler.pfDeleteSimMessage != NULL)
 519                 return mPlgHandler.pfDeleteSimMessage(SimMsgId);
 520         else
 521                 return MSG_ERR_INVALID_PLUGIN_HANDLE;
 522 }
 523
 524
 525 MSG_ERROR_T MsgPlugin::setReadStatus(MSG_SIM_ID_T SimMsgId)
 526 {
 527         if (mPlgHandler.pfSetReadStatus != NULL)
 528                 return mPlgHandler.pfSetReadStatus(SimMsgId);
 529         else
 530                 return MSG_ERR_INVALID_PLUGIN_HANDLE;
 531 }
 532
 533
 534 MSG_ERROR_T MsgPlugin::setMemoryStatus(MSG_ERROR_T Error)
 535 {
 536         if (mPlgHandler.pfSetMemoryStatus != NULL)
 537                 return mPlgHandler.pfSetMemoryStatus(Error);
 538         else
 539                 return MSG_ERR_INVALID_PLUGIN_HANDLE;
 540 }
 541
 542
 543 MSG_ERROR_T MsgPlugin::initConfigData(MSG_SIM_STATUS_T SimStatus)
 544 {
 545         if (mPlgHandler.pfInitConfigData != NULL)
 546                 return mPlgHandler.pfInitConfigData(SimStatus);
 547         else
 548                 return MSG_ERR_INVALID_PLUGIN_HANDLE;
 549 }
 550
 551
 552 MSG_ERROR_T MsgPlugin::setConfigData(const MSG_SETTING_S *pSetting)
 553 {
 554         if (mPlgHandler.pfSetConfigData != NULL)
 555                 return mPlgHandler.pfSetConfigData(pSetting);
 556         else
 557                 return MSG_ERR_INVALID_PLUGIN_HANDLE;
 558 }
 559
 560
 561 MSG_ERROR_T MsgPlugin::getConfigData(MSG_SETTING_S *pSetting)
 562 {
 563         if (mPlgHandler.pfGetConfigData != NULL)
 564                 return mPlgHandler.pfGetConfigData(pSetting);
 565         else
 566                 return MSG_ERR_INVALID_PLUGIN_HANDLE;
 567 }
 568
 569 MSG_ERROR_T MsgPlugin::addMessage(MSG_MESSAGE_INFO_S *pMsgInfo, MSG_SENDINGOPT_INFO_S *pSendOptInfo, char *pFileData)
 570 {
 571         if (mPlgHandler.pfAddMessage != NULL) {
 572                 return mPlgHandler.pfAddMessage(pMsgInfo, pSendOptInfo, pFileData);
 573         } else {
 574                 return MSG_ERR_INVALID_PLUGIN_HANDLE;
 575         }
 576 }
 577
 578 MSG_ERROR_T MsgPlugin::updateMessage(MSG_MESSAGE_INFO_S *pMsgInfo, MSG_SENDINGOPT_INFO_S *pSendOptInfo, char *pFileData)
 579 {
 580         if (mPlgHandler.pfUpdateMessage != NULL) {
 581                 return mPlgHandler.pfUpdateMessage(pMsgInfo, pSendOptInfo, pFileData);
 582         } else {
 583                 return MSG_ERR_INVALID_PLUGIN_HANDLE;
 584         }
 585 }
 586
 587
 588 MSG_ERROR_T MsgPlugin::processReceivedInd(MSG_MESSAGE_INFO_S *pMsgInfo, MSG_REQUEST_INFO_S *pRequest, bool *bReject)
 589 {
 590         if (mPlgHandler.pfProcessReceivedInd != NULL) {
 591                 return mPlgHandler.pfProcessReceivedInd(pMsgInfo, pRequest, bReject);
 592         } else {
 593                 return MSG_ERR_INVALID_PLUGIN_HANDLE;
 594         }
 595 }
 596
 597
 598 MSG_ERROR_T MsgPlugin::getMmsMessage(MSG_MESSAGE_INFO_S *pMsg, MSG_SENDINGOPT_INFO_S *pSendOptInfo,  MMS_MESSAGE_DATA_S *pMmsMsg, char **pDestMsg)
 599 {
 600         if (mPlgHandler.pfGetMmsMessage != NULL) {
 601                 return mPlgHandler.pfGetMmsMessage(pMsg, pSendOptInfo, pMmsMsg, pDestMsg);
 602         } else {
 603                 return MSG_ERR_INVALID_PLUGIN_HANDLE;
 604         }
 605 }
 606
 607
 608 MSG_ERROR_T MsgPlugin::updateRejectStatus(MSG_MESSAGE_INFO_S *pMsgInfo)
 609 {
 610         if (mPlgHandler.pfUpdateRejectStatus != NULL) {
 611                 return mPlgHandler.pfUpdateRejectStatus(pMsgInfo);
 612         } else {
 613                 return MSG_ERR_INVALID_PLUGIN_HANDLE;
 614         }
 615 }
 616
 617
 618 MSG_ERROR_T MsgPlugin::composeReadReport(MSG_MESSAGE_INFO_S *pMsgInfo)
 619 {
 620         if (mPlgHandler.pfComposeReadReport != NULL) {
 621                 return mPlgHandler.pfComposeReadReport(pMsgInfo);
 622         } else {
 623                 return MSG_ERR_INVALID_PLUGIN_HANDLE;
 624         }
 625 }
 626
 627
 628 MSG_ERROR_T MsgPlugin::restoreMsg(MSG_MESSAGE_INFO_S *pMsgInfo, char* pRecvBody, int rcvdBodyLen, char* filePath)
 629 {
 630         if (mPlgHandler.pfRestoreMsg != NULL)
 631                 return mPlgHandler.pfRestoreMsg(pMsgInfo,pRecvBody, rcvdBodyLen, filePath);
 632         else
 633                 return MSG_ERR_INVALID_PLUGIN_HANDLE;
 634 }
 635
 636
 637 /*==================================================================================================
 638                                      IMPLEMENTATION OF MsgPluginManager - Member Functions
 639 ==================================================================================================*/
 640 MsgPluginManager* MsgPluginManager::pInstance = NULL;
 641
 642
 643 MsgPluginManager* MsgPluginManager::instance()
 644 {
 645         if (pInstance == NULL)
 646                 pInstance = new MsgPluginManager();
 647
 648         return pInstance;
 649 }
 650
 651
 652 MsgPluginManager::MsgPluginManager()
 653 {
 654
 655 }
 656
 657
 658 void MsgPluginManager::initialize()
 659 {
 660         char path[64];
 661
 662         memset(path, 0x00, sizeof(path));
 663         snprintf(path, sizeof(path), "%s%s", MSG_PLUGIN_CFG_PATH, MSG_PLUGIN_CFG_NAME);
 664
 665         loadPlugins(path);
 666 }
 667
 668
 669 void MsgPluginManager::finalize()
 670 {
 671         MsgPluginMap::iterator it;
 672
 673         for (it = plgMap.begin(); it != plgMap.end(); it++)
 674         {
 675                 MsgPlugin temp = it->second;
 676                 temp.finalize();
 677         }
 678
 679         plgMap.clear();
 680 }
 681
 682
 683 void MsgPluginManager::loadPlugins(const char* path)
 684 {
 685         /* read plugins from configuration file */
 686         FILE* fp = MsgOpenFile(path, "rt");
 687
 688         MsgPlgConfig plgConf = MsgPlgConfig(fp);
 689
 690         for (int i=0; i < plgConf.titleCount(); i++)
 691         {
 692                 MsgPlgToken tok;
 693
 694                 plgConf.token(i, 0, tok);
 695                 const char* content = tok.getVal();
 696
 697                 MSG_MAIN_TYPE_T mainType = strstr(content,"sms")? MSG_SMS_TYPE:
 698                                                         (strstr(content,"mms")? MSG_MMS_TYPE: MSG_UNKNOWN_TYPE);
 699
 700                 plgConf.token(i, 1, tok);
 701                 const char* libPath = tok.getVal();
 702
 703                 MsgPlugin* pDupPlgCheck = getPlugin(mainType);
 704
 705                 if (pDupPlgCheck)
 706                         THROW(MsgException::PLUGIN_ERROR, "Plugin for type %d is duplicated", mainType);
 707
 708                 MsgPlugin newPlg(mainType, libPath);
 709
 710                 plgMap.insert(make_pair(mainType, newPlg));
 711         }
 712
 713         MsgCloseFile(fp);
 714 }
 715
 716
 717 MsgPlugin* MsgPluginManager::getPlugin(MSG_MAIN_TYPE_T mainType)
 718 {
 719         /* Implementing the content */
 720         MsgPluginMap::iterator it = plgMap.find(mainType);
 721
 722         if (it == plgMap.end())
 723                 return NULL;
 724
 725         return &(it->second);
 726 }
 727