--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javacommons/gcfbase/src/serverconnectionfactorybase.cpp	Tue Apr 27 16:30:29 2010 +0300
@@ -0,0 +1,288 @@
+/*
+* Copyright (c) 2009 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 <memory>
+#include <iostream>
+#include <sstream>
+
+#include "logger.h"
+
+#include "serverconnectionfactorybase.h"
+#include "runtimeexception.h"
+#include "javacommonutils.h"
+#include "pusherrorcodes.h"
+#include "pushexception.h"
+#include "pendingconnectionlistener.h"
+
+using namespace java::push;
+using namespace java::runtime;
+using namespace java::util;
+
+/**
+ *
+ */
+OS_EXPORT ServerConnectionFactoryBase::ServerConnectionFactoryBase()
+{
+}
+
+/**
+ *
+ */
+OS_EXPORT ServerConnectionFactoryBase::~ServerConnectionFactoryBase()
+{
+    JELOG2(EJavaPush);
+    try
+    {
+        for (SrvConnContainerIter_t iter = mServerConnections.begin();
+                iter != mServerConnections.end(); ++iter)
+        {
+            delete(iter->second.getConn());
+        }
+        mServerConnections.clear();
+    }
+    catch (...)
+    {
+        ELOG(EJavaPush,"ERROR!!! ~ServerConnectionFactoryBase(): Unexpected exception was caught");
+    }
+}
+
+/**
+ *
+ */
+OS_EXPORT ServerConnection&
+ServerConnectionFactoryBase::createPushServerConn(const std::wstring& aUri,
+        const std::wstring& aFilter,
+        ConnectionListener* aListener,
+        PendingConnectionListener* aPendingConnListener)
+{
+    JELOG2(EJavaPush);
+    ScopedLock lockObj(mMutex);
+
+    SrvConnContainerIter_t iter = mServerConnections.find(aUri);
+    if (iter != mServerConnections.end())
+    {
+        if ((SrvConnContainerData::PUSH == iter->second.connType())
+                || (SrvConnContainerData::PUSH_LISTEN_BY_MIDLET == iter->second.connType()))
+        {
+            std::string errTxt("Object already exists");
+            ELOG1(EJavaPush, "ERROR: %s",errTxt.c_str());
+            ELOG1WSTR(EJavaPush,"Error in createPushServerConn() URI: %s",aUri);
+            throw PushException(PUSH_CONNECTION_ALREADY_EXISTS,errTxt,__FILE__,__FUNCTION__,__LINE__);
+        }
+        else
+        {
+            //Connection type is NORMAL so we have to change it to PUSH_LISTEN_BY_MIDLET.
+            iter->second.setConnType(SrvConnContainerData::PUSH_LISTEN_BY_MIDLET);
+            iter->second.setPendingConnListener(aPendingConnListener);
+            iter->second.getConn()->setFilter(aFilter);
+            return *(iter->second.getConn());
+        }
+    }
+    std::auto_ptr<ServerConnection> newSrvConn(createSrvConnObj(aUri,aFilter));
+    newSrvConn->open(aListener);
+    SrvConnContainerData newDataObj(newSrvConn.release(),aPendingConnListener,
+                                    false,SrvConnContainerData::PUSH);
+    mServerConnections.insert(std::pair<std::wstring,SrvConnContainerData>(aUri,newDataObj));
+
+    return *(newDataObj.getConn());
+}
+
+/**
+ *
+ */
+OS_EXPORT ServerConnection* ServerConnectionFactoryBase::create(const std::wstring& aUri)
+{
+    JELOG2(EJavaPush);
+    ScopedLock lockObj(mMutex);
+
+    SrvConnContainerIter_t iter = mServerConnections.find(aUri);
+    if (iter == mServerConnections.end())
+    {
+        std::auto_ptr<ServerConnection> newSrvConn(createSrvConnObj(aUri,L""));
+        SrvConnContainerData newDataObj(newSrvConn.release(),0,false,SrvConnContainerData::NORMAL);
+        mServerConnections.insert(std::pair<std::wstring,SrvConnContainerData>(aUri,newDataObj));
+        return newDataObj.getConn();
+    }
+
+    if (!isMultipleSrvConnAllowed())
+    {
+        if (SrvConnContainerData::PUSH_LISTEN_BY_MIDLET == iter->second.connType()
+                || SrvConnContainerData::NORMAL == iter->second.connType())
+        {
+            std::string errTxt("Type of the connection is: ");
+            errTxt.append(java::util::JavaCommonUtils::intToString((int)iter->second.connType()));
+            throw PushException(PUSH_CONNECTION_ALREADY_EXISTS,errTxt,__FILE__,__FUNCTION__,__LINE__);
+        }
+    }
+
+    if (SrvConnContainerData::PUSH == iter->second.connType())
+    {
+        iter->second.setConnType(SrvConnContainerData::PUSH_LISTEN_BY_MIDLET);
+    }
+
+    return (*iter).second.getConn();
+}
+
+/**
+ *
+ */
+OS_EXPORT void
+ServerConnectionFactoryBase::getPushConnections(bool aAvailable,std::list<std::wstring>& aUriList)
+{
+    JELOG2(EJavaPush);
+    ScopedLock lockObj(mMutex);
+
+    for (SrvConnContainerIter_t iter = mServerConnections.begin(); iter != mServerConnections.end(); ++iter)
+    {
+        if ((SrvConnContainerData::PUSH == iter->second.connType())
+                || (SrvConnContainerData::PUSH_LISTEN_BY_MIDLET == iter->second.connType()))
+        {
+            if (true == aAvailable)
+            {
+                if (true == iter->second.isActive())
+                {
+                    aUriList.push_back((iter->first));
+                }
+            }
+            else
+            {
+                WLOG1WSTR(EJavaPush,"ServerConnectionFactoryBase::getPushConnections() URI: %s",(iter->first));
+                aUriList.push_back((iter->first));
+            }
+        }//end if( (SrvConnContainerData::PUSH == iter->second.connType())...)
+    }//end for
+}
+
+/**
+ *
+ */
+OS_EXPORT void ServerConnectionFactoryBase::closeAllConnections()
+{
+    JELOG2(EJavaPush);
+    ScopedLock lockObj(mMutex);
+
+    for (SrvConnContainerIter_t iter = mServerConnections.begin(); iter != mServerConnections.end();)
+    {
+        if (false == deletePushConnection(iter))
+            iter++;
+    }//end for
+}
+
+/**
+ *
+ */
+OS_EXPORT void ServerConnectionFactoryBase::deletePushConnection(const std::wstring& aUri)
+{
+    JELOG2(EJavaPush);
+    ScopedLock lockObj(mMutex);
+
+    SrvConnContainerIter_t iter = mServerConnections.find(aUri);
+    if (iter == mServerConnections.end())
+        return;
+    deletePushConnection(iter);
+}
+
+/**
+ *
+ */
+bool ServerConnectionFactoryBase::deletePushConnection(SrvConnContainerIter_t& aIter)
+{
+    JELOG2(EJavaPush);
+
+    if (SrvConnContainerData::PUSH == aIter->second.connType())
+    {
+        aIter->second.getConn()->close();
+        delete aIter->second.getConn();
+        mServerConnections.erase(aIter++);
+        return true;
+    }
+    else if (SrvConnContainerData::PUSH_LISTEN_BY_MIDLET == aIter->second.connType())
+    {
+        //MIDlet listens connection so we cannot delete it here.
+        aIter->second.setConnType(SrvConnContainerData::NORMAL);
+    }
+    //This method does nothing for non-push server connection. Non-push
+    //connections must be release by releaseConnection operation.
+    return false;
+}
+
+/**
+ *
+ */
+OS_EXPORT ServerConnection* ServerConnectionFactoryBase::getPushConnection(const std::wstring& aUri)
+{
+    JELOG2(EJavaPush);
+    ScopedLock lockObj(mMutex);
+
+    SrvConnContainerIter_t iter = mServerConnections.find(aUri);
+    if (iter == mServerConnections.end())
+        return 0;
+    if (SrvConnContainerData::NORMAL == iter->second.connType())
+        return 0;
+    return iter->second.getConn();
+}
+
+/**
+ *
+ */
+OS_EXPORT void ServerConnectionFactoryBase::releaseConnection(const std::wstring& aUri)
+{
+    JELOG2(EJavaPush);
+    ScopedLock lockObj(mMutex);
+
+    SrvConnContainerIter_t iter = mServerConnections.find(aUri);
+    if (iter == mServerConnections.end())
+        return;
+
+    if (SrvConnContainerData::NORMAL == iter->second.connType())
+    {
+        iter->second.getConn()->close();
+        delete iter->second.getConn();
+        mServerConnections.erase(iter);
+        return;
+    }
+    else if (SrvConnContainerData::PUSH_LISTEN_BY_MIDLET == iter->second.connType())
+    {
+        iter->second.getConn()->close();
+        iter->second.setConnType(SrvConnContainerData::PUSH);
+        return;
+    }
+    //This operation does nothing for connection which type is PUSH.
+}
+
+/**
+ *
+ */
+OS_EXPORT void ServerConnectionFactoryBase::setPendingMsgFlag
+(const std::wstring& aUri,bool aPendingMsg)
+{
+    JELOG2(EJavaPush);
+    ScopedLock lockObj(mMutex);
+
+    //LOG1WSTR(EJavaPush,EInfo,"setPendingMsgFlag() URI: %s",aUri);
+    //LOG1(EJavaPush,EInfo,"setPendingMsgFlag() aPendingMsg: %d",(int)aPendingMsg);
+
+    SrvConnContainerIter_t iter = mServerConnections.find(aUri);
+    if (iter != mServerConnections.end())
+    {
+        iter->second.setActive(aPendingMsg);
+        PendingConnectionListener* tmpListener = iter->second.getPendingConnListener();
+        if (0 != tmpListener)
+            tmpListener->setPendingStatus(aUri,aPendingMsg);
+    }
+}
+