/*
* Copyright (c) 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:  
*
*/

#include "cpactionhandlerthread.h"
#include "cpserverdef.h"
#include "cpserveractionmanager.h"
#include "cpglobals.h"

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
TInt CPExecutionThreadFunction( TAny* aParam )
    {
    ASSERT( aParam );
    CCPActionHandlerThread* actionHandlerThread =
            reinterpret_cast<CCPActionHandlerThread*>( aParam );
    return actionHandlerThread->ThreadFunction();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CCPActionHandlerThread* CCPActionHandlerThread::NewL()
    {
    CCPActionHandlerThread* self = NewLC();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CCPActionHandlerThread* CCPActionHandlerThread::NewLC()
    {
    CCPActionHandlerThread* self = new ( ELeave ) CCPActionHandlerThread;
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CCPActionHandlerThread::~CCPActionHandlerThread()
    {
    if ( ExecutionThreadRunning() && iActionExecutorAO )
        {
        // stop action execution thread
        
        // request notification when action execution thread terminates
        TRequestStatus exitStatus;
        iActionExecThread.Logon( exitStatus );
        
        // passing NULL as action parameters will cause the action executor to
        // stop active scheduler in command execution thread
        iActionExecutorAO->SetActionParams( NULL );
        // ask action executor to execute the action
        TRequestStatus* actionExecutorAOStatus =
            iActionExecutorAO->RequestStatus();
        iActionExecThread.RequestComplete( actionExecutorAOStatus, KErrNone );
        
        // wait for the action execution thread to terminate
        User::WaitForRequest( exitStatus );
        }
    iActionExecThread.Close();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CCPActionHandlerThread::ExecuteL(
        const CLiwGenericParamList& aActionParams )
    {
    StartExecutionThreadIfNeededL();
    
    ASSERT( iActionExecutorAO );
    iActionExecutorAO->SetActionParams( &aActionParams );
    
    // create rendezvous so that we are notified when action
    // execution finishes
    TRequestStatus actionExecutionStatus = KRequestPending;
    iActionExecThread.Rendezvous( actionExecutionStatus );
    
    // request action execution by completing request for the AO running
    // in the action execution thread 
    TRequestStatus* actionExecutorAOStatus =
            iActionExecutorAO->RequestStatus();
    iActionExecThread.RequestComplete( actionExecutorAOStatus, KErrNone );
    
    // wait until action execution finishes
    User::WaitForRequest( actionExecutionStatus );

    TInt err = actionExecutionStatus.Int();
    // please note that checking actionExecutionStatus is not a reliable way of
    // determining whether everything is OK because if plugin panics with 
    // reason (panic number) KErrNone, actionExecutionStatus will contain KErrNone
    if ( !ExecutionThreadRunning() )
        {
        // action execution thread died,
        // iActionExecutorAO pointer is no longer valid
        iActionExecutorAO = NULL;
        if ( err >= 0 )
            {
            err = KErrDied;
            }
        }
    else
        {
        iActionExecutorAO->SetActionParams( NULL );
        }
    
    User::LeaveIfError( err );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
 void CCPActionHandlerThread::StartExecutionThreadIfNeededL()
    {
    if ( !ExecutionThreadRunning() )
        {
        TBuf<KThreadNameLimit> threadName;
        if ( iActionExecThreadStarted )
            {
            iActionExecThread.Close();
            }
        
        // create action execution thread
        threadName.Format( KCPServerPluginThreadName, ++iThreadNum );
        TInt err = iActionExecThread.Create( threadName,
                CPExecutionThreadFunction,
                KDefaultStackSize,
                KCPServerPluginThreadMinHeapSize,
                KCPServerPluginThreadMaxHeapSize,
                reinterpret_cast<TAny*>( this ) );
        User::LeaveIfError( err );
        
        // create rendezvous so that we are notified when the thread
        // has started
        TRequestStatus threadStatus;
        iActionExecThread.Rendezvous( threadStatus );
        
        // start the action execution thread
        iActionExecThread.Resume();
        
        // wait for the thread to start
        User::WaitForRequest( threadStatus );
        
        User::LeaveIfError( threadStatus.Int() );
        
        iActionExecThreadStarted = ETrue;
        ASSERT( ExecutionThreadRunning() );
        }
    }

// ---------------------------------------------------------------------------
// RThread::ExitType() returns EExitPending if the thread is alive or has not
// been started yet. There is a member variable, iActionExecThreadStarted
// which tells if the thread was started or not. Combining the information
// from the member variable and RThread::ExitType() allows us to determine if
// the thread is running (alive).
// ---------------------------------------------------------------------------
//
 TBool CCPActionHandlerThread::ExecutionThreadRunning()
    {
    TBool actionExecThreadDidNotDie =
            iActionExecThread.ExitType() == EExitPending;

    TBool threadRunning =
            iActionExecThreadStarted && actionExecThreadDidNotDie;
    
    // if the thread is alive, it must have created an active object for
    // executing actions in plugins; verify that it is the case
    ASSERT( !threadRunning || ( threadRunning && iActionExecutorAO ));
    
    return threadRunning;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
 CCPActionHandlerThread::CCPActionHandlerThread()
    {
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CCPActionHandlerThread::ConstructL()
    {
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
TInt CCPActionHandlerThread::ThreadFunction()
    {
    __UHEAP_MARK;

    CServerEikonEnv* env = new CServerEikonEnv;
    if ( !env )
        {
        return KErrNoMemory;
        }
    CServerAppUi* ui = new CServerAppUi;
    if ( !ui )
        {
        delete env;
        return KErrNoMemory;
        }
    
    TRAPD( err,
        env->ConstructL();
        env->DisableExitChecks( ETrue );
        ui->ConstructL();

        iActionExecutorAO = CActionExecutorAO::NewL();
        
        // notify the main thread that action execution thread
        // has successfully started
        RThread::Rendezvous( KErrNone );

        CActiveScheduler::Start();
    );

    delete iActionExecutorAO;
    iActionExecutorAO = NULL;

    ui->PrepareToExit();
    env->DestroyEnvironment();
    
    __UHEAP_MARKEND;
    
    return err;
    }

// -----------------------------------------------------------------------------
// CContentHarvesterEikonEnv::DestroyEnvironment
// 
// -----------------------------------------------------------------------------
//
void CCPActionHandlerThread::CServerEikonEnv::DestroyEnvironment()
    {
    CEikonEnv::DestroyEnvironment( );
    }

// -----------------------------------------------------------------------------
// CContentHarvesterEikonEnv::ConstructL
// 
// -----------------------------------------------------------------------------
//
void CCPActionHandlerThread::CServerEikonEnv::ConstructL()
    {
    CEikonEnv::ConstructL( EFalse );
    SetAutoForwarding( ETrue );
    User::SetPriorityControl( EFalse );
    }
// -----------------------------------------------------------------------------
// CContentHarvesterAppUi::~CContentHarvesterAppUi
// 
// -----------------------------------------------------------------------------
//
CCPActionHandlerThread::CServerAppUi::~CServerAppUi()
    {
    }

// ---------------------------------------------------------------------------
// CContentHarvesterAppUi::ConstructL
// 
// ---------------------------------------------------------------------------
//
void CCPActionHandlerThread::CServerAppUi::ConstructL()
    {
    CEikAppUi::BaseConstructL( ENoAppResourceFile | ENoScreenFurniture );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CCPActionHandlerThread::CActionExecutorAO*
CCPActionHandlerThread::CActionExecutorAO::NewL()
    {
    CActionExecutorAO* self = NewLC();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CCPActionHandlerThread::CActionExecutorAO*
CCPActionHandlerThread::CActionExecutorAO::NewLC()
    {
    CActionExecutorAO* self = new ( ELeave ) CActionExecutorAO();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CCPActionHandlerThread::CActionExecutorAO::~CActionExecutorAO()
    {
    delete iActionManager;
    }
        
// ---------------------------------------------------------------------------
// Any code executed in this method must not leave!
// This way we avoid implementing RunError while making sure that 
// Rendezvous will always be called
// ---------------------------------------------------------------------------
//
void CCPActionHandlerThread::CActionExecutorAO::RunL()
    {
    if( iActionParams )
        {
        // execute action
        TRAPD( err, iActionManager->ExecuteL( *iActionParams ) );
        
        // notify the main thread that action execution has finished
        RThread::Rendezvous( err );
    
        // wait until another action execution is requested
        iStatus = KRequestPending;
        SetActive();
        }
    else
        {
        CActiveScheduler::Stop();
        }
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CCPActionHandlerThread::CActionExecutorAO::DoCancel()
    {
    TRequestStatus* myRequestStatus = &iStatus;
    User::RequestComplete( myRequestStatus, KErrCancel );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
TRequestStatus* CCPActionHandlerThread::CActionExecutorAO::RequestStatus()
    {
    return &iStatus;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CCPActionHandlerThread::CActionExecutorAO::SetActionParams(
        const CLiwGenericParamList* aActionParams )
    {
    iActionParams = aActionParams;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CCPActionHandlerThread::CActionExecutorAO::CActionExecutorAO()
    : CActive( CActive::EPriorityLow )
    {
    CActiveScheduler::Add( this );

    // wait until action execution is requested
    iStatus = KRequestPending;
    SetActive();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CCPActionHandlerThread::CActionExecutorAO::ConstructL()
    {
    iActionManager = CCPActionManager::NewL();
    }