/*

* 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:  Implementation of the CVCommandRunnable class

*

*/

#include <vcommandapi.h>

#include "rubydebug.h"

#include <apaid.h>

#include <apgcli.h>

#include <apacmdln.h>

#include <apgtask.h>

#include <eikappui.h>

/**

* The version of the streamed data protocol

* It is rather likely, that the format of the data streamed changes in the future.

* Using the protocol version, the code can check if it knows how to parse the 

* input stream

*/

const TInt32 KVCRunnableProtocolVersion = 2;

/**

* @leave KErrOverflow if aArguments is longer, than KMaxVCArgumentLength

* @leave KErrArgument if aAppUid is KNullUidValue

*/

EXPORT_C CVCRunnable* CVCRunnable::NewL( TUid aAppUid, const TDesC8& aArguments )

    {

    CVCRunnable* self = new ( ELeave ) CVCRunnable;

    CleanupStack::PushL( self );

    self->ConstructL( aAppUid, aArguments );

    CleanupStack::Pop( self );

    return self;

    }

/**

* Factory function

* @param aExeName Exe-file to start. Can be full or partical name according to 

*        the RProcess::Create rules. Cannot be KNullDesC

* @param aArguments Command line to pass to the application. This object makes

*        a copy of the passed string

* @leave KErrOverflow if aArguments is longer, than KMaxVCArgumentLength or 

*		 aExeName is longer, than KMaxOsName

* @leave KErrUndeflow if aExeName is empty

*/

EXPORT_C CVCRunnable* CVCRunnable::NewL( const TDesC& aExeName, const TDesC8& aArguments )

	{

	CVCRunnable* self = new( ELeave ) CVCRunnable;

	CleanupStack::PushL( self );

	self->ConstructL( aExeName, aArguments);

	CleanupStack::Pop( self );

	return self;

	}

/**

* Copy the existing CVRunnable

*/

EXPORT_C CVCRunnable* CVCRunnable::NewL( const CVCRunnable& aOriginal )

	{

	CVCRunnable* self = new (ELeave) CVCRunnable;

	CleanupStack::PushL( self );

	if( aOriginal.Uid() == KNullUid ) 

		{

		self->ConstructL( aOriginal.ExeName(), aOriginal.Arguments() );

		}

	else 

		{

		self->ConstructL( aOriginal.Uid(), aOriginal.Arguments() );

		}

	CleanupStack::Pop( self );

	return self;

	}

/** 

* Internalizes from stream 

* values are read in the same order as ExternalizeL wrote them

*/

EXPORT_C CVCRunnable* CVCRunnable::NewL( RReadStream &aStream )

    {

    CVCRunnable* self = new (ELeave) CVCRunnable;

    CleanupStack::PushL( self );

    self->ConstructL( aStream );

    CleanupStack::Pop( self );

    return self;    

    }

void CVCRunnable::ConstructL( RReadStream &aStream )

	{

	TInt32 ver;

    aStream >> ver;

    __ASSERT_ALWAYS( ver == KVCRunnableProtocolVersion, User::Leave( KErrNotSupported  ) );

    iExeUid = TUid::Uid( aStream.ReadInt32L() );

    iArguments = HBufC8::NewL( aStream.ReadInt32L() );

    TPtr8 pArguments = iArguments->Des();

    aStream >> pArguments;

    TInt exeNameLength = aStream.ReadInt32L();

    if( exeNameLength > 0 )

    	{

    	iExeName = HBufC::NewL( exeNameLength );

    	TPtr pExeName = iExeName->Des();

	    aStream >> pExeName;

    	}

	}

void CVCRunnable::ConstructL( TUid aAppUid, const TDesC8& aArguments )

    {

    __ASSERT_ALWAYS( aArguments.Length() <= KMaxVCArgumentLength, User::Leave( KErrOverflow) );

    __ASSERT_ALWAYS( aAppUid != KNullUid, User::Leave( KErrArgument ) );

    iExeUid = TUid::Uid( aAppUid.iUid );

    iArguments = HBufC8::NewL( aArguments.Length() );

    *iArguments = aArguments;

    }

void CVCRunnable::ConstructL( const TDesC& aExeName, const TDesC8& aArguments )

    {

    __ASSERT_ALWAYS( aArguments.Length() <= KMaxVCArgumentLength, User::Leave( KErrOverflow) );

    __ASSERT_ALWAYS( aExeName.Length() <= KMaxFileName, User::Leave( KErrOverflow ) );

    __ASSERT_ALWAYS( aExeName.Length() > 0, User::Leave( KErrUnderflow ) );

    iExeName = HBufC::NewL( aExeName.Length() );

    *iExeName = aExeName;

    iArguments = HBufC8::NewL( aArguments.Length() );

    *iArguments = aArguments;

    }

EXPORT_C CVCRunnable::~CVCRunnable()

    {

    delete iExeName;

    delete iArguments;

    }

/** 

 * Saves the object to stream.

 * The current format is as follows:

 * <protocol version: int32><uid: int32; KNullUidValue if no><argument length: int32>

 * <argument descriptor streamed by the default descriptor ExternalizeL>

 * <exe filename length><exe filename descriptor only if filename length is not 0>

 */

EXPORT_C void CVCRunnable::ExternalizeL( RWriteStream &aStream ) const

    {

    aStream << KVCRunnableProtocolVersion;

    aStream << iExeUid.iUid;

    aStream << static_cast<TInt32>( iArguments->Length() );

    aStream << *iArguments;

    if( iExeName )

    	{

    	aStream << static_cast<TInt32>( iExeName->Length() );

    	aStream << *iExeName;

    	}

    else 

    	{

    	aStream << static_cast<TInt32>( 0 );

    	}

    }

EXPORT_C TBool CVCRunnable::operator==( const CVCRunnable& aRunnable ) const

    {

    return ( 

            ( Uid() == aRunnable.Uid()) && 

            ( Arguments() == aRunnable.Arguments() ) &&

            ( ExeName() == aRunnable.ExeName() )

           );

    }

/**

* @return The uid of the application to be started

*/

EXPORT_C const TUid CVCRunnable::Uid() const

    {

    return iExeUid;

    }

/**

* @return The filename of the application to be started. KNullDesC if there is none

*/

EXPORT_C const TDesC& CVCRunnable::ExeName() const

	{

	if( iExeName )

		{

		return *iExeName;

		}

	else 

		{

		return KNullDesC;

		}

	}

/**

* The arguments to be passed to the application

*/

EXPORT_C const TDesC8& CVCRunnable::Arguments() const

    {

    return *iArguments;

    }

/** 

* Run the command. In case of aAppUid specified during the construction

* application is started via the RApaLsSession::StartApp, otherwise

* via the RProcess::Create

* @leave System-wide error code. In particular KErrNotFound if there is

*        no such app in the system

*/

EXPORT_C void CVCRunnable::ExecuteL() const

	{

	RUBY_DEBUG_BLOCK( "CVCRunnable::ExecuteL" );

	if( iExeName ) 

		{

		RProcess process;

		CleanupClosePushL( process );

		// Convert arguments into system_number_of_bits-bit descriptor 

		// (needed for exe, not needed for GUI apps)

		HBufC* arguments = HBufC::NewLC( iArguments->Length() );

		arguments->Des().Copy( *iArguments );

		User::LeaveIfError( process.Create( *iExeName, *arguments) );

		process.Resume();

		CleanupStack::PopAndDestroy( arguments );

		CleanupStack::PopAndDestroy( &process );

		}

	else 

		{

        const TUid KLogsUID3 = { 270486741 };//101F4CD5

        //In case logs.exe run in background [EDCN-84B68Q]

        //todo: General support for this kind of case,

		//      eg, add "view" keyworkd in defaultvoicecommands.xml...

        if ( iExeUid == KLogsUID3 )

            {

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

            TApaTask task = taskList.FindApp( iExeUid );

            if( task.Exists() ) //Logs already open. Request it to

                {               //activate the correct view

                task.SendMessage( iExeUid, *iArguments );

                return;

                }

            }

		TApaAppInfo appInfo;

		RApaLsSession apaLsSession;

		CleanupClosePushL( apaLsSession );

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

		User::LeaveIfError( apaLsSession.GetAppInfo( appInfo, iExeUid ) );

		CApaCommandLine* apaCommandLine = CApaCommandLine::NewLC();

		apaCommandLine->SetExecutableNameL( appInfo.iFullName );

        apaCommandLine->SetTailEndL( *iArguments );

        User::LeaveIfError( apaLsSession.StartApp( *apaCommandLine ) );

		CleanupStack::PopAndDestroy( apaCommandLine );

		CleanupStack::PopAndDestroy( &apaLsSession );

		}

	}

//End of file