/*

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

*

*/

#ifndef PUSHDATACONTAINER_H

#define PUSHDATACONTAINER_H

#include <memory>

#include <map>

#include <set>

#include "pushregdata.h"

#include "javastorage.h"

#include "javauid.h"

#include "pushdbhandler.h"

namespace java

{

namespace captain

{

class CoreInterface;

}

namespace push

{

class PushDBHandler;

/**

 * This is internal class used by PushDataContainer class.

 */

class PushRegistrationData

{

public:

    enum RegistrationType_t {DYNAMIC_REG = 0,STATIC_REG = 1};

    PushRegistrationData(const std::wstring& aUri,const std::wstring& aMidletClass,

                         const std::wstring& aFilter,RegistrationType_t aType)

            : mUri(aUri),mMidletClass(aMidletClass),mFilter(aFilter),mType(aType),

            mPendingStatus(false) {}

    virtual ~PushRegistrationData() {}

    PushRegistrationData &operator=(const PushRegistrationData &x)

    {

        mUri = x.mUri;

        mMidletClass = x.mMidletClass;

        mFilter = x.mFilter;

        mType = x.mType;

        mPendingStatus = x.mPendingStatus;

        return *this;

    }

    PushRegistrationData(const PushRegistrationData& x)

    {

        *this = x;

    }

    std::wstring mUri;

    std::wstring mMidletClass;

    std::wstring mFilter;

    RegistrationType_t mType;

    //true' means that message has arrived to the connection.

    //'false' means that application has started to handle arrived msg of the push connection

    //        or msg has not been arrived to the connection.

    bool mPendingStatus;

};

class PushRegistrationDataWithUid

{

public:

    //This class does not take ownership of the aData argument.

    PushRegistrationDataWithUid(const java::util::Uid& aUid,

                                PushRegistrationData* aData)

            : mUid(aUid),mPushRegData(aData) {}

    virtual ~PushRegistrationDataWithUid() {}

    PushRegistrationDataWithUid &operator=(const PushRegistrationDataWithUid &x)

    {

        mUid = x.mUid;

        mPushRegData = x.mPushRegData;

        return *this;

    }

    PushRegistrationDataWithUid(const PushRegistrationDataWithUid& x)

    {

        *this = x;

    }

    //MIDlet's uid.

    java::util::Uid mUid;

    PushRegistrationData* mPushRegData;

};

/**

 * This class manages push registrations in the Java Captain process.

 * This class reads all push registrations from the Java Storage and caches

 * push registrations. Dynamic puush registrations can be register/unregister

 * via this class.

 */

class PushDataContainer

{

public:

    PushDataContainer(java::captain::CoreInterface& aCore,

                      PushDBHandler& aDbHandler);

    virtual ~PushDataContainer();

    void getIdsOfMidlets(std::set<java::util::Uid>& aUidList);

    /**

     * Informs whether MIDlet has push registrations.

     * @param aUid UID of the MIDlet.

     * @return 'true' if MIDlet has static and/or dynamic push connedction(s).

     */

    bool isPushConnections(const java::util::Uid& aUid);

    /**

     * Returns push registrations of the application.

     * @param aUid UID of the application.

     * @param aOutputList Output parameter. Contains push registrations of the application.

     */

    void getPushRegsOfMidlet(const java::util::Uid& aUid,std::list<PushRegData>& aOutputList);

    /**

     * This operation stores dynamic push registration to the java storage.

     * @param aUid          UID of the MIDlet.

     * @param aUri          Push connection URI.

     * @param aMidletName   Class name of the MIdlet.

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

       *                      the MIDlet to be launched.

     * @throws              PushException with following error codes:

     *                      PUSH_CONNECTION_ALREADY_EXISTS:

     *                      Push connection already exists.

     *                      DB_ERROR:

       *                      Inserting dynamic push connection to the database failed.

     */

    void storeDynamicPushRegistration(const java::util::Uid& aUid,const std::wstring& aUri,

                                      const std::wstring& aMidletName,

                                      const std::wstring& aFilter);

    /**

     * This operation removes dynamic push connection from the MIDlet.

     * @throws  PushException with following error codes:

     *          NOT_DYNAMIC_PUSH_URI:

     *          URI is static push URI.

     *          URI_BELONGS_TO_OTHER_MIDLET:

     *          Push URI is reserved for other MIDlet.

     *          SRV_CONN_NOT_FOUND:

     *          Server connection is not found from the push registry db.

     *          DB_ERROR:

       *          Database error occurred.

     */

    void unregisterDynamicPushRegistration(const java::util::Uid& aUid,const std::wstring& aUri);

    /**

     * This method sets MIDlet to the "do not launch" list. This means that MIDlet

     * is not try to re-launch in the listening until device has booted next time.

     * This operation does not throw exceptions.

     * @param aUid UID of the MIDlet.

     */

    void setMidletDoNotLaunchList(const java::util::Uid& aUid);

    /**

     * This method removes MIDlet to the "do not launch" list.

     * This operation does not throw exceptions.

     * @param aUid UID of the MIDlet.

     */

    void removeMidletFromDoNotLaunchList(const java::util::Uid& aUid);

    /**

     * This operation does not throw exceptions.

     * @return 'true' if MIDlet is not in the "do not launch" list.

     */

    bool isMidletInDoNotLaunchList(const java::util::Uid& aUid);

    /**

     * This operation removes application from all containers.

     */

    void removeApp(const java::util::Uid& aUid);

    /**

     * This operation reads application's push registrations from the db and adds

     * those ones into the internal cache. It also removes application from the

     * 'do not launch in the push listening mode' list.

     * @param aUid  UID of the application.

     * @throws This operation does not throw exceptions.

     */

    void readAppDataFromDb(const java::util::Uid& aUid);

    /**

     * This method updates pending status of the push connection. Pending status is needed

     * by PushRegistry.listConnections() operation when this operation is called with 'true'

     * argument.

     * @param aUid UID of the application.

     * @param aUri URI of the push connection.

     * @param aMsgWaitsHandling status flag of push connection.

     *        - 'true' means that message has arrived to the connection.

     *        - 'false' means that application has started to handle arrived msg

     *          of the push connection.

     * @throws This operation does not throw exceptions.

     */

    void setPendingStatusOfConn(const java::util::Uid& aUid,const std::wstring& aUri,

                                bool aMsgWaitsHandling);

    /**

     * Sets pending status of MIDlet's all push connections to "not active".

     * @param aMidletUid UID of the application.

     * @throws This operation does not throw exceptions.

     */

    void clearPendingStatusesOfMidlet(const java::util::Uid& aMidletUid);

    /**

     * This method returns push connections of all MIDlets' in the MIDlet suite.

     * @param aMidletSuiteUid MIDlet suite UID.

     * @param aAllConnsFlag this flag indicates whether only "pending conns"

     *        are returned:

     *        'true'  => all MIDlets' push connections are returned.

     *        'false' => only push connections which waiting application's handling.

     * @param listOfPushUris URIs of push connections.

     * @throws This operation does not throw exceptions.

     */

    void getPushRegsOfMidletSuite(const java::util::Uid& aMidletSuiteUid,bool aAllConnsFlag,

                                  std::list<std::wstring>& aListOfPushUris);

    /**

     * Returns filter argument of the push registration.

     * @param aSuiteUid   MIDlet suite UID.

     * @param aUri        push URI.

     * @throws            PushException with following error codes:

     *                    SRV_CONN_NOT_FOUND:

     *                    - Push connection by URI and suite uid is not found.

     */

    const std::wstring& getFilterOfPushConn(const java::util::Uid& aSuiteUid,

                                            const std::wstring& aUri);

    /**

     * Returns class name of the push registration.

     * @param aSuiteUid   MIDlet suite UID.

     * @param aUri        push URI.

     * @throws            PushException with following error codes:

     *                    SRV_CONN_NOT_FOUND:

     *                    - Push connection by URI and suite uid is not found.

     */

    const std::wstring& getClassNameOfPushConn(const java::util::Uid& aSuiteUid,

            const std::wstring& aUri);

    /**

     * This operation returns MIDlet's uid. MIDlet is identified by suite uid and

     * class name of the MIDlet.

     * @param aSuiteUid   MIDlet suite UID.

     * @param aClassName  Class name of the MIDlet.

     * @throws            PushException with following error code:

     *                    INCORRECT_APP_DATA:

     *                    - aClassName does not match to any MIDlet in the suite.

     */

    const java::util::Uid& getMidletUid(const java::util::Uid& aSuiteUid,

                                        const std::wstring& aClassName);

    /**

     * This operation returns suite uid of the push connection retrieved by

     * base URI. Base URI means "starts with" URI in this context.

     * Comparison is case insensitive and it assumes that URI contains

     * only us-ascii characters.

     * E.g. Match occurs if full URI is "socket://:1234?param1=value1"

     * and base URI is "socket://:1234".

     * @param aBaseUri "starts with" URI.

     * @param aOutputSuiteUid Output parameter. Suite uid of the MIDlet.

     * @return true if aBaseUri argument match to one push connection URI.

     */

    bool getSuiteUidByBaseUri(const std::wstring& aBaseUri,java::util::Uid& aOutputSuiteUid);

    /**

     * This operation returns MIDlet's media uid.

     * @return MIDlet's media id. Returns -2 if MIDlet by uid is not found.

     *         Returns -1 if "is mmc available" check is not needed to do.

     */

    int getMediaIdByMidletUid(const java::util::Uid& aMidletUid);

    /**

     * This operation returns list of MIDlet's uids by media id.

     * @param aMediaId media id of the drive.

     * @param aUidList Output argument. List of MIDlet's uids installed to the certain drive.

     * @throws This operation does not throw exceptions.

     */

    void getMidletUidsByMediaId(unsigned int aMediaId,std::list<java::util::Uid>& aUidList);

private:

    //Datamembers.

    java::captain::CoreInterface& mCore;

    PushDBHandler& mPushDbHandler;

    //Container for push registrations.

    typedef std::multimap<java::util::Uid,PushRegistrationData> PushRegsContainer_t;

    typedef std::multimap<java::util::Uid,PushRegistrationData>::iterator PushRegsContainerIter_t;

    PushRegsContainer_t mPushRegistrations;

    bool mPushRegsLoaded;

    typedef std::set<java::util::Uid> DoNotLaunchList_t;

    typedef std::set<java::util::Uid>::iterator DoNotLaunchListIter_t;

    DoNotLaunchList_t mDoNotLaunchList;

    //Container for MIDlet suite info.

    //Uid is reserved for the suite uid.

    typedef std::multimap<java::util::Uid,MidletSuiteData> MidletSuiteInfoContainer_t;

    typedef std::multimap<java::util::Uid,MidletSuiteData>::iterator MidletSuiteInfoContainerIter_t;

    MidletSuiteInfoContainer_t mMidletSuiteInfo;

    //Internal operations.

    void loadPushRegs();

    void readPushRegs(const java::util::Uid& aUid);

    void insertPushRegToInternalContainer(java::storage::JavaStorageApplicationList_t::iterator& aIter);

    bool pushRegExists(const std::wstring& aUri);

    void fillConnectionsOfMidlet(const java::util::Uid& aMidletUid,bool aAllConnsFlag,

                                 std::list<std::wstring>& aListOfPushUris);

    bool isMidletPartOfSuite(const java::util::Uid& aSuiteUid,

                             const java::util::Uid& aMidletUid);

    PushRegistrationData* getPushConnOfSuite(const java::util::Uid& aSuiteUid,

            const std::wstring& aUri);

    PushRegistrationData* getPushDataByMidletUidAndUri(const java::util::Uid& aMidletUid,

            const std::wstring& aUri);

    PushRegistrationDataWithUid getPushDataByUri(const std::wstring& aUri);

    bool getSuiteUidByMidletUid(const java::util::Uid& aMidletUid,

                                java::util::Uid& aOutputSuiteUid);

    /**

     * This operation compares whether aFullUri starts with value of the aBaseUri

     * argument. Comparison is case insensitive and both URIs can contains only

     * us-ascii characters.

     */

    bool isUriStartingWith(const std::string& aFullUri,const std::string& aBaseUri);

    /**

     * This operation compares whether two chars are equals.

     * Comparison is case insensitive.

     */

    static bool caseInsensitiveCompare(const char a1,const char a2);

    //Not implemented.

    PushDataContainer(const PushDataContainer &x);

    PushDataContainer &operator=(const PushDataContainer &x);

};

}//end namespace push

}//end namespace java

#endif // PUSHDATACONTAINER_H