diff -r f5050f1da672 -r 04becd199f91 javaextensions/midppush/pushcontroller/src/pushcontrollerstarterimpl.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javaextensions/midppush/pushcontroller/src/pushcontrollerstarterimpl.cpp	Tue Apr 27 16:30:29 2010 +0300
@@ -0,0 +1,950 @@
+/*
+* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+
+#include <errno.h>
+#include <pthread.h>
+#include <iostream>
+#include <sstream>
+
+#include "logger.h"
+
+#include "dynamiclibloader.h"
+#include "runtimeexception.h"
+#include "javaosheaders.h"
+
+#include "midpruntimepushsupport.h"
+
+#include "pushcontrollerstarterimpl.h"
+#include "serverconnectionfactory.h"
+#include "serverconnection.h"
+#include "pushregistrymessages.h"
+#include "comms.h"
+#include "commsclientendpoint.h"
+#include "commsmessage.h"
+#include "javacommonutils.h"
+#include "pusherrorcodes.h"
+#include "pushexception.h"
+#include "pushconstant.h"
+#include "javauid.h"
+#include "libraryloaderexception.h"
+
+using namespace java::push;
+using namespace java::runtime;
+using namespace java::comms;
+using namespace java::util;
+using namespace std;
+
+#if defined(__SYMBIAN32__) && defined(__WINSCW__)
+#include <pls.h>
+#else
+static PushControllerStarterImpl* sPushContStarter = 0;
+#endif
+
+#ifdef __SYMBIAN32__
+PushControllerStarter& getPushControllerStarter()
+{
+#else
+extern "C" PushControllerStarter& getPushControllerStarter()
+{
+#endif
+
+    JELOG2(EJavaPush);
+
+#if defined(__SYMBIAN32__) && defined(__WINSCW__)
+    TUid uid = TUid::Uid(0xE0000050);
+    PushControllerStarterImpl* retObj = Pls<PushControllerStarterImpl>(uid);
+    return *retObj;
+#else
+    if (sPushContStarter == 0)
+    {
+        sPushContStarter = new PushControllerStarterImpl();
+    }
+    return *sPushContStarter;
+#endif
+}
+
+/**
+ *
+ */
+PushControllerStarterImpl::PushControllerStarterImpl()
+        : mSrvConnPluginMgr(0),mAppStateController(0),mState(INITIAL_STATE),
+        mThreadId(0),mMonitor(Monitor::createMonitor()),mConnCompletedMonitor(0),
+        mIsUpdate(false),mNumOfPendingUpdates(0)
+{
+    JELOG2(EJavaPush);
+    mSrvConnPluginMgr.reset(new PushServerConnPluginManager(this,this,this));
+}
+
+/**
+ *
+ */
+PushControllerStarterImpl::~PushControllerStarterImpl()
+{
+    JELOG2(EJavaPush);
+    try
+    {
+        CommsClientEndpoint& comms = getComms();
+        comms.unregisterListener(PLUGIN_ID_PUSH_CONTROLLER_C,this);
+    }
+    catch (...) {}
+}
+
+/**
+ * This operation throws exception if initialization of all connections
+ * fails. RuntimeStarter closes application if it gets exception from this
+ * operation.
+ * MidpStarterPushSupport::closeRuntimeRequestFromPush()
+ * operation is called from error() operation if opening all connections fails.
+ */
+void PushControllerStarterImpl::startListen(const java::util::Uid& aUid,
+        MidpStarterPushSupport* aAppStateController)
+{
+    JELOG2(EJavaPush);
+
+    setState(LOADING_PUSH_CONNS);
+    mAppStateController = aAppStateController;
+
+    registerCommsListener();
+    mIsUpdate = false;
+    mUid = aUid;
+    bool retValue = sendGetAllPushRegsMsg(false);
+    if (false == retValue)
+        setState(INITIAL_STATE);
+}
+
+/**
+ *
+ */
+void PushControllerStarterImpl::updatePushRegs(const java::util::Uid& aUid,
+        MidpStarterPushSupport* aAppStateController)
+
+{
+    JELOG2(EJavaPush);
+    updatePushRegs2(aUid,aAppStateController,false);
+}
+
+/**
+ * This operation can not throw exceptions.
+ * This operation is always called from comms thread so locks for mNumOfPendingUpdates
+ * datamember is not needed. Value of mNumOfPendingUpdates datamember is increased if
+ * previous updating is ongoing when next update request arrives.
+ */
+void PushControllerStarterImpl::updatePushRegs2(const java::util::Uid& aUid,
+        MidpStarterPushSupport* aAppStateController,
+        bool aThrowingExceptionAllowed)
+{
+    JELOG2(EJavaPush);
+
+    try
+    {
+        if (LOADING_PUSH_CONNS == getState())
+        {
+            ++mNumOfPendingUpdates;
+            return;
+        }
+
+        registerCommsListener();
+        mUid = aUid;
+        mAppStateController = aAppStateController;
+        mIsUpdate = true;
+        sendGetAllPushRegsMsg(aThrowingExceptionAllowed);
+        ++mNumOfPendingUpdates;
+    }
+    catch (...)
+    {
+        ELOG(EJavaPush,"ERROR!!! updatePushRegs2(): Unexpected exception was caught");
+        if (true == aThrowingExceptionAllowed)
+            throw;
+    }
+}
+
+/**
+ *
+ */
+void PushControllerStarterImpl::close()
+{
+    JELOG2(EJavaPush);
+    try
+    {
+        //Destructor of PushServerConnPluginManager class calls
+        //ServerConnectionFactory::closeAllConnections() operation for each plugin.
+        delete mSrvConnPluginMgr.release();
+        setState(INITIAL_STATE);
+    }
+    catch (...)
+    {
+        ELOG(EJavaPush,"ERROR!!! PushControllerStarterImpl::close(): Unexpected exception was caught");
+    }
+}
+
+/**
+ *
+ */
+void PushControllerStarterImpl::msgArrived(const std::wstring& aInfo)
+{
+    JELOG2(EJavaPush);
+
+    if (0 != mAppStateController)
+    {
+        mAppStateController->startMidletRequestFromPush(aInfo);
+    }
+}
+
+/**
+ *
+ */
+void PushControllerStarterImpl::error(const std::wstring& aUri,int aErrCode,
+                                      const std::string& aErrText)
+{
+    JELOG2(EJavaPush);
+
+    ELOG2(EJavaPush, "ERROR!!! err code: %d, err txt: %s",aErrCode,aErrText.c_str());
+    int numOfSuccessfulConns = getPushServerConnPluginManager().setConnFailed(aUri);
+    if (0 == numOfSuccessfulConns)
+    {
+        sendAllConnsFailedMsg();
+        closeRuntime();
+    }
+}
+
+/**
+ *
+ */
+void PushControllerStarterImpl::processMessage(CommsMessage& aMessage)
+{
+    JELOG2(EJavaPush);
+
+    switch (aMessage.getMessageId())
+    {
+    case IPC_PR_LIST_OF_ALL_PUSH_REGS:
+    {
+        handleListOfAllPushRegistrationsMsg(aMessage);
+        break;
+    }
+    case IPC_PR_CONN_MANAGED_BY_OTHER_MIDLET:
+    {
+        mConnCompletedMonitor->notify();
+        break;
+    }
+    default:
+        ELOG1(EJavaPush, "ERROR!!! Unsupported method arrives to processMessage(): %d",
+              aMessage.getMessageId());
+    }//end switch
+}
+
+/**
+ *
+ */
+bool PushControllerStarterImpl::sendGetAllPushRegsMsg(bool aThrowingExceptionAllowed)
+{
+    JELOG2(EJavaPush);
+
+    CommsMessage getAllPushRegsMsg;
+    getAllPushRegsMsg.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C);
+    getAllPushRegsMsg.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C);
+    getAllPushRegsMsg.setModuleId(PLUGIN_ID_PUSH_REGISTRY_C);
+    getAllPushRegsMsg.setMessageId(IPC_PR_GET_ALL_PUSH_REGS);
+
+    getAllPushRegsMsg << mUid;
+    CommsClientEndpoint& comms = getComms();
+    EState stateOfObj = getState();
+    setState(LOADING_PUSH_CONNS);
+    int retValue = comms.send(getAllPushRegsMsg);
+    if (0 != retValue)
+    {
+        setState(stateOfObj);
+        std::string errTxt("Sending a comms request failed: ");
+        errTxt.append(java::util::JavaCommonUtils::intToString(retValue));
+        ELOG1(EJavaPush, "ERROR!!! %s",errTxt.c_str());
+        if (false == aThrowingExceptionAllowed)
+        {
+            sendAllConnsFailedMsg();
+            closeRuntime();
+            return false;
+        }
+        throw PushException(GENERAL_COMMS_ERROR,errTxt,__FILE__,__FUNCTION__,__LINE__);
+    }
+    //setState(LOADING_PUSH_CONNS);
+    return true;
+}
+
+/**
+ *
+ */
+void PushControllerStarterImpl::handleListOfAllPushRegistrationsMsg(CommsMessage& aMessage)
+{
+    JELOG2(EJavaPush);
+
+    try
+    {
+        //std::string tmpErrTxt("Retrieving push registrations failed");
+        validateCommonParamsOfReplyCommsMsg(0,IPC_PR_LIST_OF_ALL_PUSH_REGS,
+                                            aMessage,mUid);
+        std::wstring uriStr;
+        std::wstring filterStr;
+        PushServerConnPluginManager::UriList_t uriList;
+        while ((aMessage >> uriStr))
+        {
+            if (!(aMessage >> filterStr))
+            {
+                throw PushException(INCORRECT_COMMS_MSG,"Could not resolve 'filter' parameter",
+                                    __FILE__,__FUNCTION__,__LINE__);
+            }
+            PushRegData tmpObj(uriStr,filterStr);
+            uriList.push_back(tmpObj);
+        }
+
+        if (false == mIsUpdate)
+            getPushServerConnPluginManager().startListen(uriList,false,true);
+        else
+        {
+            getPushServerConnPluginManager().updatePushRegs(uriList,*this);
+            //In this case updatePushRegs() has called closeRuntime() operation
+            //so no sense to retrieve new updates.
+            if (INITIAL_STATE == getState())
+                return;
+
+            if (1 < mNumOfPendingUpdates)
+            {
+                --mNumOfPendingUpdates;
+                sendGetAllPushRegsMsg(false);
+                return;
+            }
+            else if (1 == mNumOfPendingUpdates)
+                --mNumOfPendingUpdates;
+        }//end else
+
+        setState(PUSH_CONNS_LOADED);
+    }
+    catch (PushException& ex)
+    {
+        setState(INITIAL_STATE);
+        ELOG1(EJavaPush, "ERROR!!! PushControllerStarterImpl::getAndInitAllPushRegs(): %s",
+              ex.toString().c_str());
+        //"All connection has failed" message is sent to pushregistryplugin if any error occurs
+        //when push connections are retrieved. This prevents infinite loop if pushregistryplugin
+        //has problems to provide push connections.
+        sendAllConnsFailedMsg();
+        closeRuntime();
+
+    }
+    catch (...)
+    {
+        setState(INITIAL_STATE);
+        ELOG(EJavaPush,"ERROR!!! getAndInitAllPushRegs(): Unexpected exception was caught");
+        sendAllConnsFailedMsg();
+        closeRuntime();
+    }
+    mIsUpdate = false;
+    mMonitor->notify();
+}
+
+/**
+ *
+ */
+void PushControllerStarterImpl::registerDynamicPushConn(const std::wstring& aUri,
+        const std::wstring& aMidlet,
+        const std::wstring& aFilter,
+        const Uid& aUid,
+        bool aIsUidOfThisMidlet)
+{
+    JELOG2(EJavaPush);
+
+    bool pushSrvConnObjectCreated = false;
+    try
+    {
+        int isUidOfThisMidlet = 0;
+        if (true == aIsUidOfThisMidlet)
+        {
+            loadPushConns(aUid);
+            isUidOfThisMidlet = 1;
+            PushRegData tmpRegData(aUri,aFilter);
+            PushServerConnPluginManager::UriList_t pushList;
+            pushList.push_back(tmpRegData);
+            getPushServerConnPluginManager().startListen(pushList,true,false);
+            pushSrvConnObjectCreated = true;
+        }
+
+        if (false == aIsUidOfThisMidlet)
+        {
+            registerCommsListener();
+            //We have to open a connection in this situation to be sure that connection
+            //is not already reserved. Connection is closed immediately.
+            if (false == getPushServerConnPluginManager().isValidPushUri(aUri))
+            {
+                throw PushException(PUSH_CONNECTION_ALREADY_EXISTS,
+                                    "Connection is reserved by another application",
+                                    __FILE__,__FUNCTION__,__LINE__);
+            }
+        }
+
+        sendRegDynPushConnMsg(aUri,aMidlet,aFilter,aUid,isUidOfThisMidlet);
+
+        if (false == aIsUidOfThisMidlet)
+        {
+            startToWaitCompletionOfOper();
+        }
+    }
+    catch (PushException& ex)
+    {
+        ELOG1(EJavaPush, "ERROR!!! PushControllerStarterImpl::registerDynamicPushConn(): %s",
+              ex.toString().c_str());
+        if (true == pushSrvConnObjectCreated)
+        {
+            //ScopedLock is not needed in this situation.
+            getPushServerConnPluginManager().deletePushServerConn(aUri);
+        }
+        throw;
+    }
+    catch (java::util::LibraryLoaderException& ex)
+    {
+        ELOG1(EJavaPush, "ERROR!!! PushControllerStarterImpl::registerDynamicPushConn(): %s",
+              ex.toString().c_str());
+        throw;
+    }
+    catch (...)
+    {
+        ELOG(EJavaPush,"ERROR!!! Unexpected exception was caught");
+        if (true == pushSrvConnObjectCreated)
+            getPushServerConnPluginManager().deletePushServerConn(aUri);
+        throw java::util::ExceptionBase("Unexpected error occurred",__FILE__,__FUNCTION__,__LINE__);
+    }
+}
+
+/**
+ *
+ */
+void PushControllerStarterImpl::listConnections(bool aAvailable,const java::util::Uid& aUid,
+        std::list<std::wstring>& aUriList)
+{
+    JELOG2(EJavaPush);
+
+    //loadPushConns(aUid);
+    //mSrvConnPluginMgr->listConnections(aAvailable,aUriList);
+
+    int available = 0;
+    if (true == aAvailable)
+        available = 1;
+
+    CommsMessage getPushConns;
+    getPushConns.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C);
+    getPushConns.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C);
+    getPushConns.setModuleId(PLUGIN_ID_PUSH_REGISTRY_C);
+    getPushConns.setMessageId(IPC_PR_LIST_CONNECTIONS);
+    getPushConns << aUid;
+    getPushConns << available;
+    CommsClientEndpoint& comms = getComms();
+    CommsMessage replyMsgToListConns;
+    int retValue = comms.sendReceive(getPushConns,replyMsgToListConns,COMMS_TIMEOUT);
+    //std::string tmpErrTxt("Retrieving push URIs failed");
+    validateCommonParamsOfReplyCommsMsg(retValue,IPC_PR_LIST_CONNECTIONS_REPLY,
+                                        replyMsgToListConns,aUid);
+
+    std::wstring uriStr;
+    while ((replyMsgToListConns >> uriStr))
+    {
+        aUriList.push_back(uriStr);
+    }
+}
+
+/**
+ *
+ */
+std::wstring PushControllerStarterImpl::getFilter(const std::wstring& aUri,
+        const java::util::Uid& aSuiteUid)
+{
+    JELOG2(EJavaPush);
+
+    //loadPushConns(aUid);
+    //ServerConnection& conn = mSrvConnPluginMgr->getPushConnection(aUri);
+    //return conn.getFilter();
+
+    return sendPushDataQuery(aUri,aSuiteUid,FILTER_OF_PUSH_CONN);
+}
+
+/**
+ *
+ */
+std::wstring PushControllerStarterImpl::getClassNameOfMidlet(const std::wstring& aUri,
+        const java::util::Uid& aSuiteUid)
+{
+    JELOG2(EJavaPush);
+
+    return sendPushDataQuery(aUri,aSuiteUid,CLASSNAME_OF_PUSH_CONN);
+}
+
+/**
+ *
+ */
+bool PushControllerStarterImpl::isPushConnection(const std::wstring& aUri,
+        const java::util::Uid& aUid)
+{
+    JELOG2(EJavaPush);
+
+    try
+    {
+        loadPushConns(aUid);
+        getPushServerConnPluginManager().getPushConnection(aUri);
+        return true;
+    }
+    catch (...)
+    {
+        ELOG(EJavaPush,"ERROR!!! Exception was caught");
+        return false;
+    }
+}
+
+/**
+ *
+ */
+void PushControllerStarterImpl::unregisterDynamicPushConn(const std::wstring& aUri,
+        const Uid& aUid,
+        bool aIsUidOfThisMidlet)
+{
+    JELOG2(EJavaPush);
+
+    int isUidOfThisMidlet = 0;
+    if (true == aIsUidOfThisMidlet)
+    {
+        loadPushConns(aUid);
+        isUidOfThisMidlet = 1;
+    }
+    else
+    {
+        registerCommsListener();
+    }
+
+    CommsMessage regDynPushRegMsg;
+    regDynPushRegMsg.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C);
+    regDynPushRegMsg.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C);
+    regDynPushRegMsg.setModuleId(PLUGIN_ID_PUSH_REGISTRY_C);
+    regDynPushRegMsg.setMessageId(IPC_PR_UNREGISTER_DYNAMIC_PUSH_CONN);
+    regDynPushRegMsg << aUid;
+    regDynPushRegMsg << aUri;
+    regDynPushRegMsg << isUidOfThisMidlet;
+    CommsClientEndpoint& comms = getComms();
+    CommsMessage statusOfUnRegDynConnMsg;
+    int retValue = comms.sendReceive(regDynPushRegMsg,statusOfUnRegDynConnMsg,COMMS_TIMEOUT);
+    //std::string tmpErrTxt("Unegistering a push connection failed");
+    validateCommonParamsOfReplyCommsMsg(retValue,IPC_PR_UNREGISTER_DYNAMIC_PUSH_CONN_REPLY,
+                                        statusOfUnRegDynConnMsg,aUid);
+
+    //Unregister dynamic push connection from ServerConnection Plugin if it belongs to 'this'
+    //MIDlet.
+    if (true == aIsUidOfThisMidlet)
+        getPushServerConnPluginManager().unregisterDynamicPushConn(aUri);
+    else
+    {
+        startToWaitCompletionOfOper();
+    }
+}
+
+/**
+ *
+ */
+long long PushControllerStarterImpl::registerAlarm(const long long& aAlarmTimeInMilliSecs,
+        const Uid& aSuiteUid,
+        const std::wstring& aClassNameOfMidlet,
+        bool aIsUidOfThisMidlet)
+{
+    JELOG2(EJavaPush);
+
+    LOG1WSTR(EJavaPush,EInfo, "registerAlarm() aClassNameOfMidlet: %s",aClassNameOfMidlet);
+
+    int isUidOfThisMidlet = 0;
+    if (true == aIsUidOfThisMidlet)
+        isUidOfThisMidlet = 1;
+
+    CommsMessage regAlarmMsg;
+    regAlarmMsg.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C);
+    regAlarmMsg.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C);
+    regAlarmMsg.setModuleId(PLUGIN_ID_PUSH_REGISTRY_C);
+    regAlarmMsg.setMessageId(IPC_PR_REGISTER_ALARM);
+    regAlarmMsg << aSuiteUid;
+    regAlarmMsg << aAlarmTimeInMilliSecs;
+    regAlarmMsg << aClassNameOfMidlet;
+    regAlarmMsg << isUidOfThisMidlet;
+
+    CommsClientEndpoint& comms = getComms();
+    CommsMessage statusOfRegAlarmMsg;
+    int retValue = comms.sendReceive(regAlarmMsg,statusOfRegAlarmMsg,COMMS_TIMEOUT);
+    //std::string tmpErrTxt("Setting an alarm failed");
+    validateCommonParamsOfReplyCommsMsg(retValue,IPC_PR_REGISTER_ALARM_REPLY,statusOfRegAlarmMsg,
+                                        aSuiteUid);
+
+    long long retTime = 0LL;
+    if (!(statusOfRegAlarmMsg >> retTime))
+    {
+        std::string errTxt("Cannot resolve 'time' from the IPC_PR_REGISTER_ALARM_REPLY msg");
+        throw PushException(INCORRECT_COMMS_MSG,errTxt,__FILE__,__FUNCTION__,__LINE__);
+    }
+
+    return retTime;
+}
+
+/**
+ * Note: This operation ignores all errors.
+ */
+void PushControllerStarterImpl::sendAllConnsFailedMsg()
+{
+    JELOG2(EJavaPush);
+
+    try
+    {
+        CommsMessage allConnsFailedMsg;
+        allConnsFailedMsg.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C);
+        allConnsFailedMsg.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C);
+        allConnsFailedMsg.setModuleId(PLUGIN_ID_PUSH_REGISTRY_C);
+        allConnsFailedMsg.setMessageId(IPC_PR_ALL_CONNS_FAILED);
+        allConnsFailedMsg << mUid;
+        CommsClientEndpoint& comms = getComms();
+        int retValue = comms.send(allConnsFailedMsg);
+        if (0 != retValue)
+        {
+            std::string errTxt("sendAllConnsFailedMsg() Sending a comms request failed: ");
+            errTxt.append(java::util::JavaCommonUtils::intToString(retValue));
+            ELOG1(EJavaPush, "ERROR!!! %s",errTxt.c_str());
+        }
+    }
+    catch (...)
+    {
+        ELOG(EJavaPush, "ERROR!!! Unexpected exception caught in the PushControllerStarterImpl::sendAllConnsFailedMsg()");
+    }
+}
+
+/**
+ *
+ */
+void PushControllerStarterImpl::closeRuntime()
+{
+    JELOG2(EJavaPush);
+
+    if (0 != mAppStateController)
+    {
+        mAppStateController->closeRuntimeRequestFromPush();
+        setState(INITIAL_STATE);
+    }
+}
+
+/**
+ *
+ */
+void PushControllerStarterImpl::setPendingStatus(const std::wstring& aUri,
+        bool aMsgWaitsHandling)
+{
+    JELOG2(EJavaPush);
+
+    try
+    {
+        int msgWaitsHandling = 0;
+        if (true == aMsgWaitsHandling)
+            msgWaitsHandling = 1;
+
+        CommsMessage pendingStatusMsg;
+        pendingStatusMsg.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C);
+        pendingStatusMsg.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C);
+        pendingStatusMsg.setModuleId(PLUGIN_ID_PUSH_REGISTRY_C);
+        pendingStatusMsg.setMessageId(IPC_PR_PENDING_STATUS);
+        pendingStatusMsg << mUid;
+        pendingStatusMsg << aUri;
+        pendingStatusMsg << msgWaitsHandling;
+        CommsClientEndpoint& comms = getComms();
+        int retValue = comms.send(pendingStatusMsg);
+        if (0 != retValue)
+        {
+            std::string errTxt("setPendingStatus(): Sending a comms request failed: ");
+            errTxt.append(java::util::JavaCommonUtils::intToString(retValue));
+            ELOG1(EJavaPush, "ERROR!!! %s",errTxt.c_str());
+        }
+    }
+    catch (...)
+    {
+        ELOG(EJavaPush, "ERROR!!! Unexpected exception caught in the PushControllerStarterImpl::setPendingStatus()");
+    }
+}
+
+/**
+ *
+ */
+void PushControllerStarterImpl::connCompleted(const wstring& aUri)
+{
+    JELOG2(EJavaPush);
+
+    try
+    {
+        CommsMessage unRegCompletedMsg;
+        unRegCompletedMsg.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C);
+        unRegCompletedMsg.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C);
+        unRegCompletedMsg.setModuleId(PLUGIN_ID_PUSH_REGISTRY_C);
+        unRegCompletedMsg.setMessageId(IPC_PR_CONN_COMPLETED);
+        unRegCompletedMsg << aUri;
+        CommsClientEndpoint& comms = getComms();
+        int retValue = comms.send(unRegCompletedMsg);
+        if (0 != retValue)
+        {
+            std::string errTxt("connCompleted(): Sending a comms request failed: ");
+            errTxt.append(java::util::JavaCommonUtils::intToString(retValue));
+            ELOG1(EJavaPush, "ERROR!!! %s",errTxt.c_str());
+        }
+    }
+    catch (...)
+    {
+        ELOG(EJavaPush,
+             "ERROR!!! Unexpected exception caught in the PushControllerStarterImpl::unregCompleted()");
+    }
+}
+
+/**
+ *
+ */
+CommsClientEndpoint& PushControllerStarterImpl::getComms()
+{
+    JELOG2(EJavaPush);
+
+    CommsClientEndpoint* commsObj = CommsClientEndpoint::find(L"javacaptain");
+    if (0 == commsObj)
+    {
+        throw PushException(GENERAL_COMMS_ERROR,"Retrieving CommsClientEndpoint object failed",
+                            __FILE__,__FUNCTION__,__LINE__);
+    }
+    return *commsObj;
+}
+
+/**
+ *
+ */
+void PushControllerStarterImpl::validateUid(const Uid& aUid,CommsMessage& aMessage,
+        const std::string& aFile,
+        const std::string& aFunction,int aLine)
+{
+    JELOG2(EJavaPush);
+    Uid uid;
+    if (!(aMessage >> uid))
+    {
+        std::string errTxt("Cannot resolve uid from the comms msg");
+        throw PushException(INCORRECT_COMMS_MSG,errTxt,aFile.c_str(),aFunction.c_str(),aLine);
+    }
+    if (uid != aUid)
+    {
+        std::wstring errTxt(L"Push comms msg with incorrect uid arrived: ");
+        errTxt.append(uid.toString());
+        ELOG1WSTR(EJavaPush,"ERROR!!!", errTxt);
+        throw PushException(INCORRECT_COMMS_MSG,errTxt,aFile,aFunction,aLine);
+    }
+}
+
+/**
+ *
+ */
+void PushControllerStarterImpl::checkErrorParamsOfCommsMsg(CommsMessage& aMessage)
+{
+    JELOG2(EJavaPush);
+
+    int status = 0;
+    if (!(aMessage >> status))
+    {
+        std::string errTxt("Cannot resolve status from the comms msg");
+        throw PushException(INCORRECT_COMMS_MSG,errTxt,__FILE__,__FUNCTION__,__LINE__);
+    }
+
+    if (0 != status)
+    {
+        std::string errStatusText("");
+        //Error check is not needed here.
+        aMessage >> errStatusText;
+
+        //Exception text already contains error code.
+        throw PushException(0,errStatusText,__FILE__,__FUNCTION__,__LINE__);
+    }
+
+    //Error text is skipped in the success case.
+    std::string errTxt;
+    aMessage >> errTxt;
+}
+
+/**
+ *
+ */
+void PushControllerStarterImpl::validateCommonParamsOfReplyCommsMsg
+(int aRetValue,int aMsgId,CommsMessage& aMsg,const Uid& aUid)
+{
+    JELOG2(EJavaPush);
+
+    if (0 != aRetValue)
+    {
+        std::string errTxt("Sending a comms request failed: ");
+        errTxt.append(java::util::JavaCommonUtils::intToString(aRetValue));
+        ELOG1(EJavaPush, "ERROR!!! %s",errTxt.c_str());
+        throw PushException(GENERAL_COMMS_ERROR,errTxt,__FILE__,__FUNCTION__,__LINE__);
+    }
+
+    if (aMsgId != aMsg.getMessageId())
+    {
+        std::string errTxt("Incorrect message arrived: ");
+        errTxt.append(java::util::JavaCommonUtils::intToString(aMsg.getMessageId()));
+        ELOG1(EJavaPush, "ERROR!!! %s",errTxt.c_str());
+        throw PushException(GENERAL_COMMS_ERROR,errTxt,__FILE__,__FUNCTION__,__LINE__);
+    }
+
+    validateUid(aUid,aMsg,__FILE__,__FUNCTION__,__LINE__);
+    checkErrorParamsOfCommsMsg(aMsg);
+}
+
+/**
+ * We have to call this operation in each methods of PushRegistry interface
+ * because it might be that push connections are not retrieved before MIDlet
+ * calls methods of PushRegistry. Other case is that all existing connections are
+ * failed before a new push connection is registered to teh MIDlet. In this case push
+ * connections must be retrieved from java captain.
+ */
+void PushControllerStarterImpl::loadPushConns(const java::util::Uid& aUid)
+{
+    JELOG2(EJavaPush);
+
+    EState state = getState();
+    if (INITIAL_STATE == state)
+    {
+        updatePushRegs2(aUid,mAppStateController,true);
+        mMonitor->wait();
+    }
+    else if (LOADING_PUSH_CONNS == state)
+    {
+        mMonitor->wait();
+    }
+}
+
+/**
+ *
+ */
+std::wstring PushControllerStarterImpl::sendPushDataQuery(const std::wstring& aUri,
+        const java::util::Uid& aSuiteUid,
+        const EPushInfoQueryParams& aQueryCondition)
+{
+    JELOG2(EJavaPush);
+
+    CommsMessage pushQuery;
+    pushQuery.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C);
+    pushQuery.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C);
+    pushQuery.setModuleId(PLUGIN_ID_PUSH_REGISTRY_C);
+    pushQuery.setMessageId(IPC_PR_DATA_OF_PUSH_CONN_QUERY);
+    pushQuery << aSuiteUid;
+    pushQuery << aUri;
+    pushQuery << (int) aQueryCondition;
+    CommsClientEndpoint& comms = getComms();
+    CommsMessage statusOfPushQueryMsg;
+    int retValue = comms.sendReceive(pushQuery,statusOfPushQueryMsg,COMMS_TIMEOUT);
+    //std::string tmpErrTxt("Retrieving data of the push connection failed");
+    validateCommonParamsOfReplyCommsMsg(retValue,IPC_PR_DATA_OF_PUSH_CONN_QUERY_REPLY,
+                                        statusOfPushQueryMsg,aSuiteUid);
+
+    std::wstring returnedStr;
+    if (!(statusOfPushQueryMsg >> returnedStr))
+    {
+        std::string errTxt("Cannot resolve 'filter' from the IPC_PR_DATA_OF_PUSH_CONN_QUERY_REPLY msg");
+        throw PushException(INCORRECT_COMMS_MSG,errTxt,__FILE__,__FUNCTION__,__LINE__);
+    }
+    return returnedStr;
+}
+
+/**
+ *
+ */
+void PushControllerStarterImpl::sendRegDynPushConnMsg(const std::wstring& aUri,
+        const std::wstring& aMidlet,
+        const std::wstring& aFilter,
+        const java::util::Uid& aUid,
+        int aIsUidOfThisMidlet)
+{
+    JELOG2(EJavaPush);
+
+    CommsMessage regDynPushRegMsg;
+    regDynPushRegMsg.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C);
+    regDynPushRegMsg.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C);
+    regDynPushRegMsg.setModuleId(PLUGIN_ID_PUSH_REGISTRY_C);
+    regDynPushRegMsg.setMessageId(IPC_PR_REGISTER_DYNAMIC_PUSH_CONN);
+    regDynPushRegMsg << aUid;
+    regDynPushRegMsg << aUri;
+    regDynPushRegMsg << aMidlet;
+    regDynPushRegMsg << aFilter;
+    regDynPushRegMsg << aIsUidOfThisMidlet;
+    CommsClientEndpoint& comms = getComms();
+    CommsMessage statusOfDynRegMsg;
+    int retValue = comms.sendReceive(regDynPushRegMsg,statusOfDynRegMsg,COMMS_TIMEOUT);
+    //std::string tmpErrTxt("Registering a push connection failed");
+    validateCommonParamsOfReplyCommsMsg(retValue,IPC_PR_REGISTER_DYNAMIC_PUSH_CONN_REPLY,
+                                        statusOfDynRegMsg,aUid);
+}
+
+/**
+ *
+ */
+PushServerConnPluginManager& PushControllerStarterImpl::getPushServerConnPluginManager()
+{
+    if (0 == mSrvConnPluginMgr.get())
+        mSrvConnPluginMgr.reset(new PushServerConnPluginManager(this,this,this));
+    return *mSrvConnPluginMgr.get();
+}
+
+/**
+ *
+ */
+void PushControllerStarterImpl::setState(const EState& aState)
+{
+    JELOG2(EJavaPush);
+    ScopedLock lockObj(mMutex);
+    mState = aState;
+}
+
+/**
+ *
+ */
+PushControllerStarterImpl::EState PushControllerStarterImpl::getState() const
+{
+    JELOG2(EJavaPush);
+    ScopedLock lockObj(mMutex);
+    return mState;
+}
+
+/**
+ *
+ */
+void PushControllerStarterImpl::registerCommsListener()
+{
+    CommsClientEndpoint& comms = getComms();
+    int retValue = comms.registerListener(PLUGIN_ID_PUSH_CONTROLLER_C,this);
+    if ((0 != retValue) && (retValue != EEXIST))
+    {
+        std::string errTxt("Registering to comms failed: ");
+        errTxt.append(java::util::JavaCommonUtils::intToString(retValue));
+        ELOG1(EJavaPush, "ERROR!!! %s",errTxt.c_str());
+        throw PushException(GENERAL_COMMS_ERROR,errTxt,__FILE__,__FUNCTION__,__LINE__);
+    }
+}
+
+/**
+ *
+ */
+void PushControllerStarterImpl::startToWaitCompletionOfOper()
+{
+    JELOG2(EJavaPush);
+
+    if (0 == mConnCompletedMonitor.get())
+        mConnCompletedMonitor.reset(Monitor::createMonitor());
+    mConnCompletedMonitor->wait();
+}
+