/*

* 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 <bldvariant.hrh>

#include <featmgr.h>

#include <cmmanager.h>

#include <cmmanagerext.h>

#include <cmconnectionmethod.h>

#include <cmconnectionmethodext.h>

//  CLASS HEADER

#include "wsfapplauncher.h"

//  INTERNAL INCLUDES

#include "wsfbrowserlaunchobserver.h"

#include "wsflogger.h"

#include "wsfactivewaiter.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::EPriorityLow ),

    iIapId( 0 ), 

    iWapId( 0 ),

    iLaunchState( EIdle ),

    iRestoreSelectionMode( EFalse ),

    iRestoreAccessPoint( EFalse ),

    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,

                                      TUint aWapId,

                                      const TDesC& aURL )

    {

    LOG_ENTERFN( "CWsfAppLauncher::LaunchBrowserL_3" );

    Cancel();

    SetAccessPoint( aWapId );

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

    iObserver = &aObserver;  

    iIapId = aIapId;

    iWapId = aWapId;

    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" );

    // Browser uses WAP id instead of IAP id so 

    // we need to pass wap id to browser

    TUint wapId = plugin.GetIntAttributeL( CMManager::ECmWapId );

    LOG_WRITEF( "CWsfAppLauncher::LaunchBrowserL_2 -->> ECmWapId %d", wapId );

    // 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 );

        }

    if ( ApSelectionMode() !=0 )

        {

        // Set AP selection mode to user defined

        LOG_WRITE( "CWsfAppLauncher::LaunchBrowserL_2 -->> ap selection mode" );

        SetApSelectionMode( 0 );  

        iRestoreSelectionMode = ETrue;

        }

    LOG_WRITE( "CWsfAppLauncher::LaunchBrowserL_2 -->> before setAP" );

    SetAccessPoint( wapId );

    LaunchBrowserL( aObserver, aIapId, wapId, *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 %d" );

    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, iWapId );

        }

    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::ApSelectionModeL

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

//

TInt CWsfAppLauncher::ApSelectionMode()

    {

    LOG_ENTERFN( "CWsfAppLauncher::ApSelectionMode" );

    TInt currentState = 0;

    iRepository->Get( KBrowserAccessPointSelectionMode, currentState );

    return currentState;      

    }

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

// CWsfAppLauncher::SetApSelectionModeL

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

//

void CWsfAppLauncher::SetApSelectionMode( TInt aApSelectionMode  )

    {

    LOG_ENTERFN( "CWsfAppLauncher::SetApSelectionMode" );  

    // Valid values: 0 = User Defined, 1 = Always Ask, 2=Destination

    if ( !iRestoreSelectionMode )

        {

        //Store original setting

        TInt OriginalApSelectionMode = 0;

        iRepository->Get( KBrowserAccessPointSelectionMode, 

                OriginalApSelectionMode );

        iOriginalApSelectionMode = OriginalApSelectionMode;

        }

    iRepository->Set( KBrowserAccessPointSelectionMode, aApSelectionMode );  

    }

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

// CWsfAppLauncher::RestoreApSelectionMode

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

// 

void CWsfAppLauncher::RestoreApSelectionMode()

    {

    LOG_ENTERFN( "CWsfAppLauncher::RestoreApSelectionMode" ); 

    if ( iRestoreSelectionMode )

        {

        SetApSelectionMode( iOriginalApSelectionMode );       

        iRestoreSelectionMode = EFalse;

        } 

    }

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

// CWsfAppLauncher::SetAccessPoint

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

//

void CWsfAppLauncher::SetAccessPoint( TUint aAccessPointId )

    {

    LOG_ENTERFN( "CWsfAppLauncher::SetAccessPoint" );

    LOG_WRITEF( "aAccessPointId %d", aAccessPointId );

    CRepository* repository( iRepository );

    TUint defaultAccessPointUid = KBrowserDefaultAccessPoint;

    if ( !iRestoreAccessPoint )

        {

        // Store Access point so it can be restored after the launch

        TInt id( 0 );

        TInt err = repository->Get( defaultAccessPointUid, id );       

        if ( err != KErrNotFound )

            {            

            iOriginalApId = (TUint)id; 

            iRestoreAccessPoint = ETrue;

            }

        }

    repository->Set( defaultAccessPointUid, (TInt)aAccessPointId );  

    repository = NULL;

    }

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

// CWsfAppLauncher::RestoreAccessPoint

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

// 

void CWsfAppLauncher::RestoreAccessPoint()

    {

    LOG_ENTERFN( "CWsfAppLauncher::RestoreAccessPoint" ); 

    if ( iRestoreAccessPoint )

        {

        SetAccessPoint( iOriginalApId );       

        iRestoreAccessPoint = EFalse;

        } 

    }

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

// CWsfAppLauncher::DoCancel

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