/*
* Copyright (c) 2006-2007 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:  Processor object for running queued tasks
 *
*/


#include <e32base.h>
#include <fbs.h>
#include "thumbnailtaskprocessor.h"
#include "thumbnailtask.h"
#include "thumbnailprovider.h"
#include "thumbnailmanageruids.hrh"
#include "thumbnailmanagerconstants.h"
#include "thumbnailgeneratetask.h"
#include "thumbnailpanic.h"


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

// ---------------------------------------------------------------------------
// CThumbnailTaskProcessor::NewL()
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CThumbnailTaskProcessor* CThumbnailTaskProcessor::NewL()
    {
    CThumbnailTaskProcessor* self = new( ELeave )CThumbnailTaskProcessor();
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// CThumbnailTaskProcessor::CThumbnailTaskProcessor()
// C++ default constructor can NOT contain any code, that might leave.
// ---------------------------------------------------------------------------
//
CThumbnailTaskProcessor::CThumbnailTaskProcessor(): CActive( CActive
    ::EPriorityStandard )
    {
    CActiveScheduler::Add( this );
    }


// ---------------------------------------------------------------------------
// CThumbnailTaskProcessor::ConstructL()
// Symbian 2nd phase constructor can leave.
// ---------------------------------------------------------------------------
//
void CThumbnailTaskProcessor::ConstructL()
    {
    // define PS property
    TInt ret = RProperty::Delete(KServerIdle, KIdle);
    TN_DEBUG2( "CThumbnailTaskProcessor::CThumbnailTaskProcessor() Delete KServerIdle %d", ret);
    
    ret=RProperty::Define(KServerIdle, KIdle, RProperty::EInt);
    TN_DEBUG2( "CThumbnailTaskProcessor::ConstructL() Define KServerIdle %d", ret);
    
    // attach to the property    
	ret = iProperty.Attach(KServerIdle, KIdle, EOwnerThread);
    TN_DEBUG2( "CThumbnailTaskProcessor::ConstructL()Attach %d", ret);
    
	// set initial PS value
    ret = iProperty.Set( ETrue );
    TN_DEBUG2( "CThumbnailTaskProcessor::ConstructL() Set IDLE ETrue %d", ret );
    iIdle = ETrue;
    
    iPeriodicTimer = CPeriodic::NewL(CActive::EPriorityIdle);
    
    iTimerActive = EFalse;
     
    iIsDaemonAsProcess = EFalse;
    }


// ---------------------------------------------------------------------------
// CThumbnailTaskProcessor::~CThumbnailTaskProcessor()
// Destructor.
// ---------------------------------------------------------------------------
//
CThumbnailTaskProcessor::~CThumbnailTaskProcessor()
    {
    Cancel();
    iTasks.ResetAndDestroy();
    iProperty.Close();
    TInt ret = RProperty::Delete(KServerIdle, KIdle);
    TN_DEBUG2( "CThumbnailTaskProcessor::CThumbnailTaskProcessor() Delete KServerIdle %d", ret);
    
    if(iPeriodicTimer)
       {
       iPeriodicTimer->Cancel();
       }
    delete iPeriodicTimer;
    iPeriodicTimer = NULL;
    }


// ---------------------------------------------------------------------------
// CThumbnailTaskProcessor::AddTaskL()
// Adds new task to the task queue.
// ---------------------------------------------------------------------------
//
void CThumbnailTaskProcessor::AddTaskL( CThumbnailTask* aTask )
    {
    TN_DEBUG1( "CThumbnailTaskProcessor::AddTaskL()");
    __ASSERT_DEBUG(( aTask ), ThumbnailPanic( EThumbnailNullPointer ));
    const TInt taskCount = iTasks.Count();
    iTasks.AppendL( aTask );
    
    if ( !IsActive() && !taskCount )
        {
        // this is the first task in queue, go active now
        iActiveTask = aTask;
        
        SetActive();
        TRequestStatus* statusPtr = &iStatus;
        User::RequestComplete( statusPtr, KErrNone );
        }
    }


// ---------------------------------------------------------------------------
// CThumbnailTaskProcessor::RemoveTask()
// Removes specific tasks from the queue.
// ---------------------------------------------------------------------------
//
TInt CThumbnailTaskProcessor::RemoveTask( const TThumbnailServerRequestId&
    aRequestId )
    {
    TN_DEBUG2( "CThumbnailTaskProcessor::RemoveTask() - request ID: %d", aRequestId.iRequestId);
    
    TBool cancel = EFalse;
    TInt res = KErrNotFound;
    
    for ( TInt i = iTasks.Count(); --i >= 0; )
        {
        CThumbnailTask* task = iTasks[i];
        if ( task->RequestId() == aRequestId )
            {
            if ( task->State() != CThumbnailTask::ERunning )
                {
                // Remove task from queue
                delete task;
                task = NULL;
                iTasks.Remove( i );
                
                TN_DEBUG2( "CThumbnailTaskProcessor::RemoveTask() - removed request ID: %d", aRequestId.iRequestId);
                }
            else
                {
                // Task is already running, canceled first
                task->Cancel();
                delete task;
                task = NULL;
                iTasks.Remove( i );
                cancel = ETrue;
                
                TN_DEBUG2( "CThumbnailTaskProcessor::RemoveTask() - canceled & removed request ID: %d", aRequestId.iRequestId);
                }
            
            res = KErrNone;
            
            // don't break, because there could be many tasks related to the same request ID
            }
        }
    
    // no tasks active anymore
    if ( cancel ) 
        {
        Cancel();
        TaskComplete(NULL);
        }
    
    if(!iTasks.Count())
        {
        iTasks.Compress();
        }
    
    TN_DEBUG2( "CThumbnailTaskProcessor::RemoveTask() - remaining task count: %d", iTasks.Count());
    
    return res;
    }

// ---------------------------------------------------------------------------
// CThumbnailTaskProcessor::RemoveTasks()
// Removes specific task from the queue.
// ---------------------------------------------------------------------------
//
void CThumbnailTaskProcessor::RemoveTasks( CThumbnailServerSession* aSession )
    {
    TN_DEBUG1( "CThumbnailTaskProcessor::RemoveTasks()");
    
    TBool cancel = EFalse;
    
    for ( TInt i = iTasks.Count(); --i >= 0; )
        {
        CThumbnailTask* task = iTasks[i];
        
        if ( task->RequestId().iSession == aSession)
            {
            if ( task->State() != CThumbnailTask::ERunning )
                {
                TThumbnailRequestId id = task->RequestId().iRequestId;
                
                // Remove task from queue
                delete task;
                task = NULL;
                iTasks.Remove( i );
                
                TN_DEBUG2( "CThumbnailTaskProcessor::RemoveTasks() - removed request ID: %d", id);
                }
            else
                {
                TN_DEBUG1( "CThumbnailTaskProcessor::RemoveTasks() - task still running");
                
                TThumbnailRequestId id = task->RequestId().iRequestId;
                
                // Task is already running, canceled first
                task->Cancel();
                delete task;
                task = NULL;
                iTasks.Remove( i );
                cancel = ETrue;
                
                TN_DEBUG2( "CThumbnailTaskProcessor::RemoveTasks() - canceled & removed request ID: %d", id);
                }
            }
        }
    
    // no tasks active anymore
    if ( cancel ) 
        {
        Cancel();
        TaskComplete(NULL);
        }
    
    TN_DEBUG2( "CThumbnailTaskProcessor::RemoveTasks() - remaining task count: %d", iTasks.Count());
    }

// ---------------------------------------------------------------------------
// CThumbnailTaskProcessor::RemoveAllTasks()
// Removes specific task from the queue.
// ---------------------------------------------------------------------------
//
void CThumbnailTaskProcessor::RemoveAllTasks()
    {
    TN_DEBUG1( "CThumbnailTaskProcessor::RemoveAllTasks()");
    
    TBool cancel = EFalse;
    
    for ( TInt i = iTasks.Count(); --i >= 0; )
        {
        CThumbnailTask* task = iTasks[i];
        if ( task->State() != CThumbnailTask::ERunning )
            {
            TThumbnailRequestId id = task->RequestId().iRequestId;
            
            // Remove task from queue
            delete task;
            task = NULL;
            iTasks.Remove( i );
            
            TN_DEBUG2( "CThumbnailTaskProcessor::RemoveTasks() - removed request ID: %d", id);
            }
        else
            {
            TN_DEBUG1( "CThumbnailTaskProcessor::RemoveTasks() - task still running");
            
            TThumbnailRequestId id = task->RequestId().iRequestId;
            
            // Task is already running, canceled first
            task->Cancel();
            delete task;
            task = NULL;
            iTasks.Remove( i );
            cancel = ETrue;
            
            TN_DEBUG2( "CThumbnailTaskProcessor::RemoveTasks() - canceled & removed request ID: %d", id);
            }
        }
    
    // no tasks active anymore
    if ( cancel ) 
        {
        Cancel();
        TaskComplete(NULL);
        }
    
    TN_DEBUG1( "CThumbnailTaskProcessor::RemoveAllTasks() - Task removed because of starting format" );
    }

// ---------------------------------------------------------------------------
// CThumbnailTaskProcessor::ChangeTaskPriority()
// Changes priority of a task.
// ---------------------------------------------------------------------------
//
TInt CThumbnailTaskProcessor::ChangeTaskPriority( const
    TThumbnailServerRequestId& aRequestId, const TInt aNewPriority )
    {
    TInt err = KErrNotFound;
    const TInt count = iTasks.Count();
    for ( TInt i( 0 ); i < count; i++ )
        {
        if ( iTasks[i]->RequestId() == aRequestId )
            {
            iTasks[i]->ChangeTaskPriority( aNewPriority );
            err = KErrNone;
            break;
            }
        }
    return err;
    }


// ---------------------------------------------------------------------------
// CThumbnailTaskProcessor::RunL()
// ---------------------------------------------------------------------------
//
void CThumbnailTaskProcessor::RunL()
    {
    iActiveTask = NULL;
    TInt priority( KMinTInt );
    TInt taskPriority;
    TBool processingDaemonTasksOnly(ETrue);
    
#ifdef _DEBUG
    TN_DEBUG2( "CThumbnailTaskProcessor::TASKPROCESSOR-COUNTER---------- in, Tasks = %d", iTasks.Count() );
#endif
    
    // remove completed tasks and run priorised task
    for ( TInt i = iTasks.Count(); --i >= 0; )
        {
        CThumbnailTask* task = iTasks[i];
        if ( task->State() == CThumbnailTask::EComplete )
            {
            // Delete completed task
            delete task;
            task = NULL;
            iTasks.Remove( i );
            }
        else
            {
            if( task->State() == CThumbnailTask::EIdle )
                {
                taskPriority = task->Priority();
                if ( taskPriority > priority )
                    {
                    priority = taskPriority;
                    iActiveTask = task;
                    }
                }
            
            if ( processingDaemonTasksOnly && task->ClientThreadAlive() )
                {
                if(task->GetMessageData().Identity() != KDaemonUid )
                    {
                    TN_DEBUG1( "CThumbnailTaskProcessor::RunL() processingDaemonTasksOnly = EFalse" );
                    processingDaemonTasksOnly = EFalse; 
                    }
                }
            }
        }

    if ( iActiveTask )
        {
        iActiveTask->StartL();
        }
    
#ifdef _DEBUG
    TN_DEBUG2( "CThumbnailTaskProcessor::TASKPROCESSOR-COUNTER---------- out, Tasks = %d", iTasks.Count() );
#endif

	//update PS value for Daemon
    if( iTasks.Count() > 0 && iIdle && !processingDaemonTasksOnly)
        {
        //set not idle
        if(iTimerActive)
           {
           iPeriodicTimer->Cancel();
           iTimerActive = EFalse;
           }
        TInt ret = iProperty.Set( EFalse );
        TN_DEBUG2( "CThumbnailTaskProcessor::RunL() iProperty Set EFalse %d", ret );
        iIdle = EFalse;
        }
    else
        {
        if(!iIdle)
            {
            //set idle    
            if(iIsDaemonAsProcess)
               {
               if(iTimerActive)
                 {
                 iPeriodicTimer->Cancel();
                 iTimerActive = EFalse;
                 } 
               TN_DEBUG1( "CThumbnailTaskProcessor::RunL() - daemon is the process");
               TInt ret = iProperty.Set( ETrue );
               TN_DEBUG2( "CThumbnailTaskProcessor::RunL() iProperty Set ETrue %d", ret );
               iIdle = ETrue;
               }
            else
               {
               TN_DEBUG1( "CThumbnailTaskProcessor::RunL() - daemon is not the process - start timer");
               if(iTimerActive)
                  {
                  iPeriodicTimer->Cancel();
                  iTimerActive = EFalse;
                  }  
               iPeriodicTimer->Start( KHarvestingCompleteTimeout, KHarvestingCompleteTimeout, 
                                   TCallBack(PeriodicTimerCallBack, this));
               iTimerActive = ETrue;
               }
            }
        }
    }

// ---------------------------------------------------------------------------
// Handle any error from RunL
// ---------------------------------------------------------------------------
//
TInt CThumbnailTaskProcessor::RunError( TInt aError )
    {
    TN_DEBUG1( "CThumbnailTaskProcessor::RunError()");
    if ( iActiveTask )
        {
        // This will complete the task and continue processing from the
        // next task
        iActiveTask->StartError( aError );
        }
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CThumbnailTaskProcessor::DoCancel()
// ---------------------------------------------------------------------------
//
void CThumbnailTaskProcessor::DoCancel()
    {
    // No implementation required
    }


// ---------------------------------------------------------------------------
// CThumbnailTaskProcessor::TaskComplete()
// Marks task to completed
// ---------------------------------------------------------------------------
//
void CThumbnailTaskProcessor::TaskComplete( CThumbnailTask*  /*aTask*/ )
    {
    TN_DEBUG1( "CThumbnailTaskProcessor::TaskComplete()");
 
    if ( iTasks.Count() && !IsActive())
        {
        // More tasks yet to be run
        SetActive();
        TRequestStatus* statusPtr = &iStatus;
        User::RequestComplete( statusPtr, KErrNone );
        }
    else if( iTasks.Count() == 0 && !iIdle)
        {
        if(iIsDaemonAsProcess)
            {
            if(iTimerActive)
              {
              iPeriodicTimer->Cancel();
              iTimerActive = EFalse;
              } 
            TN_DEBUG1( "CThumbnailTaskProcessor::TaskComplete() - daemon is the process");
            TInt ret = iProperty.Set( ETrue );
            TN_DEBUG2( "CThumbnailTaskProcessor::TaskComplete() iProperty Set ETrue %d", ret );
            iIdle = ETrue;
            }
        else
            {
            if(iTimerActive)
              {
              iPeriodicTimer->Cancel();
              iTimerActive = EFalse;
              }  
            iPeriodicTimer->Start( KPSKeyTimeout, KPSKeyTimeout, 
                             TCallBack(PeriodicTimerCallBack, this));
            iTimerActive = ETrue;
            }
        }
    }

// ---------------------------------------------------------------------------
// CThumbnailTaskProcessor::PeriodicTimerCallBack()
// ---------------------------------------------------------------------------
//
TInt CThumbnailTaskProcessor::PeriodicTimerCallBack(TAny* aAny)
    {
    TN_DEBUG1( "CThumbnailTaskProcessor::PeriodicTimerCallBack()");
    
    CThumbnailTaskProcessor* self = static_cast<CThumbnailTaskProcessor*>( aAny );
    
    self->iTimerActive = EFalse;
    self->iPeriodicTimer->Cancel();
    TInt ret = self->iProperty.Set( ETrue );
    TN_DEBUG2( "CThumbnailTaskProcessor::PeriodicTimerCallBack() iProperty Set ETrue %d", ret );
    self->iIdle = ETrue;

    return KErrNone; // Return value ignored by CPeriodic
    }

void CThumbnailTaskProcessor::SetDaemonAsProcess(TBool aValue)
    {
    TN_DEBUG2( "CThumbnailTaskProcessor::SetDaemonAsProcess() Daemon set %d", aValue );
    iIsDaemonAsProcess = aValue;
    }


// End of file