/** @file

* Copyright (c) 2008-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:  Base class for event queue manager

*

*/

#include "upnpeventqueuemanagerbase.h"

#include "upnpgenamessagefactory.h"

#include "upnpsubscriberlibraryelement.h"

#include "upnpcommonupnplits.h"

#include "upnpcommonstructs.h"

#define KLogFile _L("UPnPStack.txt")

#include "upnpcustomlog.h"

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

// CUpnpEventQueueManagerBase::CUpnpEventQueueManagerBase

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

//

CUpnpEventQueueManagerBase::CUpnpEventQueueManagerBase( 

                                CUpnpServiceImplementation& aServiceImpl,

                                CUpnpEventController& aEventController,

                                CUpnpSubscriberLibrary* aSubscriberLibrary )

    :iServiceImpl( aServiceImpl ),

     iEventController( aEventController ),

     iSubscriberLibrary( aSubscriberLibrary )

    {

    // No implementation required

    }

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

// CUpnpEventQueueManagerBase::~CUpnpEventQueueManagerBase

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

//

CUpnpEventQueueManagerBase::~CUpnpEventQueueManagerBase ()

    {

    delete iBody;

    }

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

// CUpnpEventQueueManagerBase::BaseConstructL

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

//

void CUpnpEventQueueManagerBase::BaseConstructL()

    {

    }

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

// CUpnpEventQueueManagerBase::SendingCompleted

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

//    

void CUpnpEventQueueManagerBase::SendingCompleted()

    {

    iCurrentSubscriberIndex = 0;

    delete iBody;

    iBody = NULL;

    iIsSending = EFalse;

    if ( iNewValuesWaitingToBeSend )

        {

        iNewValuesWaitingToBeSend = EFalse;

        SendEvent();

        }

    }

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

// CUpnpEventQueueManagerBase::SendToNextL

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

//    

void CUpnpEventQueueManagerBase::SendToNextL()

    {    

    PrepareTransactionAndStartSendingL( iCurrentSubscriberIndex );

    }

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

// CUpnpEventQueueManagerBase::PrepareTransactionAndStartSendingL

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

// 

void CUpnpEventQueueManagerBase::PrepareTransactionAndStartSendingL( TInt aSubscriberNo )

    {

    if (  aSubscriberNo >= iSubscriberLibrary->SubscriberLibrary().Count()

       || aSubscriberNo < 0 )

        {

        User::Leave( KErrNotFound );

        }

    CUpnpSubscriberLibraryElement* subscriber( NULL );

    subscriber = iSubscriberLibrary->SubscriberLibrary()[aSubscriberNo];

    CUpnpHttpMessage* message = reinterpret_cast<CUpnpHttpMessage*>(

                        RUpnpGenaMessageFactory::EventingLC(

                          subscriber->CallbackPath(), 

                          subscriber->CallbackAddress(), 

                          subscriber->Sid(), 

                          subscriber->Seq() ) );

    message->SetTcpTimeout( KMessageTimeout );

    message->SetBodyL( *iBody );        

    CleanupStack::Pop( message ); //ownership passed to "transcation"

    CUpnpHttpTransaction* transaction = CreateTransactionL( message );

    iEventController.SendTransactionL( transaction );

    subscriber->IncreaseSeq();  

    }

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

// CUpnpEventQueueManagerBase::TransactionCompletedL

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

//

void CUpnpEventQueueManagerBase::TransactionCompletedL( 

                                  CUpnpHttpTransaction* aCompletedTransaction  

                                                      )

    {

    ASSERT( iIsSending );

    if ( aCompletedTransaction->Response() && 

        !aCompletedTransaction->Response()->Is2xx() )

        {

        if ( aCompletedTransaction->Response()->Is3xx() )

            {

            //300 Responses are redirected by Symbian HTTP Client

            //This can be changed by removing HTTPFilter from HTTPTransaction

            }

        else

            {

            RemoveInvalidSubscriber( aCompletedTransaction );

            return;

            }

        }

    iCurrentSubscriberIndex++;

    if ( iCurrentSubscriberIndex >= iSubscriberLibrary->SubscriberLibrary().Count() )

        {        

        SendingCompleted();

        }

    else 

        {           

        SendToNextL();   

        }

    } 

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

// CUpnpEventQueueManagerBase::RemoveInvalidSubscriber

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

//

void CUpnpEventQueueManagerBase::RemoveInvalidSubscriber( 

                                    CUpnpHttpTransaction* aCompletedTransaction )

    {

    iSubscriberLibrary->Remove( static_cast<CUpnpGenaMessage*>( 

                                     aCompletedTransaction->Request() )->Sid() );

    }

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

// CUpnpEventQueueManagerBase::UpdateQueue

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

//

void CUpnpEventQueueManagerBase::UpdateQueue( TInt aPos )

    {

    if( iIsSending )

        {

        if ( aPos == iCurrentSubscriberIndex  )

            {

            TRAPD( err, SendToNextL() );

            if ( err )

                {

                SendingCompleted();

                }

            return;

            }   

        if ( aPos < iCurrentSubscriberIndex )

            {

            iCurrentSubscriberIndex--;

            }           

        }

    }

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

// CUpnpEventQueueManagerBase::CreateEventL

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

//

HBufC8* CUpnpEventQueueManagerBase::CreateEventL

                        ( const RPointerArray<CUpnpStateVariable>& aVariableList )

    {      

    HBufC8* body = HBufC8::NewLC( KMaxGenaMessageLength );        

    TPtr8 bodyPtr = body->Des(); 

    bodyPtr.Zero();

    bodyPtr.Append( KGenaXml );

    bodyPtr.Append( KGenaPropertysetStart );

    TInt eventableVariableCount = FillEventBodyL( bodyPtr, aVariableList ); 

    if ( eventableVariableCount > 0 )

        {        

        bodyPtr.Append( KGenaPropertysetEnd );

        CleanupStack::Pop( body );

        return body;

        }

    else

        {

        CleanupStack::PopAndDestroy( body );

        return KNullDesC8().AllocL();             

        }

    }

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

// CUpnpEventQueueManagerBase::ClearVariables

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

//

void CUpnpEventQueueManagerBase::ClearVariables()

    {   

    for ( TInt i = 0; i < iServiceImpl.EventedStateVariables().Count(); i++ )

        {

        if ( iServiceImpl.EventedStateVariables()[i]->MaxEventRate() > 0 && 

            !iServiceImpl.EventedStateVariables()[i]->ReadyForEventing() )

            {

            }

        else

            {

            iServiceImpl.EventedStateVariables().Remove( i );

            i--;

            }

        }

    iServiceImpl.EventedStateVariables().Compress();   

    }

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

// CUpnpEventQueueManagerBase::ClearVariables

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

//

void CUpnpEventQueueManagerBase::AddVariableToEventBody( 

                                            TDes8& aBuffer , 

                                            CUpnpStateVariable * aVariable )

    {

    aBuffer.Append( KGenaPropertyStart );

    aBuffer.Append( aVariable->Name() );

    aBuffer.Append( KCloseBracket );

    aBuffer.Append( aVariable->Value() );

    aBuffer.Append( KOpenBracket );

    aBuffer.Append( UpnpString::KSlash() );

    aBuffer.Append( aVariable->Name() );

    aBuffer.Append( KGenaPropertyEnd );

    }

//end of file