/*

* Copyright (c) 2007 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:  Utility class which provides the Application, Service and File

*                launching services to Location Centre.

*

*/

// SYSTEM INCLUDES

#include <apgcli.h>

#include <apgtask.h>

#include <eikenv.h>

#include <lcappexitobserver.h>

#include <e32math.h>

#include <eikappui.h>

#include <avkon.hrh>

// USER INCLUDES

#include "lcapplauncher.h"

#include "lcipcparams.h"

#include "lcdebug.h"

// CONSTANT DEFINITIONS

_LIT( KLcFourSpace, "4 " );

// Maximum value that the UID field can take in S60

const TUint32   KUidMaxValue = 0xFFFFFFFF;

// Application Server Service ID. This is the same valuw which AknAppService classes use

const TUid KLcLaunchAppServiceUid = { 0x101F887A };

// -------- Member functions of RLcLaunchAppService --------------------------

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

// TUid RLcLaunchAppService::ServiceUid

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

//

TUid RLcLaunchAppService::ServiceUid() const

    {

    return KLcLaunchAppServiceUid;

    }

// -------- Member functions of CLcLaunchAppService --------------------------

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

// CLcLaunchAppService* CLcLaunchAppService::NewL

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

//

CLcLaunchAppService* CLcLaunchAppService::NewL()

	{

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

	return self;

	}

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

// CLcLaunchAppService::~CLcLaunchAppService

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

//		

CLcLaunchAppService::~CLcLaunchAppService()

	{

    delete iMonitor;

    iService.Close();	

	}

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

// Tvoid CLcLaunchAppService::ServerName

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

//

void CLcLaunchAppService::ServerName( TName& 	aServerName,

					 				  TUid 		aAppServerUid,

					 				  TUint 	aServerDifferentiator )

	{

	_LIT(KServerNameFormat, "%08x_%08x_AppServer");

	aServerName.Format( KServerNameFormat, 

						aServerDifferentiator, 

						aAppServerUid );

	}

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

// TUid RLcLaunchAppService::ServiceUid

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

//	

TUint CLcLaunchAppService::GenerateServerDifferentiatorAndName( 

										TName& 		aServerName, 

										TUid 		aAppServerUid )

	{

	TUint r;

	FOREVER

		{

		r = Math::Random();

		if ( r == 0 )

			continue;

		ServerName( aServerName, aAppServerUid, r );

		TFindServer find( aServerName );

		TFullName fullName;

		if ( find.Next( fullName ) == KErrNone )

			{

			continue;

			}			

		break;

		}		

	return r;

	}

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

// void CLcLaunchAppService::LaunchAppL

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

//		

void CLcLaunchAppService::LaunchAppL( const TUid& 						aAppUid, 

    					   				    MAknServerAppExitObserver& 	aObserver, 

    				 				  const TDesC&               		aCmdLineArg )

	{	

	DEBUG("+ CLcLaunchAppService::LaunchAppL")

	CEikonEnv* eikEnv = CEikonEnv::Static();		

	RWindowGroup& wg = eikEnv->RootWin();

	TName notUsed;

	const TUint differentiator = GenerateServerDifferentiatorAndName( notUsed, aAppUid );

	TRequestStatus requestStatusForRendezvous;

	RApaLsSession apa;

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

	CleanupClosePushL( apa );

    // Check for the Application capabilities

    TApaAppCapabilityBuf capabilityBuf;

    User::LeaveIfError( apa.GetAppCapability( capabilityBuf, aAppUid ));

    TApaAppCapability& caps = capabilityBuf();

	// Launch only those applications can be embedded and will not be run the background

	if( caps.iLaunchInBackground || 

	    caps.iEmbeddability == TApaAppCapability::ENotEmbeddable )

		{

		User::Leave( KErrNotSupported );

		}

	TApaAppInfo info;

	User::LeaveIfError( apa.GetAppInfo( info, aAppUid ));

    // Pack the command line arguments

	CApaCommandLine* cmdLine = CApaCommandLine::NewLC();

	cmdLine->SetExecutableNameL(info.iFullName);

	cmdLine->SetServerRequiredL(differentiator);

    // Set the Command line arguments.

    if ( aCmdLineArg.Length())

        {

        // These arguments would be sent as Tail end arguments to the launched

        // Application. Its left to the application to handle those

        HBufC8* tailEnd = HBufC8::NewLC( aCmdLineArg.Length());

        tailEnd->Des().Copy( aCmdLineArg );

        // The Tail end buffer is copied to the Command line structure. Hence,

        // can delete this variable after the set operation succeeds.

        cmdLine->SetTailEndL( tailEnd->Des());

        CleanupStack::PopAndDestroy( tailEnd );

        }

	cmdLine->SetCommandL( EApaCommandRun );

	// Window chain the client with the current application

	const TInt parentWindowGroupID = wg.Identifier();

	if ( parentWindowGroupID )

		{

		cmdLine->SetParentWindowGroupID( parentWindowGroupID );

		wg.AllowProcessToCreateChildWindowGroups( aAppUid );

		}

	// Launch the requested Application

	TThreadId threadNotUsed;

	User::LeaveIfError( apa.StartApp( *cmdLine, 

								      threadNotUsed, 

								      &requestStatusForRendezvous ));

	CleanupStack::PopAndDestroy(2, &apa);	// cmdLine and apa	

	CEikAppUi* appUi = eikEnv->EikAppUi();

	if ( appUi )

		{

		appUi->DeactivateActiveViewL();

		}

	User::WaitForRequest( requestStatusForRendezvous );

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

	// Establish a connection to the running server

	TName serverName;

	ServerName( serverName, aAppUid, differentiator );

	// Though the server had been successfully created the application

	// has can shutdown before we can establish a connection. There is nothing

	// that we can do here. Ignore the error.	

	iService.ConnectExistingByNameL(serverName );

	// Set the observer for receiving notifications of the application exit.

    iMonitor = CApaServerAppExitMonitor::NewL( iService, 

    										   aObserver,

    										   CActive::EPriorityStandard );

    DEBUG("- CLcLaunchAppService::LaunchAppL")    										   

	}

// ----- Member funtions for CLcAppLauncher ----------------------------------

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

// CLcAppLauncher::CLcAppLauncher

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

//

CLcAppLauncher::CLcAppLauncher()

    {

    // C++ Default constructor. No allocations or functions which can Leave

    // should be called from here.

    }

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

// CLcAppLauncher::~CLcAppLauncher

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

//

CLcAppLauncher::~CLcAppLauncher()

    {

	// Delete the Broswer launcher.

	delete iBrowserLauncher;

	// Delete the document handler.

	delete iDocHandler;

	// Delete the Application Service if it exists

	delete iAppService;    	

    }

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

// CLcAppLauncher* CLcAppLauncher::NewL

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

//

EXPORT_C CLcAppLauncher* CLcAppLauncher::NewL()

    {

    CLcAppLauncher* self = NewLC();

    CleanupStack::Pop( self );

    return self;         

    }

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

// CLcAppLauncher* CLcAppLauncher::NewLC

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

//

EXPORT_C CLcAppLauncher* CLcAppLauncher::NewLC()

    {

    // Symbian Two phased constructor. Leaves the object on the Clean-up

    // stack.

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;         

    }

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

// void CLcAppLauncher::ConstructL

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

//

void CLcAppLauncher::ConstructL()

    {

    // Second phase of the two phase constructor.    

    iEnv = CEikonEnv::Static();

    }

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

// void LcAppLauncher::LaunchLocationApplicationL

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

//

EXPORT_C void CLcAppLauncher::LaunchLocationApplicationL(

                                TInt                 	aAppType,

                          const TDesC&                  aIdentifer,

                                TBool                   aStandAlone,

                          const TDesC&                  aCmdLineArg,

                                MLcAppExitObserver*     aExitObserver )

    {  

    DEBUG("+ CLcLaunchAppService::LaunchLocationApplicationL")

    // Check for the validity of the request

    // Check if there is an outstanding Embedded launch request

    if(( isEmbeddedLaunchOutstanding && !aStandAlone ) ||

       ( !aStandAlone && !iEnv ))

    	{

        User::Leave( KErrNotSupported );    	

    	}

    // At any instant of time this class can one outstanding Exit observer.

    // There is currently no provision of storing a list of observers and

    // mapping them correspondingly to each of the assciated applications

    // Hence, Leave if there exists an Exit observer.

    if (( aExitObserver && iExitObserver ))

        {

        User::Leave( KErrAlreadyExists );

        }

    // Launch the Applications based on their type and Mode of launching

    switch ( aAppType )

        {

        case ELcNativeApplication:

            {

            // Since the request is for a Native S60 application, the Identifer

            // contains an UID. Obtain it using Lexer

            TLex lexer( aIdentifer );

            TUint32 uidValue;

            User::LeaveIfError( lexer.BoundedVal( uidValue, EHex, KUidMaxValue ));

            if ( aStandAlone )

            	{

	            // Launch the Location based Application based standalone mode

	            LaunchAppL( TUid::Uid( uidValue ), aCmdLineArg );   	

            	}

			else

				{

				// Launch Application in the chained mode

				LaunchAppAsChainedL( TUid::Uid( uidValue ), aCmdLineArg, aExitObserver );

				}

            break;

            }

        case ELcWebUrl:

            {

            LaunchWebBroserL( aIdentifer, aStandAlone, aExitObserver );

            break;

            }

        case ELcDocument:

            {

            LaunchContentL( aIdentifer, aStandAlone, aExitObserver );

            break;

            }

        default:

            {

            User::Leave( KErrNotSupported );

            break;

            }

        }

    DEBUG("+ CLcLaunchAppService::LaunchLocationApplicationL")        

    }

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

// void LcAppLauncher::LaunchAppL

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

//

void CLcAppLauncher::LaunchAppL(

                                TUid                    aApplicationUid,

                          const TDesC&                  aCmdLineArg )

    {  

    DEBUG("+ CLcAppLauncher::LaunchAppL")

    // Create the Session handle and connect to the Application architecture

    // server. This is required to obtain the details of the application from

    // the Application UID.

    RApaLsSession lsSession;

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

    CleanupClosePushL( lsSession );

    // Get the Application's capability.

    TApaAppCapabilityBuf capabilityBuf;

    User::LeaveIfError( lsSession.GetAppCapability( capabilityBuf, aApplicationUid ));

    TApaAppCapability& caps = capabilityBuf();

	if ( caps.iEmbeddability == TApaAppCapability::EEmbeddableOnly ||

	     caps.iEmbeddability == TApaAppCapability::EEmbeddableUiNotStandAlone )

	    {

	    User::Leave( KErrNotSupported );

	    }

    // Get the Application Information.

    TApaAppInfo appInfo;    

    User::LeaveIfError( lsSession.GetAppInfo( appInfo, aApplicationUid ) );

    // Fill the command line argument structure

    CApaCommandLine* cmdLine = CApaCommandLine::NewLC();

    // Set the Application name.    

    TFileName appName = appInfo.iFullName;

    cmdLine->SetExecutableNameL( appName );

    // Set the Command

    if ( caps.iLaunchInBackground )

        {

        cmdLine->SetCommandL( EApaCommandBackground );

        }

    else

        {

        cmdLine->SetCommandL( EApaCommandRun );

        }

    // Set the Command line arguments.

    if ( aCmdLineArg.Length())

        {

        // These arguments would be sent as Tail end arguments to the launched

        // Application. Its left to the application to handle those

        HBufC8* tailEnd = HBufC8::NewLC( aCmdLineArg.Length());

        tailEnd->Des().Copy( aCmdLineArg );

        // The Tail end buffer is copied to the Command line structure. Hence,

        // can delete this variable after the set operation succeeds.

        cmdLine->SetTailEndL( tailEnd->Des());

        CleanupStack::PopAndDestroy( tailEnd );

        }

	// Start the Application

	User::LeaveIfError( lsSession.StartApp( *cmdLine ));

    // Clean up all the allocated heap variables.

    CleanupStack::PopAndDestroy( cmdLine );

    CleanupStack::PopAndDestroy(); //lsSession 		         

    DEBUG("- CLcAppLauncher::LaunchAppL")

    }

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

// void LcAppLauncher::LaunchAppAsChainedL

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

//

void CLcAppLauncher::LaunchAppAsChainedL( 	  

							  TUid                    aApplicationUid,                               

                 		const TDesC&                  aCmdLineArg,

                 			  MLcAppExitObserver*     aExitObserver )

	{

	DEBUG("+ CLcAppLauncher::LaunchAppAsChainedL" )

	// Createt the App service object and launch the application

	CLcLaunchAppService* appService = CLcLaunchAppService::NewL();

	CleanupStack::PushL( appService );

	appService->LaunchAppL( aApplicationUid, *this, aCmdLineArg );

	CleanupStack::Pop( appService );

	// Transfer the ownership to this class.

	iAppService = appService;	

	isEmbeddedLaunchOutstanding = ETrue;

	// Store the Observer for future reference

	iExitObserver = aExitObserver;

	DEBUG("- CLcAppLauncher::LaunchAppAsChainedL" )	

	}

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

// void LcAppLauncher::LaunchWebBroserL

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

// 

void CLcAppLauncher::LaunchWebBroserL( const TDesC&              aUrl,

                                             TBool               aStandAlone,

                                             MLcAppExitObserver* aObserver )

    {

    // The parameters need to be packed in the order specified by the browser.

    // Parameters are separated by space

    // 1st parameter: Type of the second parameter. In this case 4 to indicate

    //                that the second parameter is a URL.

    // 2nd parameter: URL that needs to be launched in the browser.

    // Since we have to pack "4 " before the URL name, the total length of

    // the parameter string should be Length of the URL + 2.

    HBufC* param = HBufC::NewLC(( 2 + aUrl.Length()));

    param->Des().Append( KLcFourSpace );

    param->Des().Append( aUrl );

    if ( aStandAlone )

        {

        // The URL is launched in the Browser. Set the Browser UID as the UID

        // of the application which needs to be launched.

        const TInt KBrowserUid = 0x10008D39;

        TUid id( TUid::Uid( KBrowserUid ) );

        // Check if the Browser application is already running. Incase its

        // running Open this URL in the browser.

        TApaTaskList taskList( CEikonEnv::Static()->WsSession() );

        TApaTask task = taskList.FindApp( id );

        if ( task.Exists() )

            {

            // The browser is running. Launch the URL.

            HBufC8* param8 = HBufC8::NewLC( param->Length() );

            param8->Des().Append( *param );

            task.SendMessage( TUid::Uid( 0 ), *param8 ); // UID is not used

            CleanupStack::PopAndDestroy();

            }

        else 

            {

            // The browser is not running. Start the browser application with

            // the specified parameter. This is done by launching the browser with

            // a document name as the URL.

            RApaLsSession appArcSession;

            // Connect to the Application architecture server.

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

            CleanupClosePushL( appArcSession );

            TThreadId id;

            // Start the browser with the URL

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

                                                             TUid::Uid( KBrowserUid ),

                                                             id ));

            CleanupStack::PopAndDestroy( &appArcSession );

            }        

        }

    else

        {

        if ( !iBrowserLauncher )

            {

            // Create the Browser instance    

            iBrowserLauncher = CSchemeHandler::NewL( aUrl );

            }

        // Launch the Web URL in a browser in the Embedded mode.

        iBrowserLauncher->HandleUrlEmbeddedL();