/*

* Copyright (c) 2007-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:  Implementation of CWsfAppLauncher

*

*/

//  EXTERNAL INCLUDES

#include <apgtask.h>

#include <apgcli.h>

#include <centralrepository.h>

#include <browseruisdkcrkeys.h>

#include <cmmanager.h>

#include <cmconnectionmethod.h>

//  CLASS HEADER

#include "wsfapplauncher.h"

//  INTERNAL INCLUDES

#include "wsfbrowserlaunchobserver.h"

#include "wsflogger.h"

//  LOCAL DEFINITIONS

/**

* Delay that we wait for the browser to start or terminate

*/

static const TInt KTimerTickInterval = 2 * 1000 * 1000;    

/**

* Repository key ID for the browser's homepage URL

*/

static const TUint32 KBrowserNGHomepageURL = 0x00000030;

#ifdef _DEBUG

    _LIT( KBrowserLauncherPanic, "CWsfAppLauncher" );

    #define _ASSERTD( cond ) __ASSERT_DEBUG( (cond), \

            User::Panic( KBrowserLauncherPanic, __LINE__) )

#else

    #define _ASSERTD( cond ) {}

#endif //_DEBUG

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

// CWsfAppLauncher::NewL

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

//

EXPORT_C CWsfAppLauncher* CWsfAppLauncher::NewL()

    {

    CWsfAppLauncher* self = CWsfAppLauncher::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CWsfAppLauncher::NewLC

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

//

EXPORT_C CWsfAppLauncher* CWsfAppLauncher::NewLC()

    {

    CWsfAppLauncher* self = new( ELeave ) CWsfAppLauncher();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CWsfAppLauncher::~CWsfAppLauncher

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

//

CWsfAppLauncher::~CWsfAppLauncher()

    {

    Cancel();

    delete iURL;

    delete iRepository;

    iTimer.Close();

    iWsSession.Close();     

    }

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

// CWsfAppLauncher::CWsfAppLauncher

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

//

CWsfAppLauncher::CWsfAppLauncher(): 

    CActive( CActive::EPriorityStandard ),

    iIapId( 0 ), 

    iLaunchState( EIdle ),

    iLaunchBookMarks( EFalse )

    {

    }

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

// CWsfAppLauncher::ConstructL

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

//

void CWsfAppLauncher::ConstructL()

    {

    LOG_ENTERFN( "CWsfAppLauncher::ConstructL" );

    iBrowserUid = KCRUidBrowser;

    iHomepageKey = KBrowserNGHomepageURL; 

    iBrowserStartingPageKey = KBrowserNGHomepageType;

    // Common settings for both browsers

    iRepository = CRepository::NewL( KCRUidBrowser );

    User::LeaveIfError( iWsSession.Connect() );    

    User::LeaveIfError( iTimer.CreateLocal() );

    iURL = KNullDesC().AllocL();    

    CActiveScheduler::Add( this );

    }

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

// CWsfAppLauncher::LaunchBrowserL

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

//

void CWsfAppLauncher::LaunchBrowserL( MWsfBrowserLaunchObserver& aObserver, 

                                      TUint aIapId,

                                      const TDesC& aURL )

    {

    LOG_ENTERFN( "CWsfAppLauncher::LaunchBrowserL_3" );

    Cancel();

    LOG_WRITE( "CWsfAppLauncher::LaunchBrowserL_3 -->> afer cancel" );

    iObserver = &aObserver;  

    iIapId = aIapId;

    HBufC* url = aURL.AllocL();

    delete iURL;

    iURL = url;

    iLaunchState = EIdle;    

    LOG_WRITE( "CWsfAppLauncher::LaunchBrowserL_3 -->> before set active" );

    SetActive();

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    }

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

// CWsfAppLauncher::LaunchBrowserL

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

//

void CWsfAppLauncher::LaunchBrowserL( MWsfBrowserLaunchObserver& aObserver, 

                                      TUint aIapId )

    {

    LOG_ENTERFN( "CWsfAppLauncher::LaunchBrowserL_2" );

    LOG_WRITEF( "CWsfAppLauncher::LaunchBrowserL_2 -->> iIapid %d", aIapId );

    HBufC* url = HBufC::NewLC( 

                        NCentralRepositoryConstants::KMaxUnicodeStringLength );

    TPtr urlPtr( url->Des() );

    iLaunchBookMarks = EFalse;

    RCmManager cmManager;

    cmManager.OpenL();

    LOG_WRITE( "CWsfAppLauncher::LaunchBrowserL_2 -->> cmmanager opened" );

    CleanupClosePushL( cmManager );

    RCmConnectionMethod plugin;

    CleanupClosePushL( plugin );

    LOG_WRITE( "CWsfAppLauncher::LaunchBrowserL_2 -->> cm before open" );

    LOG_WRITEF( "CWsfAppLauncher::LaunchBrowserL_2 -->> iIapid %d", aIapId );

    plugin = cmManager.ConnectionMethodL( aIapId );

    LOG_WRITE( "CWsfAppLauncher::LaunchBrowserL_2 -->> cm after open" );

    // do we have start page for Access Point?

    HBufC* apHomepage = NULL;

    apHomepage = plugin.GetStringAttributeL( CMManager::ECmStartPage );

    LOG_WRITE( "CWsfAppLauncher::LaunchBrowserL_2 -->> String Attrib got" );

    CleanupStack::PushL( apHomepage );

    if( apHomepage->Length() == 0 )

        {

        LOG_WRITE( "CWsfAppLauncher::LaunchBrowserL_2 -->> hplength = 0" );

        // if we can't have Access Point URL then

        // we try to get browser homepage URL

        TInt err = BrowserHomepage( urlPtr );   

        // if browser homepage is not defined either,

        // launch bookmarks view

        if ( err || url->Length() == 0 )

            {

            LOG_WRITE( 

                   "CWsfAppLauncher::LaunchBrowserL_2 -->> err in url length" );

            iLaunchBookMarks = ETrue;

            }

        }

    else

        {

        LOG_WRITE( "CWsfAppLauncher::LaunchBrowserL_2 -->> hplength>0" );

        url->Des().Copy( *apHomepage );

        }

    LaunchBrowserL( aObserver, aIapId, *url );

    LOG_WRITE( "CWsfAppLauncher::LaunchBrowserL_2 -->> after launch _3" );

    CleanupStack::PopAndDestroy( apHomepage );

    CleanupStack::PopAndDestroy( &plugin );

    CleanupStack::PopAndDestroy( &cmManager );

    CleanupStack::PopAndDestroy( url );

    }

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

// CWsfAppLauncher::DoLaunchBrowserL

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

//

void CWsfAppLauncher::DoLaunchBrowserL()

    {

    LOG_ENTERFN( "CWsfAppLauncher::DoLaunchBrowserL" );

    _LIT( KFormatCommand, "%d %S" );

    const TInt KBrowserFirstParamUrlFollows = 4;

    iLaunchState = EStartingUp;    

    HBufC* param = NULL; 

    if ( iLaunchBookMarks )

        {

        param = KNullDesC().AllocLC();

        }

    else

        {

        param = HBufC::NewLC( KFormatCommand().Length() + iURL->Length() );

        param->Des().Format( KFormatCommand, 

                             KBrowserFirstParamUrlFollows, iURL );

        }

    RApaLsSession appArcSession;

    User::LeaveIfError( appArcSession.Connect() ); // connect to AppArc server

    CleanupClosePushL( appArcSession );

    User::LeaveIfError( appArcSession.StartDocument( *param, iBrowserUid, 

                                                                  iThreadId ) );

    CleanupStack::PopAndDestroy( &appArcSession );

    CleanupStack::PopAndDestroy( param );

    iTimer.Cancel();

    iTimer.After( iStatus, KTimerTickInterval );

    SetActive();

    }

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

// CWsfAppLauncher::BrowserExists

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

//

TBool CWsfAppLauncher::BrowserExists()

    {

    LOG_ENTERFN( "CWsfAppLauncher::BrowserExists" );

    TApaTaskList taskList( iWsSession );            

    TApaTask startedtask = taskList.FindApp( iBrowserUid );

    return startedtask.Exists();   

    }

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

// CWsfAppLauncher::BrowserHomepage

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

//

TInt CWsfAppLauncher::BrowserHomepage( TDes& aHomePageURL )

    {

    LOG_ENTERFN( "CWsfAppLauncher::BrowserHomepage" );

    CRepository* repository( iRepository );

    // get the default starting page setting

    TInt startingPageMode( 0 );

    TInt err = repository->Get( iBrowserStartingPageKey, startingPageMode );

    if ( err == KErrNone )

        {

        switch ( startingPageMode )

            {

            case 1:

            case 2:

                {

                // user defined or current page

                 err = repository->Get( iHomepageKey, aHomePageURL );

                break;

                }

            default:

                {

                aHomePageURL.Zero();                     

                }

            }

        }

    return err;    

    }

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

// CWsfAppLauncher::KillBrowserIfAlreadyExists

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

//

TBool CWsfAppLauncher::KillBrowserIfAlreadyExists()

    {

    LOG_ENTERFN( "CWsfAppLauncher::KillBrowserIfAlreadyExists" );

    _ASSERTD( iLaunchState == EIdle);    

    _ASSERTD( !IsActive() );       

    TBool killing = EFalse;

    TApaTaskList taskList( iWsSession );

    TApaTask task = taskList.FindApp( iBrowserUid );

    if ( task.Exists() )

        {    

        // kill the browser...

        task.EndTask();

        killing = ETrue;

        iTimer.Cancel();

        iTimer.After( iStatus, KTimerTickInterval );

        }    

    else

        {

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrNone );  

        }

    SetActive();

    iLaunchState = EShuttingDown;

    return killing;

    }

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

// CWsfAppLauncher::ContinueBrowsingL

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

//

void CWsfAppLauncher::ContinueBrowsingL()

    {

    LOG_ENTERFN( "CWsfAppLauncher::ContinueBrowsingL_0" );

    //Check if the application is already running

    TBool exists = BrowserExists();

    if ( exists )

        {

        TApaTaskList taskList( iWsSession );

        TApaTask task = taskList.FindApp( iBrowserUid );

        task.BringToForeground();

        }

    else

        {

        User::Leave( KErrNotFound );    

        }       

    }

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

// CWsfAppLauncher::ContinueBrowsingL

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

//

void CWsfAppLauncher::ContinueBrowsingL( MWsfBrowserLaunchObserver& aObserver, 

                                         TUint aIapId )

    {

    LOG_ENTERFN( "CWsfAppLauncher::ContinueBrowsingL_2" );

    //Check if the application is already running

    TBool exists = BrowserExists();

    if ( exists )

        {

        TApaTaskList taskList( iWsSession );

        TApaTask task = taskList.FindApp( iBrowserUid );

        task.BringToForeground();

        }

    else    // browser not running - launch browser

        {

        LaunchBrowserL( aObserver, aIapId );

        }       

    }    

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

// CWsfAppLauncher::Launching

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

//

TWsfLaunchState CWsfAppLauncher::Launching()

    {

    LOG_ENTERFN( "CWsfAppLauncher::Launching" );

    return iLaunchState;    

    }

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

// CWsfAppLauncher::BrowserIap

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

//

TUint32 CWsfAppLauncher::BrowserIap() const

    {

    return iIapId;

    }

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

// CWsfAppLauncher::DoCancel

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

//

void CWsfAppLauncher::DoCancel()

    {

    LOG_ENTERFN( "CWsfAppLauncher::DoCancel" ); 

    iThread.LogonCancel( iStatus );

    iThread.Close();

    iTimer.Cancel();

    iLaunchState = EIdle;

    }

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

// CWsfAppLauncher::RunL

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

//

void CWsfAppLauncher::RunL()

    {

    LOG_ENTERFN( "CWsfAppLauncher::RunL" ); 

    _ASSERTD( iObserver ); 

    User::LeaveIfError( iStatus.Int() );

    switch( iLaunchState )

        {

        case EIdle: // Starting to launch

            {

            LOG_WRITE( "CWsfAppLauncher::RunL -->> EIdle" );

            KillBrowserIfAlreadyExists();  

            break;    

            }

        case EShuttingDown: // Existing browser was succesfully closed 

            {

            LOG_WRITE( "CWsfAppLauncher::RunL -->> EShuttingDown" );

            DoLaunchBrowserL();

            break;    

            }

        case EStartingUp:  // Start-up completed, check browser exists 

            {

            LOG_WRITE( "CWsfAppLauncher::RunL -->> EStartingUp" );

            TBool exists = BrowserExists();

            TInt err = exists ? KErrNone : KErrNotFound;

            iLaunchState = ECompleted;

            TRequestStatus* status = &iStatus;

            User::RequestComplete( status, err );

            SetActive();    

            break;    

            }

        case ECompleted:  //Browser exists, notify observer about completion

            {

            LOG_WRITE( "CWsfAppLauncher::RunL -->> ECompleted" );  

            iLaunchState = EFinished;

            LOG_WRITE( "CWsfAppLauncher::RunL -->> Before thread open" );

            User::LeaveIfError( iThread.Open( iThreadId, EOwnerProcess ) );

            LOG_WRITE( "CWsfAppLauncher::RunL -->> Thread opened" );

            iObserver->BrowserLaunchCompleteL(); 

            TRequestStatus* status = &iStatus;

            iThread.Logon( *status );

            SetActive();    

            break;    

            }

        case EFinished:  //Browser exists, notify observer about completion

            {

            LOG_WRITE( "CWsfAppLauncher::RunL -->> EFinished" );

            iObserver->BrowserExitL();  

            iLaunchState = EIdle;

            break;    

            }

        default:

            {

            _ASSERTD( EFalse ); 

            }

        }    

    }

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

// CWsfAppLauncher::RunError

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

//

TInt CWsfAppLauncher::RunError( TInt aError )

    {

    LOG_ENTERFN( "CWsfAppLauncher::RunError" ); 

    _ASSERTD( iObserver ); 

    switch( iLaunchState )

        {

        case EIdle:         // 

        case EShuttingDown: // Shuttind down existing browser failed

        case EStartingUp:   // Starting up new browser failed

        case ECompleted:   // Starting up new browser failed

            {   

            iObserver->BrowserLaunchFailed( aError );

            break;    

            }

        default:

            {

            _ASSERTD( EFalse ); 

            }

        }    

    iLaunchState = EIdle;

    return aError;

    }