/** @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 dispacher engine

*

*/

// INCLUDE FILES

#include "upnpdispatcherengine.h"

#include "upnphttpmessagefactory.h"

#include "upnphttpfileaccess.h"

#include "upnpdispatcherrequest.h"

#include "upnpdispatcherengineobserver.h"

#include "upnpcustomlog.h"

#include "upnphttpserversession.h"

#include "upnphttpserverruntime.h"

#include "upnpsettings.h"

#ifdef _DEBUG

#define KLogFile _L("UPnPStack.txt")

#endif

// CONSTANTS

const TInt KPortBufferLength = 10;

_LIT8(KMSearchConfig,"1,1,5,5,10");

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CUpnpDispatcherEngine::CUpnpDispatcherEngine

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CUpnpDispatcherEngine::CUpnpDispatcherEngine(

                                      MDispatcherEngineObserver& aObserver )

    : CActive( EPriorityStandard ),

      iAddLocalPtr( NULL, 0 ),

      iObserver( aObserver ),

      iGetDevPtr( NULL, 0 ),

      iGetServPtr( NULL, 0 ),

      iRemoveUuidPtr( NULL, 0 ),

      iIsSessionOpen( EFalse )

    {

    CActiveScheduler::Add( this );

    iDeviceGetState = ENoOperation;

    iAddLocalBuffer = NULL;

    iRemoveUuid = NULL;

    }

// -----------------------------------------------------------------------------

// CUpnpDispatcherEngine::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CUpnpDispatcherEngine::ConstructL()

    {

#ifdef _DEBUG

    iReqsInStart = RThread().RequestCount();

    RThread().HandleCount( iProcessHandlesInStart, iThreadHandlesInStart );

#endif // _DEBUG

    User::LeaveIfError( iSession.Connect() );

    iIsSessionOpen = ETrue;

    iSession.RequestStartSsdpL();

    iActiveRequest = NULL;

    iSearch = NULL;

    ConstructHttpL();

    iDeviceGetState = ENoOperation;

    }

// -----------------------------------------------------------------------------

// CUpnpDispatcherEngine::ConstructHttpL

// -----------------------------------------------------------------------------

//

void CUpnpDispatcherEngine::ConstructHttpL()

    {

    TInt iapId = CUpnpSettings::GetIapL();

    iHttpServerSession = CUpnpHttpServerSession::NewL( iapId, *this );    

    }

// -----------------------------------------------------------------------------

// CUpnpDispatcherEngine::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CUpnpDispatcherEngine* CUpnpDispatcherEngine::NewL(

        MDispatcherEngineObserver& aObserver )

    {

    CUpnpDispatcherEngine* self = NewLC( aObserver );

    CleanupStack::Pop( self );

    return self;

    }

// -----------------------------------------------------------------------------

// CUpnpDispatcherEngine::NewLC

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CUpnpDispatcherEngine* CUpnpDispatcherEngine::NewLC(

        MDispatcherEngineObserver& aObserver )

    {

    CUpnpDispatcherEngine* self =

        new ( ELeave ) CUpnpDispatcherEngine( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// -----------------------------------------------------------------------------

// CUpnpDispatcherEngine::~CUpnpDispatcherEngine

// -----------------------------------------------------------------------------

//

CUpnpDispatcherEngine::~CUpnpDispatcherEngine()

    {

    // If active, calls DoCancel

    Cancel();

    delete iRemoveUuid;

    iRemoveUuid = NULL;

    delete iAddLocalBuffer;

    iAddLocalBuffer = NULL;

    delete iSearch;

    iSearch = NULL;

    delete iUuids;

    iUuids = NULL;

    delete [] iDevs;

    delete [] iServs;

    iSession.Close();

    iIsSessionOpen = EFalse;

    iCustomers.Reset();

    if ( iHttpServerSession )

        {

        iHttpServerSession->Stop();

        delete iHttpServerSession;

        }

    iPendingRequests.ResetAndDestroy();

    iNewDevices.ResetAndDestroy();

    RemoveHandledRequest();

    delete iMXString;

    }

// -----------------------------------------------------------------------------

// CUpnpDispatcherEngine::AddCustomer

// -----------------------------------------------------------------------------

//

void CUpnpDispatcherEngine::AddCustomer( const MUpnpDispatcherCustomer& aCustomer )

    {

    // adds a new customer for CUpnpDispatcherEngine

    if ( iCustomers.Find( &aCustomer ) == KErrNotFound )

        {

        iCustomers.Append( &aCustomer );

        }

    }

// -----------------------------------------------------------------------------

// CUpnpDispatcherEngine::RemoveCustomer

// -----------------------------------------------------------------------------

//

void CUpnpDispatcherEngine::RemoveCustomer( const MUpnpDispatcherCustomer& aCustomer )

    {

    TInt pos = iCustomers.Find( &aCustomer );

    if ( pos != KErrNotFound )

        {

        LOGS2("CUpnpDispatcherEngine::RemoveCustomer, removing customer 0x%x from position %d", &aCustomer, pos);

        iCustomers.Remove( pos );

        iCustomers.Compress();

        LOGS("CUpnpDispatcherEngine::RemoveCustomer done");

        }

    else

        LOGS1("CUpnpDispatcherEngine::RemoveCustomer, customer 0x%x not found", &aCustomer);

    }

// -----------------------------------------------------------------------------

// CUpnpDispatcherEngine::SendMessageL

// -----------------------------------------------------------------------------

//

void CUpnpDispatcherEngine::SendMessageL( CUpnpHttpMessage* aMessage )

    {

    // Sends a Http message

    iHttpServerSession->SendMessageL( aMessage );

    }

// -----------------------------------------------------------------------------

// CUpnpDispatcherEngine::UpdateDevicesL

// -----------------------------------------------------------------------------

//

void CUpnpDispatcherEngine::UpdateDevicesL( TInt aUpdateId )

    {

    // checking if new list size is called.

    if ( iDeviceGetState != EGetListSize )

        {

        if ( IsActive() )

            {

            return;

            }

        // setting information for message handler

        // iSize contains information about last known

        // update id. On return, it will contain also

        // number of new devices and servises.

        if( iSize.iUpdateId > iOldUpdateId )

            {

            iDeviceGetState = EGetList;

            SetActive();

            iStatus = KRequestPending;

            TRequestStatus* stat = &iStatus;

            User::RequestComplete( stat, KErrNone );

            }

        else

            {

            iSize.iUpdateId = aUpdateId;

            iOldUpdateId = aUpdateId;

            iStatus = KRequestPending;

            // connection restoring

            if(!iIsSessionOpen)

                {

                User::LeaveIfError( iSession.Connect() );

                iIsSessionOpen = ETrue;

                }

            iSession.RequestGetDeviceListSize( iStatus, iSize );

            if( !IsActive() )

                {

                SetActive();

                }

                iDeviceGetState = EGetList;

            }

        }

    }

// -----------------------------------------------------------------------------

// CUpnpDispatcherEngine::GetDevicesL

//

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

CUpnpDispatcherEngine::TDispatcherRequest CUpnpDispatcherEngine::GetDevicesL()

    {

    LOG_FUNC_NAME;

    TDispatcherRequest status( ENewDevices );

    if ( iDevs )

        {

        delete [] iDevs;

        iDevs = NULL;

        }

    if ( iServs )

        {

        delete [] iServs;

        iServs = NULL;

        }

    // checking if new devices or services has been found.

    if ( iSize.iUpdateId > iOldUpdateId )

        {

        if( IsActive() )

            {

            Cancel();

            }

        // constructing buffers for getting the information

        // for new devices and services.

        // iDevs is an array, that will have number of

        // devices as we have just received from Message Handler

        // Same with iServs for services.

        iDevs = new (ELeave) TUpnpDevice[iSize.iDeviceCount];

        iServs = new (ELeave) TUpnpService[iSize.iServiceCount];

        TPtr8 devPtr( reinterpret_cast<TUint8*>( iDevs ),

            iSize.iDeviceCount*sizeof( TUpnpDevice ),

            iSize.iDeviceCount*sizeof( TUpnpDevice ) );

        TPtr8 servPtr( reinterpret_cast<TUint8*>( iServs ),

            iSize.iServiceCount*sizeof( TUpnpService ),

            iSize.iServiceCount*sizeof( TUpnpService ) );

        // setting member pointers to point to strictures that will be

        // filled with device and service information as call returns.

        iGetDevPtr.Set(devPtr);

        iGetServPtr.Set(servPtr);

        // connection restoring

        if(!iIsSessionOpen)

            {

            User::LeaveIfError( iSession.Connect() );

            iIsSessionOpen = ETrue;

            }

        iStatus = KRequestPending;

        iSession.RequestGetDeviceList( iStatus, iGetDevPtr, iGetServPtr );

        if( !IsActive() )

            {

            SetActive();

            }

        status = ENewDevices;

        }

    else

        {

        // if no new devices, return the request for Message Handler,

        // so it can complete message when there will be new devices.

        UpdateDevicesL(iSize.iUpdateId);

        status = EDeviceList;

        }

    return status;

    }

// -----------------------------------------------------------------------------

// CUpnpDispatcherEngine::DevicesReceivedL

// -----------------------------------------------------------------------------

//

TInt CUpnpDispatcherEngine::DevicesReceivedL()

    {

    if( iDevs && iServs)

        {

        TInt servIndex = 0;

        // parsing data to devices and services.

        for ( TInt i = 0; i < iSize.iDeviceCount; i++ )

            {

            RPointerArray<TUpnpService> currServs;

            CleanupClosePushL( currServs );

            for ( TInt j = 0; j < iDevs[i].iServiceCount; j++ )

                {

                currServs.Append( (const TUpnpService*)&iServs[servIndex+j] );

                }

            CleanupStack::Check(&currServs);

            servIndex += iDevs[i].iServiceCount;

            // creating CUpnpDevice objects from this information.

            CUpnpDevice* device = CUpnpDevice::NewL( &iDevs[i], currServs );

            CleanupStack::Check(&currServs);

            device->SetAlive( iDevs[i].iAlive );

            CleanupStack::Check(&currServs);

            currServs.Reset();

            CleanupStack::Pop( &currServs );

            iNewDevices.Append( device );

            }

        delete[] iDevs;

        iDevs = NULL;

        delete[] iServs;

        iServs = NULL;

        iOldUpdateId = iSize.iUpdateId;

        // inform CUpnpDispatcher that new devices and services has been found.

        iObserver.DeviceListReceivedL(iOldUpdateId);

        }

    //The UpdateId should be passed back to the DispatcherEngine

    //(Through Observer)

    return iOldUpdateId;

    }

// -----------------------------------------------------------------------------

// CUpnpDispatcherEngine::NewDevices

// -----------------------------------------------------------------------------

//

const RPointerArray<CUpnpDevice>& CUpnpDispatcherEngine::NewDevices() const

    {

    return iNewDevices;

    }

// -----------------------------------------------------------------------------

// CUpnpDispatcherEngine::RemoveDevices

// -----------------------------------------------------------------------------

//

void CUpnpDispatcherEngine::RemoveDevices()

    {

    iNewDevices.ResetAndDestroy();

    }

// -----------------------------------------------------------------------------

// CUpnpDispatcherEngine::AddLocalDeviceL

// -----------------------------------------------------------------------------

//

void CUpnpDispatcherEngine::AddLocalDeviceL( const TDesC8& aUuid,

                                             const TDesC8& aDeviceType,

                                             const TDesC8& aDescriptionPath,

                                             const CDesC8Array& aServices,

                                             const TBool aIsRootDevice )

    {

    // checking if client is busy.

    if ( iDeviceGetState != EOtherOperation &&

        iDeviceGetState != EListReceived)

        {

        if ( IsActive() )

            {

            Cancel();

            }

        TBuf8<KPortBufferLength> port;

        port.Num( HttpServerAddress().Port() );

        _LIT8( KRootDevice, "r" );

        TInt bufLen = aUuid.Length() +

            aDeviceType.Length() +

            aDescriptionPath.Length() +

            port.Length() + KRootDevice().Length();

        TInt i=0;

        for ( i = 0; i < aServices.Count(); i++ )

            {

            bufLen += aServices[i].Length();

            }

        if(iAddLocalBuffer)

            {

            delete iAddLocalBuffer;

            iAddLocalBuffer = NULL;

            }

        // creating a buffer that will hold information about device

        // that is to be added.

        iAddLocalBuffer = HBufC8::NewL( bufLen );

        iAddLocalPtr.Set( iAddLocalBuffer->Des() );

        // iAddLocalDevice is a struct, that will hold length of each

        // data in the buffer. When we have length of each data and

        // the data buffer, we can parse the data back to separate

        // buffers on server side.

        iAddLocalDevice.iUuidLength = aUuid.Length();

        iAddLocalDevice.iDeviceTypeLength = aDeviceType.Length();

        iAddLocalDevice.iDescriptionUrlLength = aDescriptionPath.Length();

        iAddLocalDevice.iDomainLength = 0;

        iAddLocalDevice.iPortNumberLength = port.Length();

        iAddLocalDevice.iRootDeviceLength = 0;

        iAddLocalPtr.Append( aUuid );

        iAddLocalPtr.Append( aDeviceType );

        iAddLocalPtr.Append( aDescriptionPath );

        iAddLocalPtr.Append( port );

                if ( aIsRootDevice )

                    {

                    iAddLocalPtr.Append( KRootDevice() );

                    iAddLocalDevice.iRootDeviceLength = KRootDevice().Length();

                    }

        for ( i = 0; i < aServices.Count(); i++ )

            {

            iAddLocalDevice.iServiceLength[i] = aServices[i].Length();

            iAddLocalPtr.Append( aServices[i] );

            }

        for ( ; i < KMaxServiceCount; i++ )

            {

            iAddLocalDevice.iServiceLength[i] = 0;

            }

        iAddLocalDevice.iBufferLength = iAddLocalPtr.Length();

        // connection restoring

        if(!iIsSessionOpen)

            {

            User::LeaveIfError( iSession.Connect() );

            iIsSessionOpen = ETrue;

            }

        iStatus = KRequestPending;

        iSession.RequestAddLocalDevice( iStatus, iAddLocalDevice,

            iAddLocalPtr );

        if( !IsActive() )

            {

            SetActive();

            }

        iDeviceGetState = EOtherOperation;

        }

    else

        {

        // if client is busy, making a request to request queue.

        CUpnpDispatcherRequest* request = CUpnpDispatcherRequest::NewLC(

            EAddLocalDevice );

        request->AddArgumentL( aUuid );

        request->AddArgumentL( aDeviceType );

        request->AddArgumentL( aDescriptionPath );

        _LIT8( KRootDevice, "r" );

        if ( aIsRootDevice )

            {

            request->AddArgumentL( KRootDevice );

            }

        else

            {

            request->AddArgumentL( KNullDesC8 );

            }

        TInt granularity = aServices.Count();

        if( 0 == granularity )