/*

* Copyright (c) 2004 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: Client application plugin loader.

*

*/

// INCLUDE FILES

#include    <imlauncherplugin.h>

#include    "imlauncher.h"

#include    "logutils.h"

// Default start wait time in sec

static const TInt KDefaultTimeOut = 60;

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

// -----------------------------------------------------------------------------

// CImLauncher::CImLauncher

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CImLauncher::CImLauncher()

        :   CActive( EPriorityStandard ),

        iPlugin( NULL ),

        iReturnValue( KErrNone )

    {

    CActiveScheduler::Add( this );

    }

// -----------------------------------------------------------------------------

// CImLauncher::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CImLauncher::ConstructL()

    {

    iTimer = CImShutDownTimer::NewL( this, EPriorityStandard );

    }

// -----------------------------------------------------------------------------

// CImLauncher::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CImLauncher* CImLauncher::NewL()

    {

    CImLauncher* self = new( ELeave ) CImLauncher;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CImLauncher::~CImLauncher()

    {

    Cancel();

    delete iTimer;

    if ( iPlugin ) // extra security check

        {

        delete iPlugin;

        }

    }

// -----------------------------------------------------------------------------

// CImLauncher::Panic

// Panics the thread

// -----------------------------------------------------------------------------

//

void CImLauncher::Panic( TLauncherPanic aPanicCode )

    {

    User::Panic( KLauncherPanic, aPanicCode );

    }

// -----------------------------------------------------------------------------

// CImLauncher::RunL

// -----------------------------------------------------------------------------

//

void CImLauncher::RunL()

    {

#ifdef _DEBUG

    CImApiLogger::Log( _L( "Application start status: %d" ), iStatus.Int() );

#endif

    iReturnValue = iStatus.Int();

    // We're finished

    iTimer->Cancel();

    CActiveScheduler::Stop();

    }

// -----------------------------------------------------------------------------

// CImLauncher::DoCancel

// -----------------------------------------------------------------------------

//

void CImLauncher::DoCancel()

    {

    if ( iPlugin ) // extra security check

        {

        iPlugin->CancelStartApplication();

        }

    iTimer->Cancel();

    }

// -----------------------------------------------------------------------------

// CImLauncher::DoShutDown

// -----------------------------------------------------------------------------

//

void CImLauncher::TimedOut()

    {

#ifdef _DEBUG

    CImApiLogger::Log( _L( "Application starting timed out" ) );

#endif

    Cancel();

    iReturnValue = KErrTimedOut;

    CActiveScheduler::Stop();

    }

// -----------------------------------------------------------------------------

// CImLauncher::RunError

// Handles the RunL leave errors

// -----------------------------------------------------------------------------

//

TInt CImLauncher::RunError( TInt /*aError*/ )

    {

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CImLauncher::StartL()

// Loads the application launcher plugin and waits for the completition

// -----------------------------------------------------------------------------

void CImLauncher::StartL( TImpsLaunchParams& aThreadParams )

    {

    /*

     * Convert the 16bit descriptor to 8bit.

     * This should not be a problem as ClientID should not contain

     * non ASCII chars.

     * If there will be a problem the ECom default resolver should be changed!

     */

    TBuf8<KImpsMaxClientId> applicationId;

    if ( aThreadParams.iApplicationId.Length() > KImpsMaxClientId )

        {

        User::Leave( KErrArgument );

        }

    else

        {

        applicationId.Copy( aThreadParams.iApplicationId );

        }

#ifdef _DEBUG

    // NOTICE: this accepts only 16bit descriptor to log :-(

    CImApiLogger::Log( _L( "Loading 3rd party launcher plugin: %S" ), &aThreadParams.iApplicationId );

#endif

    // ECom loading

    iPlugin = CImLauncherPlugin::NewL( applicationId );

#ifdef _DEBUG

    CImApiLogger::Log( _L( "Loading successfull" ) );

#endif

    // Make a request

    iStatus = KRequestPending;

    SetActive();

    iPlugin->StartApplicationL( iStatus, aThreadParams.iSAP, aThreadParams.iUserId );

#ifdef _DEBUG

    CImApiLogger::Log( _L( "Timer started: %d sec" ), KDefaultTimeOut );

#endif

    iTimer->After( KDefaultTimeOut * 1000000 );

    CActiveScheduler::Start();

    // if the request failed return the fail code to thread starter

    User::LeaveIfError( iReturnValue );

    delete iPlugin;

    iPlugin = NULL;

    }

// -----------------------------------------------------------------------------

// ThreadFunction()

// Static function. Installs the CleanupsStack and ActiveScheduler

// then initiates the application launching.

// -----------------------------------------------------------------------------

TInt CImLauncher::ThreadFunction( TImpsLaunchParams& aThreadParams )

    {

#ifdef _DEBUG

    CImApiLogger::Log( _L( "ThreadFunction start" ) );

    __UHEAP_MARK;

#endif

    CTrapCleanup* cleanupStack = CTrapCleanup::New();

    if ( cleanupStack == NULL )

        {

        Panic( ECreateTrapCleanup );

        }

    // Construct active scheduler

    CActiveScheduler* activeScheduler = new CActiveScheduler;

    // Install active scheduler

    // We don't need to check whether an active scheduler is already installed

    // as this is a new thread, so there won't be one

    CActiveScheduler::Install( activeScheduler );

    CImLauncher* launcher = NULL;

    TRAPD( err,  launcher = CImLauncher::NewL() );

    if ( err == KErrNone )

        {

        TRAP( err, launcher->StartL( aThreadParams ) );

        }

    delete launcher;

    delete activeScheduler;

    delete cleanupStack;

    cleanupStack = NULL;

    REComSession::FinalClose();

#ifdef _DEBUG

    CImApiLogger::Log( _L( "ThreadFunction end %d" ), err );

    __UHEAP_MARKEND;

    CImApiLogger::Log( _L( "MEM TEST OK" ) );

#endif

    return err;

    }

/*

 * Main function

 */

TInt E32Main()

    {

#ifdef _DEBUG

    CImApiLogger::Log( _L( "EXE Started" ) );

#endif

//

    TBuf < sizeof( TImpsLaunchParams ) > paramsDes;

    User::CommandLine( paramsDes );

    TImpsLaunchParams params;

    params.Set( paramsDes );

    return CImLauncher::ThreadFunction( params );

    }

//**********************************

// CImShutDownTimer

//**********************************

// -----------------------------------------------------------------------------

// CImShutDownTimer::CImShutDownTimer()

// Constructor

// -----------------------------------------------------------------------------

CImShutDownTimer::CImShutDownTimer( CImLauncher* aLauncher, TInt aPriority )

        : CTimer( aPriority ),

        iLauncher( aLauncher )

    {

    CActiveScheduler::Add( this );

    }

// -----------------------------------------------------------------------------

// CImShutDownTimer::ConstructL()

// 2nd phase Constructor

// -----------------------------------------------------------------------------

void CImShutDownTimer::ConstructL()

    {

    CTimer::ConstructL();

    }

// -----------------------------------------------------------------------------

// CImShutDownTimer::NewL()

// Factory function

// -----------------------------------------------------------------------------

CImShutDownTimer* CImShutDownTimer::NewL( CImLauncher* aLauncher, TInt aPriority )

    {

    CImShutDownTimer* self = new( ELeave ) CImShutDownTimer( aLauncher, aPriority );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// -----------------------------------------------------------------------------

// CImShutDownTimer::~CImShutDownTimer()

// Destructor

// -----------------------------------------------------------------------------

CImShutDownTimer::~CImShutDownTimer()

    {

    Cancel();

    }

// -----------------------------------------------------------------------------

// CImShutDownTimer::RunL()

// Signals the timeout to the timer user

// -----------------------------------------------------------------------------

void CImShutDownTimer::RunL()

    {

    iLauncher->TimedOut();

    }

//  End of File