/*
* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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 multi plugin controllers*
*/





// INCLUDE FILES
#include "CCseSchedulerMultiPluginController.h"
#include "CseDebug.h"                           // Debug macros
#include "CCseSchedulerPluginStarter.h"
#include "CCseSchedulerLandLord.h"
#include <ipvideo/CCseScheduledProgram.h>
#include "CCseSchedulerTimer.h"
#include "CCseSchedulerServerEngine.h"
#include "CCseSchedulerThreadPacket.h"

// EXTERNAL DATA STRUCTURES
// None.

// EXTERNAL FUNCTION PROTOTYPES  
// None.

// CONSTANTS
// None

// MACROS
// None.

// LOCAL CONSTANTS AND MACROS
// None.

// MODULE DATA STRUCTURES
// None.

// LOCAL FUNCTION PROTOTYPES
// None.


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

// -----------------------------------------------------------------------------
// CCseSchedulerPluginControllerBase::CCseSchedulerMultiPluginController
// C++ default constructor can NOT contain any code, that might leave.
// -----------------------------------------------------------------------------
//
CCseSchedulerMultiPluginController::CCseSchedulerMultiPluginController(
                                        CCseSchedulerServerEngine& aEngine,
                                        TInt32 aPluginUid ) :
                                        CCseSchedulerPluginControllerBase( aEngine, aPluginUid )

    {
    CSELOGSTRING_HIGH_LEVEL(
        ">>>CCseSchedulerMultiPluginController::CCseSchedulerMultiPluginController");
        
    CSELOGSTRING_HIGH_LEVEL(
        "<<<CCseSchedulerMultiPluginController::CCseSchedulerMultiPluginController");
    }

// -----------------------------------------------------------------------------
// CCseSchedulerMultiPluginController::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CCseSchedulerMultiPluginController* CCseSchedulerMultiPluginController::NewL( 
                                        CCseSchedulerServerEngine& aEngine,
                                        TInt32 aPluginUid )
    {
    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerMultiPluginController::NewL");
    
    CCseSchedulerMultiPluginController* self = 
            new( ELeave ) CCseSchedulerMultiPluginController( aEngine, aPluginUid );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    
    CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerMultiPluginController::NewL");
    return self;
    }

// -----------------------------------------------------------------------------
// CCseSchedulerMultiPluginController::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CCseSchedulerMultiPluginController::ConstructL()
    {
    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerMultiPluginController::ConstructL");

    CCseSchedulerPluginControllerBase::ConstructL();
       
	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerMultiPluginController::ConstructL");
    }

// -----------------------------------------------------------------------------
// CCseSchedulerMultiPluginController::~CCseSchedulerMultiPluginController
// Destructor.
// -----------------------------------------------------------------------------
//
CCseSchedulerMultiPluginController::~CCseSchedulerMultiPluginController()
    {
    CSELOGSTRING_HIGH_LEVEL(
        ">>>CCseSchedulerMultiPluginController::~CCseSchedulerMultiPluginController");
    
    iLandLords.ResetAndDestroy( );
    iLandLords.Close();    
		
    CSELOGSTRING_HIGH_LEVEL(
        "<<<CCseSchedulerMultiPluginController::~CCseSchedulerMultiPluginController");
    }

// -----------------------------------------------------------------------------
// CCseSchedulerMultiPluginController::RunPluginsL
//
// -----------------------------------------------------------------------------
//
void CCseSchedulerMultiPluginController::RunPluginsL()
    {
    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerMultiPluginController::RunPluginsL");
    TBool scheduleAlreadyRunning( EFalse );
    
    if(iScheduleArray.Count() >0 )
        {
        // Kick those schedules running that aren't already running
        for( TInt i = 0; i < iScheduleArray.Count(); i++)
            {
            for ( TInt ii = 0; ii < iLandLords.Count(); ii++ )
                {
                if( iScheduleArray[i]->DbIdentifier() ==
                        iLandLords[ii]->ThreadPacket()->Schedule()->DbIdentifier() )
                    {
                    scheduleAlreadyRunning = ETrue;
                    }                
                }
            if( !scheduleAlreadyRunning )
                {
                if( iEngine.IsAllowedToRun( iScheduleArray[i]->DbIdentifier() ) )
                    {                    
                    // Create new LandLord for each schedule to be run
                    CCseSchedulerLandLord* landLord = CCseSchedulerLandLord::NewL( this );
                                                  
                    CleanupStack::PushL( landLord );                    
                                                                                    
                    // Set schedule for LandLord
                    landLord->SetScheduleL( *iScheduleArray[i] );
                    
                    // Increase run count
                    iEngine.IncreaseScheduleRunCountL( iScheduleArray[0]->DbIdentifier() );
                    
                    // Order the LandLord to run plugin
                    landLord->RunPluginL();
                    
                    CleanupStack::Pop( landLord );
                    
                    // Add created landLord to array. Destroyed later when landLord
                    // is not needed anymore.
                    iLandLords.AppendL( landLord );
                    
                    CleanupStack::Pop( landLord );
                    }        
                else
                    {
                    // Schedule cannot be run anymore due to security reasons
                    // Signal engine to remove schedule from DB
                    iEngine.ScheduleNotValid( iScheduleArray[i]->DbIdentifier() );
                    
                    // Remove schedule own list
                    delete iScheduleArray[i];
                    iScheduleArray.Remove( i );
                    i--;
                    }
                }
            }
        if( iLandLords.Count() == 0 )
            {
            // We've gone through all our schedules and still no LandLords.
            // We need to request new schedules.
            iEngine.RequestReschedule(); 
            }
        }
    else
        {
        // No schedules...!?!? REEEEESCHEDULE!!!
        iEngine.RequestReschedule();
        }     
        
    CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerMultiPluginController::RunPluginsL");
    }
    
// -----------------------------------------------------------------------------
// CCseSchedulerMultiPluginController::ScheduleCompletedL
//
// -----------------------------------------------------------------------------
//
void CCseSchedulerMultiPluginController::ScheduleCompletedL( const TUint32 aDbIdentifier,
                                                             TInt aCompletitionCode )
	{	
	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerMultiPluginController::ScheduleCompletedL");

    if ( aCompletitionCode == KErrNone )
        {
        ScheduleCompletedSuccesfullyL( aDbIdentifier );            
        }
    else
        {
        HandleScheduleErrorL( aDbIdentifier, aCompletitionCode );
        }    
 
	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerMultiPluginController::ScheduleCompletedL");
	}

// -----------------------------------------------------------------------------
// CCseSchedulerUniPluginController::ScheduleCompletedSuccesfullyL
//
// -----------------------------------------------------------------------------
//
void CCseSchedulerMultiPluginController::ScheduleCompletedSuccesfullyL( const TUint32 aDbIdentifier )
	{
	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerMultiPluginController::ScheduleCompletedSuccesfullyL");

    // Remove schedule from list
    for ( TInt i = 0; i < iScheduleArray.Count(); i ++)
        {
        if( iScheduleArray[i]->DbIdentifier() == aDbIdentifier )
            {
            delete iScheduleArray[i];
            iScheduleArray.Remove( i );                
            }
        }
        
    // Notify engine about completition.
    iEngine.ScheduleCompletedSuccesfullyL( aDbIdentifier );
    
	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerMultiPluginController::ScheduleCompletedSuccesfullyL");	
	}
	
// -----------------------------------------------------------------------------
// CCseSchedulerMultiPluginController::HandleScheduleErrorl
//
// -----------------------------------------------------------------------------
//
void CCseSchedulerMultiPluginController::HandleScheduleErrorL( const TUint32 aDbIdentifier,
                                                              TUint32 aCompletitionCode )
	{	
	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerMultiPluginController::HandleScheduleError");
	
	// Here we could try to handle plugin errors. Problem is that scheduler doesn't
	// know anything about schedule it is running and so there cannot be tailored
	// error handling for each plugin. In the end, we just complete schedule
	// to engine with error code (ends up removing schedule from DB).
	
	// Remove schedule from list
    for ( TInt i = 0; i < iScheduleArray.Count(); i ++)
        {
        if( iScheduleArray[i]->DbIdentifier() == aDbIdentifier )
            {
            delete iScheduleArray[i];
            iScheduleArray.Remove( i ); 
            break;               
            }
        }
	
	iEngine.ScheduleCompletedWithErrorL( aDbIdentifier, aCompletitionCode );

	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerMultiPluginController::HandleScheduleError");
	}
	
// -----------------------------------------------------------------------------
// CCseSchedulerMultiPluginController::DoCleanUp::DoCleanUp
//
// -----------------------------------------------------------------------------
//
void CCseSchedulerMultiPluginController::DoCleanUp( )
	{
	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerMultiPluginController::DoCleanUp");
    TBool scheduleFound( EFalse );

    // Check all LandLords. If we found that there is no schedules related to 
    // one we destroy it.
    for (TInt i = iLandLords.Count(); i > 0; i--)
        {
        for ( TInt ii = 0; ii < iScheduleArray.Count(); ii++ )
            {
            // Compare LandLords DbIdentifier with the ones in schedules
            if( iLandLords[i-1]->ThreadPacket()->Schedule()->DbIdentifier() ==
                    iScheduleArray[ii]->DbIdentifier() )
                {
                scheduleFound = ETrue;
                break;
                }            
            }
        // Remove LandLord if there is no schedule for it.
        if( !scheduleFound )
            {
            delete iLandLords[i-1];
            iLandLords.Remove(i-1);
            }
        scheduleFound = EFalse;
        }
   
    
	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerMultiPluginController::DoCleanUp");	
	}
	
// -----------------------------------------------------------------------------
// CCseSchedulerMultiPluginController::ClearPlugin
//
// -----------------------------------------------------------------------------
//
void CCseSchedulerMultiPluginController::ClearControllerL( )
	{	
	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerMultiPluginController::ClearControllerL");
	for( TInt i = 0 ; i < iLandLords.Count() ; i++ )
	    {
	    iLandLords[i]->ClearL();
	    }
	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerMultiPluginController::ClearControllerL");
	}	

// -----------------------------------------------------------------------------
// CCseSchedulerMultiPluginController::IsControllerActive
//
// -----------------------------------------------------------------------------
//
TBool CCseSchedulerMultiPluginController::IsControllerActive( )
    {
    TBool retVal( EFalse );
    
    for( TInt i = 0; i < iLandLords.Count(); i++ )
        {
        if( iLandLords[i]->IsWorking() )
            {
            retVal = ETrue ;
            break;
            }            
        }
    return retVal;
    }   

// End of file.