/** @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:  Defines MessageHandlerEngine class
 *
 */

#ifndef C_CUPNPMESSAGEHANDLERENGINE_H
#define C_CUPNPMESSAGEHANDLERENGINE_H

// INCLUDES
#include <upnpnetworkeventobserver.h>
#include "upnpdevicelibrary.h"
#include "upnphttpmessage.h"
#include "upnphttpserverobserver.h"
#include "upnpssdpserverobserver.h"
#include "upnpmessagehandlersession.h"
#include "upnpmessagehandlerengineobserver.h"
#include "upnpcompvariant.hrh"

// LITERALS

static const TInt KSSDPAddressLength=40;
_LIT( KMessagehandlerPanic, "UPnP messagehandler Panic" );
_LIT8( KEmptyMessage, " " );
_LIT8( KMulticastPacket, " " );

// FORWARD DECLARATIONS
class CUpnpHttpServer;
class CUpnpSsdpServer;
class MMessageHandlerEngineObserver;
class CUpnpMSearchTimer;
class CUpnpConnectionManagerProxy;
class CUpnpSsdpHandlerBase;
class CUpnpSsdpHandlerUp;
class CUpnpSsdpHandlerDown;

#ifdef RD_UPNP_REMOTE_ACCESS
class CUpnpIPFiltering;
#endif

// CLASS DECLARATION

/*! 
 \brief The UPnP engine of Message Handler
 
 The message handler is divided into three modules: 
 CUpnpMessageHandler (having the server functionality), 
 CUpnpMessageHandlerSession (having the session functionality) and 
 CUpnpMessageHandlerEngine (having the actual message handling engine).

 Thus, this class represents the engine of the message handling. 
 
 */
class CUpnpMessageHandlerEngine : public CBase,
    public MUpnpDeviceLibraryObserver, public MUpnpSsdpServerObserver,
    public MUpnpNetworkEventObserver
    {
private:
    enum TMessagehandlerPanics
        {
        ENullDeviceLibrary,
        ENullSsdpServer,
        };
public:

    /**
     A two-phased constructor function
     @param aObserver to observe engine
     @result A new instance of CUpnpMessageHandlerEngine
     */
    static CUpnpMessageHandlerEngine* NewL(
        MMessageHandlerEngineObserver& aObserver );
    
    /** 
     Destructor function
     */
    virtual ~CUpnpMessageHandlerEngine();

public:

    /**
     Starts ssdp
     @result error
     */
    TInt StartSsdpL();

    /**
     This function is called from SSDP server after receiving a SSDP message
     @param aMessage The SSDP message that is just received
     @result None.
     */
    void SsdpEventL( CUpnpSsdpMessage* aMessage );
    
    /**
     * Returns device library     
     */
    CUpnpDeviceLibrary* DeviceLibrary();
    
    /**
     Adds a new local device to the device library
     @param aDevice A structure containing indexes to the data buffer
     @param aBuffer A data buffer containing the actual information
     @result KErrNone or one of the system-wide error codes
     */
    TInt AddLocalDeviceL( TUpnpAddLocalDevice& aDevice, TDesC8& aBuffer );

    /**
     Removes a local device from the device library
     @param aUuid UUID of the target device
     @result None.
     */
    void RemoveLocalDeviceL( const TDesC8& aUuid, TBool aSilent );

    /**
     Adds a new local control point client
     */
    TInt AddLocalControlPoint();

    /**
     Removes a local control point client
     */
    TInt RemoveLocalControlPoint();
    
    /**
     It stops using filtering for a target device
     @param aUuid UUID of the target device
     @result None.
     */
    void StopFilteringDeviceL( const TDesC8& aUuid );

    /**
     Returns the device library elements in a pointer array
     @result A pointer to an array containing pointers to the device library 
     elements
     */
    RPointerArray<CUpnpDeviceLibraryElement>& DeviceList();

    /**
     callback method
     */
    void InterfaceDown();
           
public:
    // From MUpnpDeviceLibraryObserver

    /**
     Implementation of MUpnpDeviceLibraryObserver::AdvertiseDevice). 
     
     Advertises a device using SSDP server to 
     send SSDP advertisements to the network.
     @param aLive Tells whether to use ssdp:alive or ssdp:byebye
     @param anElement The device to advertise
     @result None.
     */
    void AdvertiseDeviceL( TInt aLive, CUpnpDeviceLibraryElement& aElement );

    /** 
     Returns the id of the active IAP. 
     @result The id of the IAP
     */
    TInt ActiveIap() const;

    /**
     Makes a SSDP search.
     @param aSearchString The SSDP search string, that is placed to the 
     ST header of the SSDP message.
     @result None.
     */
    void SsdpSearchL( TDesC8& aSearchString, TDesC8& aMX );

    /**
     Inform observer that device list changed.
     @result None.
     */
    void DeviceListChangedL();

#ifdef RD_UPNP_REMOTE_ACCESS
    void AddAddressL( const TInetAddr& aAddress );
    void AddAddressL( const RMessage2& aMessage, const TDesC8& aRemoteName );
    void RemoveAddressL( const TInetAddr& aAddress );
    void RemoveAddressL( const RMessage2& aMessage, const TDesC8& aRemoteName );
    void RemoveAll();
    void StartIPFiltering();
    void StopIPFiltering();
    TBool IsIPFilteringStarted() const;
    TBool IsIPAllowed( const TInetAddr& aAddress ) const;
    void IPFilteringStatus( TInt& aListSize ) const;
    const TDesC8& GetIPFilterList();
#endif

private:    // from MUpnpNetworkEventObserver

    /**
     * It is called from bottom layer when network event occurs [callback method]     
     * @result None
     */
    void NetworkEvent( CUpnpNetworkEventBase* aEvent );

private:

    /**
     Default constructor.
     @param aObserver to observe engine
     @param aHandle the message handler thread log handle
     */
    CUpnpMessageHandlerEngine( MMessageHandlerEngineObserver& aObserver );

    /**
     Default (leaving) constructor.
     */
    void ConstructL();

    /**
     Create session id property and signal id semaphore.
     */
    void CreateSessionIdPropertyL();

    /**
     * Callback function used to inform about the timer events
     */
    void TimerEventL( CUpnpNotifyTimer* aTimer );

private:
    // current state of ssdp servers
    CUpnpSsdpHandlerBase* iCurrentSsdpHandler;

    // ssdp up and runnig state handler 
    CUpnpSsdpHandlerUp* iSsdpHandlerUp;

    // ssdp stopped state handler     
    CUpnpSsdpHandlerDown* iSsdpHandlerDown;

    // The device library 
    CUpnpDeviceLibrary* iDeviceLibrary;

    // The active socket server connection 
    RSocketServ iSocketServ;

    // The MessageHandler observer 
    MMessageHandlerEngineObserver& iObserver;

    // True if SSDP server is ready for shutdown 
    TBool iSsdpReadyForShutdown;

    //Local control points counter 
    TInt iCPCounter;

    // Object used for WLAN lost and address change events and getting local address
    CUpnpConnectionManagerProxy *iConnectionManagerProxy;
    
    // session id access semaphore
    RSemaphore iAccessSemaphore;
    
#ifdef RD_UPNP_REMOTE_ACCESS    
    //Local control points counter 
    CUpnpIPFiltering* iIPFilterRepository;
#endif    
    };

#endif // C_CUPNPMESSAGEHANDLERENGINE_H