1 /*

     2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: Java Captain extension plugin for RMS

    15 *

    16 */

    17 

    18 #include <string>

    19 

    20 #include "logger.h"

    21 #include "coreinterface.h"

    22 #include "comms.h"

    23 #include "commsmessage.h"

    24 #include "commsendpoint.h"

    25 

    26 #include "rmsextensionplugin.h"

    27 

    28 #ifdef __SYMBIAN32__

    29 java::captain::ExtensionPluginInterface* getExtensionPlugin()

    30 {

    31 #else

    32 extern "C" java::captain::ExtensionPluginInterface* getExtensionPlugin()

    33 {

    34 #endif

    35     return new java::rms::RmsExtensionPlugin();

    36 }

    37 

    38 using namespace java::rms;

    39 

    40 RmsExtensionPlugin::RmsExtensionPlugin() : mCore(0)

    41 {

    42 }

    43 

    44 RmsExtensionPlugin::~RmsExtensionPlugin()

    45 {

    46 }

    47 

    48 void RmsExtensionPlugin::startPlugin(CoreInterface* aCore)

    49 {

    50     LOG(EMidpRms, EInfo, "RmsExtensionPlugin::startPlugin()");

    51     mCore = aCore;

    52     mCore->getComms()->registerListener(PLUGIN_ID_RMS_C, this);

    53 }

    54 

    55 void RmsExtensionPlugin::stopPlugin()

    56 {

    57     LOG(EMidpRms, EInfo, "RmsExtensionPlugin::stopPlugin()");

    58     mCore->getComms()->unregisterListener(PLUGIN_ID_RMS_C, this);

    59     mCore = 0;

    60     mListeners.clear();

    61 }

    62 

    63 CommsListener* RmsExtensionPlugin::getCommsListener()

    64 {

    65     return this;

    66 }

    67 

    68 void RmsExtensionPlugin::processMessage(CommsMessage& aMessage)

    69 {

    70     JELOG2(EMidpRms);

    71 

    72     switch (aMessage.getMessageId())

    73     {

    74     case MSG_ID_RECORD_CHANGE:

    75     {

    76         std::string recordStore;

    77         aMessage >> recordStore;

    78         notifyListeners(recordStore, aMessage);

    79         break;

    80     }

    81     case MSG_ID_LISTENER_CHANGE:

    82     {

    83         std::string recordStore;

    84         int operation = 0;

    85         aMessage >> recordStore >> operation;

    86         if (operation == ADD_LISTENER)

    87         {

    88             addListener(recordStore, aMessage.getSender());

    89         }

    90         else

    91         {

    92             removeListener(recordStore, aMessage.getSender());

    93         }

    94         sendListenerCount(recordStore, aMessage);

    95         break;

    96     }

    97     default:

    98         WLOG1(EMidpRms, "processMessage() unknown message received, msgId:%d", aMessage.getMessageId());

    99         break;

   100     }

   101 }

   102 

   103 void RmsExtensionPlugin::addListener(std::string aName, int aAddress)

   104 {

   105     LOG2(EMidpRms, EInfo, "addListener(%s, %d)", aName.c_str(), aAddress);

   106     mListeners[aName].push_back(aAddress);

   107 }

   108 

   109 void RmsExtensionPlugin::removeListener(std::string aName, int aAddress)

   110 {

   111     listenersIterator iter = mListeners.find(aName);

   112     if (iter != mListeners.end())

   113     {

   114         for (std::vector<int>::iterator it = iter->second.begin(); it < iter->second.end(); it++)

   115         {

   116             if (aAddress == *it)

   117             {

   118                 LOG3(EMidpRms, EInfo, "removeListener(%s, %d, left=%d)",

   119                      aName.c_str(), aAddress, iter->second.size()-1);

   120                 iter->second.erase(it);

   121                 break;

   122             }

   123         }

   124         if (iter->second.size() == 0)

   125         {

   126             mListeners.erase(iter);

   127         }

   128     }

   129 }

   130 

   131 void RmsExtensionPlugin::notifyListeners(std::string aName, CommsMessage& aMessage)

   132 {

   133     listenersIterator iter = mListeners.find(aName);

   134     if (iter != mListeners.end())

   135     {

   136         CommsMessage notifyMsg = aMessage;

   137         notifyMsg.setMessageRef(0);

   138         for (std::vector<int>::iterator it = iter->second.begin(); it < iter->second.end();)

   139         {

   140             if (aMessage.getSender() != *it)

   141             {

   142                 LOG2(EMidpRms, EInfo, "notifyListeners(%s, %d)", aName.c_str(), *it);

   143                 notifyMsg.setReceiver(*it);

   144                 int rc = send(notifyMsg);

   145                 if (rc != 0)

   146                 {

   147                     ELOG2(EMidpRms, "notifyListeners() failed (%s, %d)", aName.c_str(), *it);

   148                     it = iter->second.erase(it);

   149                     continue;

   150                 }

   151             }

   152             it++;

   153         }

   154         if (iter->second.size() == 0)

   155         {

   156             mListeners.erase(iter);

   157         }

   158     }

   159 }

   160 

   161 void RmsExtensionPlugin::sendListenerCount(std::string aName, CommsMessage& aSender)

   162 {

   163     listenersIterator iter = mListeners.find(aName);

   164     if (iter != mListeners.end())

   165     {

   166         CommsMessage msg = createListenerCountMsg(aName, iter->second.size());

   167         LOG2(EMidpRms, EInfo, "sendListenerCount(%s, %d)", aName.c_str(), iter->second.size());

   168         for (std::vector<int>::iterator it = iter->second.begin(); it < iter->second.end(); it++)

   169         {

   170             msg.setReceiver(*it);

   171             if (msg.getReceiver() == aSender.getSender())

   172             {

   173                 // ensures that sender can use comms.sendReceive()

   174                 msg.replyTo(aSender);

   175                 msg.setMessageId(MSG_ID_LISTENER_COUNT);

   176             }

   177             send(msg);

   178         }

   179     }

   180 }

   181 

   182 CommsMessage RmsExtensionPlugin::createListenerCountMsg(std::string aName, int aCount)

   183 {

   184     CommsMessage msg;

   185     msg.setModuleId(PLUGIN_ID_RMS_C);

   186     msg.setMessageId(MSG_ID_LISTENER_COUNT);

   187     msg << aName << aCount;

   188     return msg;

   189 }

   190 

   191 

   192 int RmsExtensionPlugin::send(CommsMessage& aMessage)

   193 {

   194     int rc = mCore->getComms()->send(aMessage);

   195     return rc;

   196 }