/*

* 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:

*

*/

#ifndef SERVERCONNECTIONFACTORYBASE_H

#define SERVERCONNECTIONFACTORYBASE_H

#include <map>

#include "serverconnectionfactory.h"

#include "serverconnection.h"

#include "scopedlocks.h"

namespace java

{

namespace push

{

class PendingConnectionListener;

/**

 * This class is internal helper class of ServerConnectionFactoryBase class.

 * This class contains data of one ServerConnection object.

 */

class SrvConnContainerData

{

public:

    enum ServerConnectionType_t

    {

        PUSH, //Push server connection which is listen by Push Controller

        NORMAL, //non-push server connection

        PUSH_LISTEN_BY_MIDLET //Push server connection listen by MIDlet.

    };

    /**

     * @param aConn This class does not take ownership of this argument.

     */

    SrvConnContainerData(ServerConnection* aConn,PendingConnectionListener* aListener,

                         bool aIsActive,ServerConnectionType_t aType)

            :mSrvConn(aConn),mPendingConnListener(aListener),mIsActive(aIsActive),mConnType(aType)

    {

    }

    virtual ~SrvConnContainerData()

    {

    }

    ServerConnection* getConn() const

    {

        return mSrvConn;

    }

    void setPendingConnListener(PendingConnectionListener* aListener)

    {

        mPendingConnListener = aListener;

    }

    PendingConnectionListener* getPendingConnListener() const

    {

        return mPendingConnListener;

    }

    void setActive(bool aIsActive)

    {

        mIsActive = aIsActive;

    }

    bool isActive() const

    {

        return mIsActive;

    }

    void setConnType(ServerConnectionType_t aConnType)

    {

        mConnType = aConnType;

    }

    ServerConnectionType_t connType() const

    {

        return mConnType;

    }

    SrvConnContainerData(const SrvConnContainerData &x)

    {

        *this = x;

    }

    SrvConnContainerData &operator=(const SrvConnContainerData &x)

    {

        mSrvConn = x.mSrvConn;

        mPendingConnListener = x.mPendingConnListener;

        mIsActive = x.mIsActive;

        mConnType = x.mConnType;

        return *this;

    }

private:

    //Datamembers.

    //This class does not take ownership of this datamember.

    ServerConnection* mSrvConn;

    PendingConnectionListener* mPendingConnListener;

    //Indicates whether incoming message has arrived to the connection.

    bool mIsActive;

    ServerConnectionType_t mConnType;

};

/**

 * This class has "default" implementation of ServerConnectionFactory interface.

 * Probably this implementation is enough for most of protocols. I.e. it is recommened

 * to use this implementation if protocol does not have special reguirements for

 * implementation of ServerConnectionFactory.

 */

class ServerConnectionFactoryBase : public ServerConnectionFactory

{

public:

    OS_IMPORT ServerConnectionFactoryBase();

    OS_IMPORT virtual ~ServerConnectionFactoryBase();

    //Methods of ServerConnectionFactory interface.

    /**

     * See comments from ServerConnectionFactory::createPushServerConn() operation.

     */

    OS_IMPORT virtual ServerConnection& createPushServerConn(const std::wstring& aUri,

            const std::wstring& aFilter,

            ConnectionListener* aListener,

            PendingConnectionListener* aPendingConnListener);

    /**

     * This operation creates ServerConnection if it is not already created.

     * @exception throws RuntimeException if type of the existing ServerConnection

     *            object is PUSH_LISTEN_BY_MIDLET || PUSH and isMultipleSrvConnAllowed()

     *            operation returns 'false'.

     */

    OS_IMPORT virtual ServerConnection* create(const std::wstring& aUri);

    /**

     * Returns all connections which connection type is PUSH_LISTEN_BY_MIDLET || PUSH.

     */

    OS_IMPORT virtual void getPushConnections(bool aAvailable,std::list<std::wstring>& aUriList);

    /**

     * See comments ServerConnectionFactory::closeAllConnections() operation.

     */

    OS_IMPORT virtual void closeAllConnections();

    /**

     * See comments ServerConnectionFactory::deletePushConnection() operation.

     */

    OS_IMPORT virtual void deletePushConnection(const std::wstring& aUri);

    /**

     * See comments ServerConnectionFactory::getPushConnection() operation.

     */

    OS_IMPORT virtual ServerConnection* getPushConnection(const std::wstring& aUri);

    /**

     * See comments ServerConnectionFactory::releaseConnection() operation.

     */

    OS_IMPORT virtual void releaseConnection(const std::wstring& aUri);

    /**

     * Implementation class of the ServerConnection interface must update status whether

     * ServerConnection object has pending message(= message arrived but not yet read).

     * This information is needed for PushRegistry.listConnections() operation. MIDlet can

     * retrieve by this operation active but not handled connections.

     * @param aUri        URI of the connection.

     * @param aPendingMsg Updating logic of pending message flag:

     *                    - Set it 'true' when message arrives to the connection.

     *                    - Set it 'false' when ServerConnection::open() operation has been called.

     */

    OS_IMPORT void setPendingMsgFlag(const std::wstring& aUri,bool aPendingMsg);

    /**

     * This operation creates protocol specific ServerConnection object. Validation of

     * arguments must be done com.nokia.mj.impl.gcf.PushValidator java framework.

     * Note: This operation does not open push connection.

     * @param aUri    ServerConnection URI.

     * @param aFilter Connection URL indicating which senders are allowed to cause

       *                the MIDlet to be launched.

       *                Value of this argument is empty string in the normal server connection case.

       *                Note: START_APP_IN_LISTEN_MODE mode is used in the creation of normal server connection.

       * @throws        PushException with following error codes:

       *                COMMON_SRV_CONN_PLUGIN_ERROR:

       *                reserved for other errors in the creation of ServerConnection object.

     */

    virtual ServerConnection* createSrvConnObj(const std::wstring& aUri,

            const std::wstring& aFilter) = 0;

    /**

     * This method indicates whether multiple Connector.open() operation call is allowed

     * for a connection. Normally this is not allowed but e.g. for some new protocol it might

     * be allowed.

     */

    virtual bool isMultipleSrvConnAllowed() = 0;

protected:

    typedef std::map<std::wstring,SrvConnContainerData> SrvConnContainer_t;

    typedef std::map<std::wstring,SrvConnContainerData>::iterator SrvConnContainerIter_t;

    //Datamembers.

    SrvConnContainer_t mServerConnections;

    java::util::ScopedMutex mMutex;

private:

    //Internal operations.

    bool deletePushConnection(SrvConnContainerIter_t& aIter);

    //Not implemented.

    ServerConnectionFactoryBase(const ServerConnectionFactoryBase &x);

    ServerConnectionFactoryBase &operator=(const ServerConnectionFactoryBase &x);

};

}//end namespace push

}//end namespace java

#endif // SERVERCONNECTIONFACTORYBASE_H