/*
* 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: Proxy class for Im app launcher.
*
*/



// INCLUDE FILES
#include    <E32Math.h>
#include    "impsapplauncherproxy.h"
#include    "impsutils.h"

// CONSTANTS

// MACROS
#ifndef _DEBUG
#define _NO_IMPS_LOGGING_
#endif


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

// -----------------------------------------------------------------------------
// CImpsAppLauncherProxy::CImpsAppLauncherProxy
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CImpsAppLauncherProxy::CImpsAppLauncherProxy( MImpsAppLaunchHandler* aLaunchObserver )
        :   CActive( EPriorityStandard ),
        iLaunchObserver( aLaunchObserver ),
        iRequestList( _FOFF( CLaunchRequest, iLink ) )
    {
    CActiveScheduler::Add( this );
    }

// -----------------------------------------------------------------------------
// CImpsAppLauncherProxy::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CImpsAppLauncherProxy::ConstructL()
    {
    }

// -----------------------------------------------------------------------------
// CImpsAppLauncherProxy::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CImpsAppLauncherProxy* CImpsAppLauncherProxy::NewL(
    MImpsAppLaunchHandler* aLaunchObserver )
    {
    CImpsAppLauncherProxy* self = new( ELeave ) CImpsAppLauncherProxy(
        aLaunchObserver );

    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();

    return self;
    }


// Destructor
CImpsAppLauncherProxy::~CImpsAppLauncherProxy()
    {
    // Free the request queue
    TDblQueIter<CLaunchRequest> iter( iRequestList );
    iter.SetToFirst();
    while ( iter )
        {
        CLaunchRequest* request = iter;
        iter++;
        request->Destroy();
        }

    Cancel();
    delete iCurrentRequest; // just in case
    }


// -----------------------------------------------------------------------------
// CImpsAppLauncherProxy::LaunchApplication
// The request function. Launches the application which is registered with
// the given ApplicationID.
// -----------------------------------------------------------------------------
//
TInt CImpsAppLauncherProxy::LaunchApplicationL( const TDesC& aApplicationId,
                                                const TDesC& aSAP,
                                                const TDesC& aUserID )
    {
#ifndef _NO_IMPS_LOGGING_
    CImpsClientLogger::Log( _L( "CImpsAppLauncherProxy: LaunchApplication (appId: %S, SAP: %S, user: %S)" ), &aApplicationId, &aSAP, &aUserID );
#endif

    CLaunchRequest* launchRequest = CLaunchRequest::NewL( aApplicationId, aSAP, aUserID );


    if ( IsActive() )
        {
        if ( !iCurrentRequest )
            {
            delete launchRequest;
            User::Leave( KErrCorrupt );
            }

        if ( !( *iCurrentRequest == *launchRequest ) )
            {
            // Different request
            // Queue this aApplicationId it for later handling
#ifndef _NO_IMPS_LOGGING_
            CImpsClientLogger::Log( _L( "CImpsAppLauncherProxy: Active with different request " ) );
#endif
            QueueRequest( *launchRequest );
            }
        else
            {
#ifndef _NO_IMPS_LOGGING_
            CImpsClientLogger::Log( _L( "CImpsAppLauncherProxy: Active with same request " ) );
#endif

            }
        }
    else // not active
        {
#ifndef _NO_IMPS_LOGGING_
        CImpsClientLogger::Log( _L( "CImpsAppLauncherProxy: Not active. Starting." ) );
#endif
        // Assign a new request to current
        delete iCurrentRequest;
        iCurrentRequest = NULL;
        iCurrentRequest = launchRequest;

        // return ImLauncher process starting error code
        TInt err = DoStartProcess( *iCurrentRequest );
        if ( err )
            {
            delete iCurrentRequest;
            iCurrentRequest = NULL;
            }

        return err;
        }
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CImpsAppLauncherProxy::RunL
// Called when the launcher process exited
// -----------------------------------------------------------------------------
//
void CImpsAppLauncherProxy::RunL()
    {
    // Here comes the control when the ImLauncher.exe (or dll) finished
#ifndef _NO_IMPS_LOGGING_
    CImpsClientLogger::Log( _L( "CImpsAppLauncherProxy: RunL %d" ), iStatus.Int() );
#endif

    // Notify the observer if any
    if ( iLaunchObserver != NULL )
        {
        iLaunchObserver->HandleAppLaunch( iCurrentRequest->ApplicationId(), iStatus.Int() );
        }

    // Delete the current Client ID
    delete iCurrentRequest;
    iCurrentRequest = NULL;

    ProcessNextRequestL();
    }

// -----------------------------------------------------------------------------
// CImpsAppLauncherProxy::DoCancel
// -----------------------------------------------------------------------------
//
void CImpsAppLauncherProxy::DoCancel()
    {
    }

// -----------------------------------------------------------------------------
// CImpsAppLauncherProxy::RunError
// Called when the RunL leaved
// -----------------------------------------------------------------------------
//
TInt CImpsAppLauncherProxy::RunError( TInt /*aError*/ )
    {
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CImpsAppLauncherProxy::DoStartProcess
// Starts the ImLauncher process
// -----------------------------------------------------------------------------
//
TInt CImpsAppLauncherProxy::DoStartProcess( CLaunchRequest& aRequest )
    {
    TInt result;

    RProcess launcher;
    const TDesC& appId = aRequest.ApplicationId();
    const TDesC& sap = aRequest.Sap();
    const TDesC& userId = aRequest.UserId();
    TImpsLaunchParams params( appId, sap, userId );
    _LIT( KLauncherFilenameExe, "ImLauncher.exe" );
    TPtrC paramsDes = params.Get();
    result = launcher.Create( KLauncherFilenameExe, paramsDes );
    if ( result != KErrNone )
        {
#ifndef _NO_IMPS_LOGGING_
        CImpsClientLogger::Log( _L( "CImpsAppLauncherProxy: Create process failed: %d " ), result );
#endif
        return result;
        }

    // When the launcher exits we'll get the exit code in iStatus
    iStatus = KRequestPending;
    SetActive();
    launcher.Logon( iStatus );

    launcher.Resume();
    launcher.Close();

#ifndef _NO_IMPS_LOGGING_
    CImpsClientLogger::Log( _L( "CImpsAppLauncherProxy: Create process success" ) );
#endif
    return KErrNone;
    }


// -----------------------------------------------------------------------------
// CImpsAppLauncherProxy::QueueRequest
// Adds the request to the queue. No duplicates are queued.
// -----------------------------------------------------------------------------
//
void CImpsAppLauncherProxy::QueueRequest( CLaunchRequest& aRequest )
    {
    // Check for duplicate requests
    if ( !IsDuplicate( aRequest ) )
        {
#ifndef _NO_IMPS_LOGGING_
        CImpsClientLogger::Log( _L( "Queued" ) );
#endif
        iRequestList.AddLast( aRequest );
        }
    else
        {
#ifndef _NO_IMPS_LOGGING_
        CImpsClientLogger::Log( _L( "Request already exists" ) );
#endif
        }
    }

// -----------------------------------------------------------------------------
// CImpsAppLauncherProxy::ProcessNextRequest
// Gets the next request from the queue and processes it.
// -----------------------------------------------------------------------------
//
void CImpsAppLauncherProxy::ProcessNextRequestL()
    {
    // Check for queued
    TDblQueIter<CLaunchRequest> iter ( iRequestList );
    iter.SetToFirst();
    if ( iter )
        {
        // There is request to handle
        CLaunchRequest* request = iter;
        delete iCurrentRequest;
        iCurrentRequest = NULL;
        iCurrentRequest = request;
        request->iLink.Deque(); // remove it from the queue

#ifndef _NO_IMPS_LOGGING_
        CImpsClientLogger::Log(
            _L( "CImpsAppLauncherProxy: Processing the next request: \"%S\"" ),
            &( iCurrentRequest->ApplicationId() ) );
#endif

        TInt err( DoStartProcess( *iCurrentRequest ) );
        if ( ( err != KErrNone ) )
            {
            // if starting failed notify the observer
            if ( iLaunchObserver != NULL )
                {
                iLaunchObserver->HandleAppLaunch( iCurrentRequest->ApplicationId(), err );
                }
            }

        }
    else
        {
#ifndef _NO_IMPS_LOGGING_
        CImpsClientLogger::Log(
            _L( "CImpsAppLauncherProxy: No more requests to process" ) );
#endif

        }
    }


// -----------------------------------------------------------------------------
// CImpsAppLauncherProxy::IsDuplicate
// Checks if the given ApplicationID is already in the queue.
// -----------------------------------------------------------------------------
//
TBool CImpsAppLauncherProxy::IsDuplicate( CLaunchRequest& aRequest )
    {
    TDblQueIter<CLaunchRequest> iter ( iRequestList );
    iter.SetToFirst();
    while ( iter )
        {
        CLaunchRequest* request = iter++;
        if ( aRequest == *request )
            {
            return ETrue;
            }
        }

    return EFalse;
    }

//////////////////////////////////////////////////////////////////////////

// -----------------------------------------------------------------------------
// CLaunchRequest::CLaunchRequest
// -----------------------------------------------------------------------------

CLaunchRequest::CLaunchRequest( )
    {
    }


CLaunchRequest* CLaunchRequest::NewL( const TDesC& aCID,
                                      const TDesC& aSAP,
                                      const TDesC& aUserId )
    {
    CLaunchRequest* self = new( ELeave ) CLaunchRequest();

    CleanupStack::PushL( self );
    self->ConstructL( aCID, aSAP, aUserId );
    CleanupStack::Pop();

    return self;

    }

void CLaunchRequest::ConstructL( const TDesC& aCID,
                                 const TDesC& aSAP,
                                 const TDesC& aUserId )
    {
    iCID = aCID.AllocL();
    iSAP = aSAP.AllocL();
    iUserId = aUserId.AllocL();
    }

CLaunchRequest::~CLaunchRequest()
    {
    delete iCID;
    delete iSAP;
    delete iUserId;
    } //lint !e1540 iFields freed in Destroy

void CLaunchRequest::Destroy()
    {
    iLink.Deque();
    delete this;
    }


const TDesC& CLaunchRequest::ApplicationId()
    {
    return *iCID;
    }

const TDesC& CLaunchRequest::Sap()
    {
    return *iSAP;
    }

const TDesC& CLaunchRequest::UserId()
    {
    return *iUserId;
    }

bool CLaunchRequest::operator==( CLaunchRequest& rhs )
    {
    if ( this->ApplicationId().Compare( rhs.ApplicationId() ) ||
         this->Sap().Compare( rhs.Sap() ) ||
         this->UserId().Compare( rhs.UserId() ) )
        {
        return true;
        }
    else
        {
        return false;
        }
    }

//  End of File