/*
* 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:    Timer for the notifier*
*/




#include "CCseSchedulerLandLord.h"
#include "CCseSchedulerPluginStarter.h"
#include <ipvideo/CCseScheduledProgram.h>
#include "CCseSchedulerThreadPacket.h"
#include <ipvideo/MCseScheduleObserver.h>   // Observer for informing engine
#include <e32std.h>
#include "CseDebug.h"               // Debug macros
#include "CCseSemaphoreController.h"

_LIT( KCseUniThreadName, "CseThread" );
_LIT( KCseLine,          "-" );

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

// ---------------------------------------------------------------------------
// CCseSchedulerTimer::CCseSchedulerTimer()
//
// ---------------------------------------------------------------------------
CCseSchedulerLandLord::CCseSchedulerLandLord( MCseScheduleObserver* aObserver ) :
                            CActive( CActive::EPriorityStandard ),
                            iThreadRunning( EFalse ),
                            iTakedownRequested( EFalse )

	{
	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerLandLord::CCseSchedulerLandLord");
	
	// C++ default constructor
	iObserver = aObserver;	
		
	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerLandLord::CCseSchedulerLandLord");
	}

// ---------------------------------------------------------------------------
// CCseSchedulerLandLord::~CCseSchedulerLandLord()
//
// ---------------------------------------------------------------------------	
CCseSchedulerLandLord::~CCseSchedulerLandLord()
	{
	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerLandLord::~CCseSchedulerLandLord");

	Cancel();

    delete iShutdownCompleteMonitor;    
    iShutdownCompleteMonitor = NULL;    
    delete iActiveSchedulerWait;
    iActiveSchedulerWait = NULL;    
	iObserver = NULL;
	delete iThreadPacket;
	iThreadPacket = NULL;
	delete iThreadName;
		
	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerLandLord::~CCseSchedulerLandLord");
	}

// ---------------------------------------------------------------------------
// CCseSchedulerLandLord::NewL()
//
// ---------------------------------------------------------------------------	
CCseSchedulerLandLord* CCseSchedulerLandLord::NewL( 
	                        MCseScheduleObserver* aObserver )
	{	
	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerLandLord::NewL");
	
	// Symbian C++ constructor
	CCseSchedulerLandLord* self = new ( ELeave ) CCseSchedulerLandLord( aObserver );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( );
    
	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerLandLord::NewL");
    return self;
	}
	
// ---------------------------------------------------------------------------
// CCseSchedulerLandLord::ConstructL()
//
// ---------------------------------------------------------------------------
void CCseSchedulerLandLord::ConstructL()
	{
	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerLandLord::ConstructL");	

    iActiveSchedulerWait = new (ELeave) CActiveSchedulerWait;    
    CActiveScheduler::Add( this );
  
    CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerLandLord::ConstructL");
	}

// ---------------------------------------------------------------------------
// CCseSchedulerLandLord::DoCancel()
//
// ---------------------------------------------------------------------------
void CCseSchedulerLandLord::DoCancel()
	{
	CSELOGSTRING_HIGH_LEVEL( ">>>CCseSchedulerLandLord::DoCancel" );

	if ( iThreadRunning )
	    {
    	CSELOGSTRING_HIGH_LEVEL(
    	    "CCseSchedulerLandLord::DoCancel Canceling thread" );
        
	    // Signal thread to die away!
	    iPluginShutdownSemaphore.Signal();
	
    	iThreadRunning = EFalse;
    	
    	// Complete schedule with KErrAbort
    	TRAP_IGNORE( iObserver->ScheduleCompletedL(
    	    iThreadPacket->Schedule( )->DbIdentifier(), KErrAbort ) );    	
	    }

	CSELOGSTRING_HIGH_LEVEL( "<<<CCseSchedulerLandLord::DoCancel" );
	}

// ---------------------------------------------------------------------------
// CCseSchedulerTimer::RunL()
//
// ---------------------------------------------------------------------------		
void CCseSchedulerLandLord::RunL()
	{
	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerLandLord::RunL");
	
    iThreadRunning = EFalse;

    // In case we have not cancelled operation, complete schedule with result code.
    // If we have cancelled it, we're not interested about the result as the
    // schedule has already been removed from the DB
    if( !iTakedownRequested )
        {        
        iObserver->ScheduleCompletedL( iThreadPacket->Schedule( )->DbIdentifier(),
                                       iThreadPacket->ResultCode( ) );
        }
	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerLandLord::RunL");
	}
	
// ---------------------------------------------------------------------------
// CCseSchedulerTimer::SetScheduleL()
//
// ---------------------------------------------------------------------------		
void CCseSchedulerLandLord::SetScheduleL( CCseScheduledProgram& aData )
	{
	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerLandLord::SetSchedule");
	
	delete iThreadPacket;
	iThreadPacket = NULL;
	iThreadPacket = CCseSchedulerThreadPacket::NewL();
	iThreadPacket->SetScheduleL( aData );	    

	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerLandLord::SetSchedule");
	}
		
// ---------------------------------------------------------------------------
// CCseSchedulerTimer::ThreadPacket()
//
// ---------------------------------------------------------------------------		
CCseSchedulerThreadPacket* CCseSchedulerLandLord::ThreadPacket( )
	{
	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerLandLord::Schedule");
    CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerLandLord::Schedule");
   
    return iThreadPacket;
	}
	
// -----------------------------------------------------------------------------
// CCseSchedulerLandLord::RunError
// From CActive, called when RunL leaves.
// -----------------------------------------------------------------------------
//
TInt CCseSchedulerLandLord::RunError( TInt /*aError*/ )
    {
	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerLandLord::RunError");	
    // ATM there isn't leaving code in RunL so we just cancel timer if it is active.    
    Cancel();
    // Return KErrNone to avoid crash.
	return KErrNone;
    }
    
// -----------------------------------------------------------------------------
// CCseSchedulerLandLord::GenerateThreadName
// Generates "unique" name for thread
// -----------------------------------------------------------------------------
//
void CCseSchedulerLandLord::GenerateThreadNameL( )
    {
	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerLandLord::GenerateThreadName");	

    delete iThreadName;
    iThreadName = NULL;
    iThreadName = KCseUniThreadName().AllocL();
    iThreadName = iThreadName->ReAllocL(
                                iThreadName->Size() +   // Length of original name.
                                sizeof( TUint32 ) * 2 + // Space for Plugin Uid and DbIdentifier
                                2 );                    // Two "-" as a separator between
                                                        // Uid and identifier

    // Separator                                                        
    iThreadName->Des( ).Append( KCseLine );
    
    // Plugin uid
    iThreadName->Des( ).AppendNum( iThreadPacket->Schedule()->PluginUid() );
    
    // Separator
    iThreadName->Des( ).Append( KCseLine );
    
    // Finally schedule identifier to make thread name unique
    iThreadName->Des( ).AppendNum( iThreadPacket->Schedule()->DbIdentifier() );

	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerLandLord::GenerateThreadName");	
    }

// -----------------------------------------------------------------------------
// CCseSchedulerLandLord::GenerateSemahoresL
// Generates semaphores for shutdown signalling
// -----------------------------------------------------------------------------
//
void CCseSchedulerLandLord::GenerateSemaphoresL( )
    {
    iPluginShutdownSemaphore.CreateLocal( 0 );
    iThreadPacket->SetShutdownSemaphore( iPluginShutdownSemaphore );
    
    iPluginShutdownCompleteSemaphore.CreateLocal( 0 );
    iThreadPacket->SetShutdownCompleteSemaphore( iPluginShutdownCompleteSemaphore );
    }
	
// -----------------------------------------------------------------------------
// CCseSchedulerLandLord::RunPluginL
// From CActive, called when RunL leaves.
// -----------------------------------------------------------------------------
//
void CCseSchedulerLandLord::RunPluginL( )
    {
	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerLandLord::RunPluginL");	
    TInt error( KErrNone );
    
    // Create semaphores for shutdown signalling
    GenerateSemaphoresL();
    
    // First we create unique thread name
    GenerateThreadNameL( );
    
    // Create thread where to run schedule
    error = iThread.Create( *iThreadName,
                             CCseSchedulerPluginStarter::StartThread,
                             KDefaultStackSize,
                             NULL, // uses caller thread's heap
                             iThreadPacket, // Schedule
                             EOwnerThread );
    
    if( error == KErrNone )
        {
        // Creation succesfull, start running it and logon on it.
        CSELOGSTRING_HIGH_LEVEL(
            "CCseSchedulerLandLord::RunPluginL - Thread creation succesfull");
        iThread.Resume();
        iThread.Logon( iStatus );
        SetActive();
        iThreadRunning = ETrue;
        }
    else
        {
        CSELOGSTRING2_HIGH_LEVEL(
            "CCseSchedulerLandLord::RunPluginL - Thread creation FAILED: %d",
             error);
        }

    CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerLandLord::RunPluginL");    
    } 
    
// -----------------------------------------------------------------------------
// CCseSchedulerLandLord::ActiveWait
//
// -----------------------------------------------------------------------------
//	
void CCseSchedulerLandLord::ActiveWait( TBool aStart )
    {
    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerLandLord::ActiveWait()");    
    if (aStart)
        {
	    if(!iActiveSchedulerWait->IsStarted())
	        {
	        CSELOGSTRING_HIGH_LEVEL("CCseSchedulerLandLord::ActiveWait - Wait start");    
	        iActiveSchedulerWait->Start();		
	        }
        }
    else
        {
		if(iActiveSchedulerWait->IsStarted())
			{
			CSELOGSTRING_HIGH_LEVEL("CCseSchedulerLandLord::ActiveWait - Wait stop");    
			iActiveSchedulerWait->AsyncStop();		
			}
        }
    CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerLandLord::ActiveWait()");
    }

// -----------------------------------------------------------------------------
// CCseSchedulerLandLord::ActiveWait
//
// -----------------------------------------------------------------------------
//	    
void CCseSchedulerLandLord::SemaphoreSignalled()
    {
    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerLandLord::ShutdownPlugin()"); 
    
    ActiveWait( EFalse );
    
    CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerLandLord::ShutdownPlugin()"); 
    }
    
// ---------------------------------------------------------------------------
// CCseSchedulerLandLord::ClearL()
//
// ---------------------------------------------------------------------------
void CCseSchedulerLandLord::ClearL()
	{
	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerLandLord::ClearL");	

	if( iThreadRunning )
	    {
	    // Flag the takedown. We're cancelling the operation, so we have
	    // no interest about result code as the schedule has already
	    // been removed from the DB.
	    iTakedownRequested = ETrue;
	    
    	// Signal thread to die away!
        iPluginShutdownSemaphore.Signal();
            
        if( !iShutdownCompleteMonitor )
            {
            CSELOGSTRING_HIGH_LEVEL("CCseSchedulerLandLord::ClearL - New semaphore monitor" );
            iShutdownCompleteMonitor = CCseSemaphoreController::NewL( iPluginShutdownCompleteSemaphore, *this );
            }
        
        CSELOGSTRING_HIGH_LEVEL("CCseSchedulerLandLord::ClearL - StartMonitor" );    
        iShutdownCompleteMonitor->Start();    
        
        ActiveWait( ETrue );     
            
        iThreadRunning = EFalse;	
	    }
  
    CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerLandLord::ClearL");
	}

// -----------------------------------------------------------------------------
// CCseSchedulerLandLord::ActiveWait
//
// -----------------------------------------------------------------------------
//      
TBool CCseSchedulerLandLord::IsWorking()
    {
    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerLandLord::IsWorking()"); 
    
    CSELOGSTRING2_HIGH_LEVEL("<<<CCseSchedulerLandLord::IsWorking(): %d", iThreadRunning);
    
    return iThreadRunning;
    }

// End of file