/** @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:  Implements algoritms for modereted events
*
*/


#include "upnpmoderatedeventqueuemanager.h"
#include "upnpgenamessagefactory.h"
#include "upnpsubscriberlibraryelement.h"
#include "upnphttpmoderatedeventtransaction.h"
#include "upnpnotifytimer.h"

// -----------------------------------------------------------------------------
// CUpnpModeratedEventQueueManager::CUpnpModeratedEventQueueManager
// -----------------------------------------------------------------------------
//
CUpnpModeratedEventQueueManager::CUpnpModeratedEventQueueManager( 
                                        CUpnpServiceImplementation& aServiceImpl,
                                        CUpnpEventController& aEventController,
                                        CUpnpSubscriberLibrary* aSubscriberLibrary
                                                                )
    :CUpnpEventQueueManagerBase( aServiceImpl, aEventController , aSubscriberLibrary )
    {
    // No implementation required
    }

// -----------------------------------------------------------------------------
// CUpnpModeratedEventQueueManager::~CUpnpModeratedEventQueueManager
// -----------------------------------------------------------------------------
//
CUpnpModeratedEventQueueManager::~CUpnpModeratedEventQueueManager()
    {
    delete iModerationTimer;
    }

// -----------------------------------------------------------------------------
// CUpnpModeratedEventQueueManager::CUpnpModeratedEventQueueManager
// -----------------------------------------------------------------------------
//
CUpnpModeratedEventQueueManager* CUpnpModeratedEventQueueManager::NewLC( 
                                        CUpnpServiceImplementation& aServiceImpl,
                                        CUpnpEventController& aEventController,
                                        CUpnpSubscriberLibrary* aSubscriberLibrary 
                                                                        )
    {
    CUpnpModeratedEventQueueManager* self = 
        new (ELeave) CUpnpModeratedEventQueueManager( aServiceImpl, 
                                                      aEventController, 
                                                      aSubscriberLibrary 
                                                     );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }
    
// -----------------------------------------------------------------------------
// CUpnpModeratedEventQueueManager::NewL
// -----------------------------------------------------------------------------
//
CUpnpModeratedEventQueueManager* CUpnpModeratedEventQueueManager::NewL( 
                                       CUpnpServiceImplementation& aServiceImpl,
                                       CUpnpEventController& aEventController,
                                       CUpnpSubscriberLibrary* aSubscriberLibrary 
                                                                       )
    {
    CUpnpModeratedEventQueueManager* self=
            CUpnpModeratedEventQueueManager::NewLC( aServiceImpl, 
                                                    aEventController, 
                                                    aSubscriberLibrary );
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CUpnpModeratedEventQueueManager::ConstructL
// -----------------------------------------------------------------------------
//
void CUpnpModeratedEventQueueManager::ConstructL()
    {
    BaseConstructL();
    iModerationTimer = CUpnpNotifyTimer::NewL( this );
    }

// -----------------------------------------------------------------------------
// CUpnpModeratedEventQueueManager::StartSendingEventL
// -----------------------------------------------------------------------------
//    
void CUpnpModeratedEventQueueManager::StartSendingEventL()
    {
    if ( !iSubscriberLibrary->SubscriberLibrary().Count() )
        {
        return;
        }
    
    if ( iIsSending ) 
        {
        iNewValuesWaitingToBeSend = ETrue;
        return;
        }
    
    iIsSending = ETrue;
     
    iCurrentSubscriberIndex = 0;
    for ( TInt i = 0; i < iServiceImpl.EventedStateVariables().Count(); i++ )
        {
        if ( iServiceImpl.EventedStateVariables()[i]->MaxEventRate() > 0 )
            {
            iServiceImpl.EventedStateVariables()[i]->EventTick();
            }
        }    

    delete iBody;
    iBody = NULL;
      
    iBody = CreateEventL( iServiceImpl.StateVariableList() );
    ClearVariables();
        
    PrepareTransactionAndStartSendingL( KFirstSubscriberInQueue );
    }

// -----------------------------------------------------------------------------
// CUpnpModeratedEventQueueManager::SendEvent
// -----------------------------------------------------------------------------
//
void CUpnpModeratedEventQueueManager::SendEvent()
    {
    if ( ! iSubscriberLibrary->SubscriberLibrary().Count() )
        {
        return;
        }
    
    iModerationTimer->Cancel();
    iModerationTimer->After( KMaxEventRate ); 
    }

// -----------------------------------------------------------------------------
// CUpnpModeratedEventQueueManager::CreateTransactionL
// -----------------------------------------------------------------------------
//
CUpnpHttpTransaction* CUpnpModeratedEventQueueManager::CreateTransactionL( CUpnpHttpMessage* aMessage )
    {
    return CUpnpHttpModeratedEventTransaction::NewL( aMessage, *this );
    }
 
// -----------------------------------------------------------------------------
// CUpnpModeratedEventQueueManager::WaitBeforeSending
// -----------------------------------------------------------------------------
//
void CUpnpModeratedEventQueueManager::WaitBeforeSending()
    {
    iModerationTimer->Cancel();
    iModerationTimer->After( KMaxEventRate );   
    }

// -----------------------------------------------------------------------------
// CUpnpModeratedEventQueueManager::FillEventBodyL
// -----------------------------------------------------------------------------
//
TInt CUpnpModeratedEventQueueManager::FillEventBodyL( TDes8& aEvent, 
                                                 const RPointerArray<CUpnpStateVariable>& aVariableList 
                                                     )
    {
    TInt eventableVariableCount(0);        
    for ( TInt i = 0; i < aVariableList.Count(); i++ )
        {
        if (   aVariableList[i]->Eventable().CompareF( KYes() ) == 0 
            && aVariableList[i]->ReadyForEventing() 
            && aVariableList[i]->IsModerated()  )
            {                            
            AddVariableToEventBody( aEvent , aVariableList[i] );
                                              
            iServiceImpl.StateVariableEvented( aVariableList[i]->Name() );        
            eventableVariableCount++;
            }  
        }
    return eventableVariableCount;
    }

// -----------------------------------------------------------------------------
// CUpnpModeratedEventQueueManager::TimerEventL
// -----------------------------------------------------------------------------
//
void CUpnpModeratedEventQueueManager::TimerEventL( CUpnpNotifyTimer* /*aTimer*/ )
    {
    if ( iModerationTimer->iStatus.Int() == KErrNone )
        {
        if ( !iIsSending )  
            {
            TRAPD( err ,StartSendingEventL() );
            if( err )
                {
                SendingCompleted();
                }
            }
        else
            {
            WaitBeforeSending();
            }
        }
    }
//end of file