/*

* 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 "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:  XIMP Framework process starter implementation.

*

*/

//  INCLUDE FILES

#include "ximpprocessstarter.h"

#include <e32std.h>

#include <f32file.h>

// CONSTANTS

_LIT( KEka2ExeDir,"\\sys\\bin\\");

_LIT( KEka2LaunchMutexExt, "[lMtx]" );

const TInt KEka2SrvConnTries = 7;               // Try to start 7 times

                                                // before giving up

const TInt KEka2SrvConnInitialRetryWait = 500;  // MicroSeconds => 0.0005s

// ==============================================================

// ====================== HELPER CLASS ==========================

// ==============================================================

/**

 * RSessionBase accessor to give to the XIMPProcessStarter

 * access to RSessionBase::CreateSession().

 */

class REka2SessionBaseAccessor : public RSessionBase

    {

    public: // Constructor

        inline REka2SessionBaseAccessor()

            {

            }

    public: // New functions

        /**

         * Public access to RSessionBase::CreateSession().

         */

        inline TInt CreateSession( const TDesC& aServer,

                                   const TVersion& aVersion,

                                   TInt aAsyncMessageSlots )

            {

            return RSessionBase::CreateSession( aServer,

                                                aVersion,

                                                aAsyncMessageSlots );

            }

    };

// ==============================================================

// ====================== PROCESSSTARTER ========================

// ==============================================================

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

// XIMPProcessStarter::FullExePathForClienLocation()

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

//

EXPORT_C void XIMPProcessStarter::FullExePathForClienLocation(

    const TDesC& aExeName,

    TFileName& aFullExePath )

    {

    //Get drive (C:) where this client code is installed

        {

        TFileName tmp;

        Dll::FileName( tmp );

        aFullExePath.Copy( TParsePtrC( tmp ).Drive() );

        }

    //Build the rest from the exe path

    aFullExePath.Append( KEka2ExeDir );

    aFullExePath.Append( aExeName );

    }

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

// XIMPProcessStarter::StartInstance()

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

//

EXPORT_C TInt XIMPProcessStarter::StartInstance(

    const TDesC& aFullExePath,

    const TDesC& aCommand,

    const TArray< TXIMPProcessStartupParam >* aParams )

    {

    RMutex launchMutex;

    TInt error = KErrNotFound;

        {

        // Dynamic mutex name used to allow code share

        TName launchMutexName( TParsePtrC( aFullExePath ).Name() );

        launchMutexName.Append( KEka2LaunchMutexExt );

        // Open or Create mutex to serialize to access to server startup code.

        // (race condition safe way)

        while( error == KErrNotFound )

            {

            error = launchMutex.CreateGlobal( launchMutexName );

            if( error != KErrAlreadyExists )

                {

                break;

                }

            error = launchMutex.OpenGlobal( launchMutexName );

            }

        if( error != KErrNone )

            {

            return error;

            }

        }

    launchMutex.Wait();

    //Serialized access

    error = XIMPProcessStarter::DoStartInstance( aFullExePath,

                                             aCommand,

                                             aParams );

    launchMutex.Signal();

    launchMutex.Close();

    return error;

    }

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

// XIMPProcessStarter::ConnectToServer()

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

//

EXPORT_C TInt XIMPProcessStarter::ConnectToServer(

    const TDesC& aFullExePath,

    const TDesC& aCommand,

    const TArray< TXIMPProcessStartupParam >* aParams,

    RSessionBase& aSessionToConnect,

    const TDesC& aServerName,

    const TVersion& aClientVersion,

    TInt aAsyncMessageSlots )

    {

    if( aSessionToConnect.Handle() != KNullHandle )

        {

        return KErrInUse;

        }

    TInt err = KErrNone;

    TInt startupWait = KEka2SrvConnInitialRetryWait;

    //Server connect and launch loop

    for( TInt trie = 0 ; trie < KEka2SrvConnTries ; trie++ )

        {

        REka2SessionBaseAccessor acc;

        err = acc.CreateSession( aServerName,

                                 aClientVersion,

                                 aAsyncMessageSlots );

        if( err == KErrNone )

            {

            //session ownership is now on client

            aSessionToConnect = acc;

            return KErrNone;

            }

        else if( ( err == KErrNotFound ) ||

                 ( err == KErrServerTerminated ) )

            {

            //Server missing or died when connecting

            //Start a new server

            err = XIMPProcessStarter::StartInstance( aFullExePath,

                                                     aCommand,

                                                     aParams );

            //If process exist already, then all is fine

            //(some other process started it between the origical connect and launch trie)

            if( err == KErrAlreadyExists )

                {

                err = KErrNone;

                }

            //If server process start failed, bail out.

            if( err != KErrNone )

                {

                return err;

                }

            //If this is 2nd or subsequent try,

            //give some time for server to startup

            if( trie > 0 )

                {

                User::After( startupWait ); // CSI: 92 #

                startupWait = 2 * startupWait;

                }

            }

        else

            {

            //Server process start failed. Bail out.

            return err;

            }

        }

    return err;

    }

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

// XIMPProcessStarter::DoStartServerInstance()

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

//

TInt XIMPProcessStarter::DoStartInstance(

    const TDesC& aFullExePath,

    const TDesC& aCommand,

    const TArray< TXIMPProcessStartupParam >* aParams )

    {

    TInt error = KErrNone;

    //Create process

    RProcess process;

    error = process.Create( aFullExePath, aCommand );

    if( error == KErrNone )

        {

        //Set process startup parameters

        error = ApplyParameters( aParams, process );

        //And execute the process and wait it's startup

       if( error == KErrNone )

            {

            TRequestStatus rendezvousStatus;

            process.Rendezvous( rendezvousStatus );

            process.Resume();

            User::WaitForRequest( rendezvousStatus ); // CSI: 94 #

            error = rendezvousStatus.Int();

            if( process.ExitType() != EExitPending )

                {

                //Something failed in server startup

                //Force the error code to be always something

                //else than KErrNone

                if( error == KErrNone )

                    {

                    error = KErrServerTerminated;

                    }

                }

            }

        }

    process.Close();

    return error;

    }

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

// XIMPProcessStarter::ApplyParameters()

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

//

TInt XIMPProcessStarter::ApplyParameters(

    const TArray< TXIMPProcessStartupParam >* aParams,

    RProcess& aProcess )

    {

    TInt error = KErrNone;

    if( aParams )

        {

        const TInt paramCount = aParams->Count();

        for( TInt ix = 0; ix < paramCount; ix++ )

            {

            error = (*aParams)[ ix ].ApplyParam( aProcess );

            if( error != KErrNone )

                {

                break;

                }

            }

        }

    return error;

    }

// ==============================================================

// ================== TPROCESSSTARTUPPARAM ======================

// ==============================================================

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

// TXIMPProcessStartupParam::TXIMPProcessStartupParam()

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

//

EXPORT_C TXIMPProcessStartupParam::TXIMPProcessStartupParam()

    : iType( EUnknown ),

      iSlot( KErrNotFound )

    {

    }

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

// TXIMPProcessStartupParam::Set()

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

//

void TXIMPProcessStartupParam::Set( TInt aSlot,

                                const RHandleBase& aHandle )

    {

    iType = EHandle;

    iSlot = aSlot;

    iHandle = &aHandle;

    }

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

// TXIMPProcessStartupParam::Set()

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

//

void TXIMPProcessStartupParam::Set( TInt aSlot,

                                const RSubSessionBase& aSubSession )

    {

    iType = ESubSession;

    iSlot = aSlot;

    iSubSession = &aSubSession;

    }

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

// TXIMPProcessStartupParam::Set()

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

//

void TXIMPProcessStartupParam::Set( TInt aSlot,

                                const TDesC16& aDes )

    {

    iType = EDes16;

    iSlot = aSlot;

    iDes16.Set( aDes );

    }

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

// TXIMPProcessStartupParam::Set()

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

//

void TXIMPProcessStartupParam::Set( TInt aSlot,

                                const TDesC8& aDes )

    {

    iType = EDes8;

    iSlot = aSlot;

    iDes8.Set( aDes );

    }

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

// TXIMPProcessStartupParam::Set()

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

//

EXPORT_C void TXIMPProcessStartupParam::Set( TInt aSlot,

                                TInt aInt )

    {

    iType = EInt;

    iSlot = aSlot;

    iInt = aInt;

    }

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

// TXIMPProcessStartupParam::ApplyParam()

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

//

TInt TXIMPProcessStartupParam::ApplyParam( RProcess& aProcess ) const

    {

    switch( iType )

        {

        case EHandle: return aProcess.SetParameter( iSlot, *iHandle );

        case ESubSession: return aProcess.SetParameter( iSlot, *iSubSession );

        case EDes16: return aProcess.SetParameter( iSlot, iDes16 );

        case EDes8: return aProcess.SetParameter( iSlot, iDes8 );

        case EInt: return aProcess.SetParameter( iSlot, iInt );

        }

    return KErrUnknown;

    }

// END OF FILE