/** @file

* Copyright (c) 2005-2006 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:  Message dispacther engine

*

*/

#ifndef C_CUPNPDISPATCHERENGINE_H

#define C_CUPNPDISPATCHERENGINE_H

// INCLUDES

#include <e32base.h>

#include "upnpdispatchersession.h"

#include "upnpdevice.h"

#include "upnphttpserver.h"

// FORWARD DECLARATIONS

class CUpnpDispatcherRequest;

class MDispatcherEngineObserver;

class CUpnpHttpServerSession;

// CLASS DECLARATION

/**

@brief A message dispatcher unit cooperating with Message Handler

This class represents a logical unit between UPnP devices / control points

and Message Handler. Message Handler is a Symbian Server - thus, dispatcher

follows the same client/server framework and is a client that opens a session

to Message Handler. This is not done by class CUpnpDispatcherEngine;

the class RUpnpDispatcherSession represents the client interface.

Using AddCustomer/RemoveCustomer functions it is possible to set the active

services. Dispatcher is able to forward messages to its customers.

Also SendMessage function is very essential part of the dispatcher.

 */

class CUpnpDispatcherEngine : public CActive, public MUpnpHttpServerObserver

    {

public:

    /**

    * Create a CUpnpDispatcherEngine object using two phase construction,

    *and return a pointer to the created object.

    *

    * A session with Message Handler is initiated during the construction.

    *

    * @param aObserver

    * @return a pointer to the created instance of CUpnpDispatcherEngine

    */

    static CUpnpDispatcherEngine* NewL( MDispatcherEngineObserver& aObserver );

    /**

    * Create a CUpnpDispatcherEngine object using two phase construction,

    * and return a pointer to the created object

    *

    * A session with Message Handler is initiated during the construction.

    *

    * @param aObserver

    * @return a pointer to the created instance of CUpnpDispatcherEngine

    */

    static CUpnpDispatcherEngine* NewLC( MDispatcherEngineObserver& aObserver );

    /**

    * Destroy the object and release all memory objects

    */

    virtual ~CUpnpDispatcherEngine();

private:

    /**

    * CUpnpDispatcherEngine

    *

    * @discussion Perform the first phase of two phase construction

    * @param aParent the object to be used to handle updates from the server

    * @param aObserver

    */

    CUpnpDispatcherEngine( MDispatcherEngineObserver& aObserver );

    /**

    * ConstructL performs the second phase construction of a CUpnpDispatcherEngine

    * object

    */

    void ConstructL();

    /**

    * Creates http server

    */    

    void ConstructHttpL();

public:

    /**

    * Send a message. This function pushes the message to the Message Handler.

    * @param aMessage The message to be sent.

    */

    void SendMessageL( CUpnpHttpMessage* aMessage );

    /**

    * Add a customer to the customer list of this dispatcher. In practice,

    * means that messages start being forwarded to that customer.

    * @param aCustomer The customer to be added.

    */

    void AddCustomer( const MUpnpDispatcherCustomer& aCustomer );

    /**

    * Remove a customer from the customer list of this dispatcher. In practice,

    * means that messages stop being forwarded to that customer.

    * @param aCustomer The customer to be removed.

    */

    void RemoveCustomer( const MUpnpDispatcherCustomer& aCustomer );

    /**

    *Starts http server

    *@since Series60

    *@param aRegister determines if starting error in message handler process will be checked

    *@param aPort starts server on fixed port    

    */

    void StartHttpServerL( TBool aRegister, const TInt aPort );

    /**

    *Stops http server

    *@since Series60

    */

    void StopHttpServer();

public: // from CActive

    /**

    * Active object RunL, pending request completed.

    */

    void RunL();

    /**

    * Active object RunL, pending request completed.

    * @param aError code from RunL.

    * @result KErrNone.

    */

    TInt RunError( TInt aError );

    /**

    * Active object DoCancel, cancel pending requests.

    */

    void DoCancel();

public:

    // Enum that is used when finding out last request

    enum TDispatcherRequest

    {

    EUnknown = -1,

    ENewDevices,

    EDeviceList

    };

    /**

    * Return the MAC addess of this CUpnpDispatcherEngine's HTTP server.

    * @result Buffer that will contain the MAC address.

    */

    const HBufC8* MacAddressL();

    /**

    * Removes a device from Message Handler's device library,

    * which has an UUID of aUuid.

    * @param aUuid UUID of device that is to be removed.

    * @result None.

    */

    void RemoveLocalDeviceL( const TDesC8& aUuid, TBool aSilent );

    /**

    * Return the IP addess of this CUpnpDispatcherEngine's HTTP server.

    * @result TInetAddr that will contain the IP address of the server.

    */

    TInetAddr HttpServerAddress();

    /**

    * Callback from HTTP server that a HTTP message has been received.

    * @param aMessage Received message.

    * @result None.

    */

    void HttpEventLD( CUpnpHttpMessage* aMessage );

    /**

    * Sends a SSDP search for aString

    * @param aString Search message we want to send

    * @result None.

    */

    void SsdpSearchL( const TDesC8& aString );

    /**

    * Sends a SSDP uuids that should not be filtered

    * @param aString Uuids

    */

    void SsdpStopFilteringL( const TDesC8& aString );

    /**

    * Adds a local device to Message Handler's device library with

    * given information.

    * @param aUuid UUID of the device

    * @param aDeviceType Device type of the device

    * @param aDescriptionPath URL to this device's desctiption

    * @param aServices List of services provided by this device.

    * @param aIsRootDevice ETrue, if this device is UPnP root device, \

    *       EFalse otherwise.

    * @result None.

    */

    void AddLocalDeviceL( const TDesC8& aUuid,

                          const TDesC8& aDeviceType,

                          const TDesC8& aDescriptionPath,

                          const CDesC8Array& aServices,

                          const TBool aIsRootDevice );

     /**

    * Add control point client to message handler.

    */

    void AddControlPointClientL( );

     /**

    * Add control point client to message handler.

    */

    void RemoveControlPointClientL( );

    /**

    * This requests Message Handler for new device list.

    * @param aUpdateId Dispatcher's last known update id.

    */

    void UpdateDevicesL( TInt aUpdateId );

    /**

    * Returns a list of new devices found on last query.

    * @return List of CUpnpDevice's.

    */

    const RPointerArray<CUpnpDevice>& NewDevices() const;

    /**

    * Clears the list of newly found devices.

    * @result None.

    */

    void RemoveDevices();

    /**

    * Deletes current request from list of requests.

    * @result KErrNone, if successful. KErrNotFound if no requests

    *       in list.

    */

    TInt RemoveHandledRequest();

    /**

    * Cancels current pending request, if there is a need to send

    * for example a SSDP search.

    * @result None.

    */

    void StopRequestL();

    /**

    * This function sets handle to transaction creator interface.

    * @since Series60 5.0 

    * @param aTransactionCreator pointer to object implementing MUpnpHttpServerTransactionCreator

    *     interface.

    **/

    void SetTransactionCreator( MUpnpHttpServerTransactionCreator* aTransactionCreator );

private:

    /**

    * Makes a request for devices to Message Handler.

    * @return ENewDevices, if request is made for new devices,

    * returns EDeviceList, if request is made for new devices list size.

    */

    TDispatcherRequest GetDevicesL();

    /**

    * Function gets called when new devices are found.

    * @return Last update id.

    */

    TInt DevicesReceivedL();

    /**

    * Sets the Dispatcher to handle next request and remove

    * the old one.

    */

    void HandlePendingRequestL();

    /**

    *Check if start was succesfull

    *@sience Series60 5.0

    *@param aRegister

    */

    void CheckErrorL( TBool aRegister );

private:

    /*! @var iHttpServerSession Pointer to this dispatcher's HTTP server session*/

    CUpnpHttpServerSession* iHttpServerSession;

    /*! @var iSession the message handler session */

    RUpnpDispatcherSession                  iSession;

    /*! @var iCustomers list of dispatcher customers */

    RPointerArray<MUpnpDispatcherCustomer>  iCustomers;

    /*! @var iNewDevices List of new devices that were found on this query */

    RPointerArray<CUpnpDevice>              iNewDevices;

    /*! @var iAddLocalDevice Struct of TInt's that will \

        inform what is the length of each value in the data buffer */

    TUpnpAddLocalDevice                     iAddLocalDevice;

    /*! @var iAddLocalPtr Pointer to buffer that will contain device \

       information. */

    TPtr8                   iAddLocalPtr;

    /*! @var iAddLocalBuffer Buffer that holds the information about \

        device to be added to Message Handler's device library. */

    HBufC8*                 iAddLocalBuffer;

    enum TGetDeviceListState

    {

        EGetListSize = 0,

        EGetList,

        EListReceived,

        EOtherOperation,

        ENoOperation,

    };

    /*! @var iDeviceGet Current state of DispatcherEngine. */

    TGetDeviceListState                    iDeviceGetState;

    /*! @var iSize Structure that holds information \

        about number of new services and devices. */

    TUpnpGetDeviceListSize                 iSize;

    /*! @var iDevs Pointer to list of new devices. */

    TUpnpDevice*                           iDevs;

    /*! @var iServs Pointer to list of new services. */

    TUpnpService*                          iServs;

    /*! @var iOldUpdateId Last known update id of this CUpnpDispatcher. */

    TInt                                   iOldUpdateId;

    /*! @var iObserver Reference to this CUpnpDispatcherEngine's parent for \

        callbacks. */

    MDispatcherEngineObserver&             iObserver;

    /*! @var iPendingRequests List of requests to Message Handler that \

        ahve not yet been sent. */

    RPointerArray<CUpnpDispatcherRequest>  iPendingRequests;

    /*! @var iActiveRequest Request that is currently active \

        to Message Handler. */

    CUpnpDispatcherRequest*                iActiveRequest;

    /*! @var iSearch Buffer that holds a search string that will be \

        sent as SSDP message. */

    HBufC8*                                iSearch;

    /*! @var iGetDevPtr Pointer that is used to receive new devices \

        from Message Handler. */

    TPtr8                                  iGetDevPtr;

    /*! @var iGetServPtr Pointer that is used to receive new services \

        from Message Handler. */

    TPtr8                                  iGetServPtr;

    /*! @var iRemoveUuid Pointer to list of new services. */

    HBufC8*                                iRemoveUuid;

    /*! @var iRemoveUuidPtr Buffer that is used to hold UUID of the \

        device that needs to be removed from Message Handler's device \

        library. */

    TPtrC8                                 iRemoveUuidPtr;

    /* @var Handle counts for logging */

    TInt                iProcessHandlesInStart;

    //

    TInt                iThreadHandlesInStart;

    //

    TInt                iReqsInStart;

    //

    TInt                iProcessHandlesInEnd;

    //

    TInt                iThreadHandlesInEnd;

    //

    TInt                iReqsInEnd;

    HBufC8* iMXString;

    HBufC8* iUuids;

    TBool iIsSessionOpen;

    };

#endif // C_CUPNPDISPATCHERENGINE_H

// End of File