/*

* Copyright (c) 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:  App for Action handler

 *

*/

#include <apgcli.h>

#include <apacmdln.h>

#include <apgtask.h>

#include <vwsdef.h>

#include <eikenv.h>

#include <eikappui.h>

#include <liwvariant.h>

#include "ahproperties.hrh"

#include "ahpapplauncher.h"

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

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

// Symbian 2nd phase constructor can leave.

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

//

void CAHAppLauncher::ConstructL()

    {

    iEnv = CEikonEnv::Static( );

    }

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

// Two-phased constructor.

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

//

CAHAppLauncher* CAHAppLauncher::NewL()

    {

    CAHAppLauncher* self = CAHAppLauncher::NewLC( );

    CleanupStack::Pop( self );

    return self;

    }

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

// Two-phased constructor.

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

//

CAHAppLauncher* CAHAppLauncher::NewLC()

    {

    CAHAppLauncher* self = new( ELeave ) CAHAppLauncher;

    CleanupStack::PushL( self );

    self->ConstructL( );

    return self;

    }

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

// destructor

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

CAHAppLauncher::~CAHAppLauncher()

    {

    }

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

// Executes provided action

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

//

TInt CAHAppLauncher::ExecuteTypeLaunchL( const CLiwMap* aMap )

    {

    TInt errCode(KErrArgument);

    RBuf launchMethod;

    CleanupClosePushL( launchMethod );

    if ( !ExtractDesL( aMap, launchMethod, KLaunchMethod ) )

        {

        if ( !launchMethod.CompareF( KLaunchMethodValueCmdLine ) )

            {

            errCode = ExecuteCommmandLineL( aMap );

            }

        else if ( !launchMethod.CompareF( KLaunchMethodValueMessageWithDoc )

                || !launchMethod.CompareF( KLaunchMethodValueMessageWithTail ) )

            {

            errCode = ExecuteApaMessageL( aMap );

            }

        }

    CleanupStack::PopAndDestroy( &launchMethod );       

    return errCode;

    }

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

// Executes provided command line action

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

//

TInt CAHAppLauncher::ExecuteCommmandLineL( const CLiwMap* aMap )

    {

    TInt errCode(KErrArgument);

    TUid appUid= TUid::Null( );

    if ( !ExtractUidL( aMap, appUid, KApplicationUid ) )

        {

        TApaTaskList taskList( iEnv->WsSession() );       

        TApaTask task = taskList.FindApp( appUid );

        if ( task.Exists( ) )

            {

            errCode = KErrNone;

            task.BringToForeground();

            }

        else

            {

            // app not yet running

            RApaLsSession appSession;

            CleanupClosePushL( appSession );

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

            CApaCommandLine* cmd = CApaCommandLine::NewLC( );

            cmd->SetCommandL( GetCommandL( aMap ) );

            RBuf documentNameValue;

            CleanupClosePushL( documentNameValue );

            if( !ExtractDesL( aMap, documentNameValue, KDocumentName ) )

                {

                cmd->SetDocumentNameL( documentNameValue );

                }

            TApaAppInfo appInfo;

            appSession.GetAppInfo( appInfo, appUid );

            cmd->SetExecutableNameL( appInfo.iFullName );

            errCode = appSession.StartApp( *cmd );

            CleanupStack::PopAndDestroy( &documentNameValue );

            CleanupStack::PopAndDestroy( cmd );

            CleanupStack::PopAndDestroy( &appSession );

            }

        }

    return errCode;

    }

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

// Executes provided apa message action

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

// 

TInt CAHAppLauncher::ExecuteApaMessageL( const CLiwMap* aMap )

    {

    TInt errCode(KErrArgument);

    TUid appUid= TUid::Null( );

    if ( !ExtractUidL( aMap, appUid, KApplicationUid ) )

        {

        TApaTaskList taskList( iEnv->WsSession() );       

        TApaTask task = taskList.FindApp( appUid );

        if ( task.Exists( ) )

            {

            TUid messageUid= TUid::Null( );

            RBuf8 additionalData;

            CleanupClosePushL( additionalData );

            if ( !ExtractUidL( aMap, messageUid, KMessageUid )

                    && !ExtractDes8L( aMap, additionalData, KAdditionalData ) )

                {

                errCode = task.SendMessage( messageUid, additionalData );

                }

            CleanupStack::PopAndDestroy( &additionalData );    

            }

        else

            { // app not yet running

            RBuf launchMethod;

            CleanupClosePushL( launchMethod );

            if ( !ExtractDesL( aMap, launchMethod, KLaunchMethod ) )

                {

                if ( !launchMethod.CompareF( KLaunchMethodValueMessageWithDoc ) )

                    {

                    errCode = StartDocumentL( aMap ) ;

                    }

                else if ( !launchMethod.CompareF( KLaunchMethodValueMessageWithTail ) )

                    {

                    errCode = StartAppL( aMap );

                    }

                }

            CleanupStack::PopAndDestroy( &launchMethod );     

            }

        }

    return errCode;

    }

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

// Start document

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

// 

TInt CAHAppLauncher::StartDocumentL( const CLiwMap* aMap )

    {

    TInt errCode(KErrArgument);

    TUid appUid= TUid::Null( );

    RBuf documentNameValue;

    CleanupClosePushL( documentNameValue );

    if ( !ExtractUidL( aMap, appUid, KApplicationUid ) 

        && !ExtractDesL( aMap, documentNameValue, KDocumentName ) )

        {

        RApaLsSession appArcSession;

        CleanupClosePushL( appArcSession );

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

        TThreadId id;

        errCode = appArcSession.StartDocument( documentNameValue, appUid, id );

        CleanupStack::PopAndDestroy( &appArcSession );

        }

    CleanupStack::PopAndDestroy( &documentNameValue );

    return errCode;

    }

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

// Starts application

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

// 

TInt CAHAppLauncher::StartAppL( const CLiwMap* aMap )

    {

    TInt errCode(KErrArgument);

    TUid appUid= TUid::Null( );

    RBuf8 additionalData;

    CleanupClosePushL( additionalData );

    if ( !ExtractUidL( aMap, appUid, KApplicationUid )

        && !ExtractDes8L( aMap, additionalData, KAdditionalData ) )

        {

        RApaLsSession appArcSession;

        CleanupClosePushL( appArcSession );

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

        TApaAppInfo appInfo;

        errCode = appArcSession.GetAppInfo( appInfo, appUid );

        if ( errCode == KErrNone )

            {

            CApaCommandLine* cmdLine = CApaCommandLine::NewLC( );

            cmdLine->SetExecutableNameL( appInfo.iFullName );

            cmdLine->SetCommandL( EApaCommandRun );

            cmdLine->SetTailEndL( additionalData );

            errCode = appArcSession.StartApp( *cmdLine );

            CleanupStack::PopAndDestroy( cmdLine );

            }

        CleanupStack::PopAndDestroy( &appArcSession );

        }

    CleanupStack::PopAndDestroy( &additionalData );

    return errCode;

    }

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

// Executes provided action - activate view

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

//

TInt CAHAppLauncher::ExecuteActivateViewL( const CLiwMap* aMap )

    {

    TInt errCode(KErrGeneral);

    if ( iEnv )

        {

        CCoeAppUi* appui = iEnv-> EikAppUi( );

        if ( appui )

            {

            TUid messageUid= TUid::Null( );

            TVwsViewId viewId;

            if ( !ExtractViewIdL( aMap, viewId ) )

                {

                RBuf8 additionalData;

                CleanupClosePushL( additionalData );

                if ( !ExtractUidL( aMap, messageUid, KMessageUid )

                    && !ExtractDes8L( aMap, additionalData, KAdditionalData ) )

                    {

                    appui->ActivateViewL( viewId, messageUid, additionalData );

                    }

                else

                    {

                    appui->ActivateViewL( viewId );

                    }

                errCode = KErrNone;

                CleanupStack::PopAndDestroy( &additionalData );

                }

            }

        }

    return errCode;

    }

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

// Executes provided action

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

//

TInt CAHAppLauncher::ExecuteActionL( const CLiwMap* aMap )

    {

    TInt errCode(KErrNotFound);

    RBuf type;

    CleanupClosePushL( type );

    errCode = ExtractDesL( aMap, type, KType );

    if ( errCode == KErrNone )

        {

        if ( !type.CompareF( KActionValueLaunchApplication ) )

            {

            errCode = ExecuteTypeLaunchL( aMap );

            }

        else if ( !type.CompareF( KActionValueViewActivation ) )

            {

            errCode = ExecuteActivateViewL( aMap );

            }

        }

    CleanupStack::PopAndDestroy( &type );

    return errCode;

    }

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

// 

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

//

TInt CAHAppLauncher::ExtractDesL( const CLiwMap* aMap,

    RBuf& aString, const TDesC8& aMapName )

    {

    TInt errCode(KErrNotFound);

    TLiwVariant variant;

    variant.PushL( );

    TPtrC tempString( KNullDesC );

    if ( aMap->FindL( aMapName, variant ) )

        {

        variant.Get( tempString );

        aString.ReAllocL( tempString.Length( ) );

        aString.Append( tempString );

        errCode = KErrNone;

        }

    CleanupStack::PopAndDestroy( &variant );    

    return errCode;

    }

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

// 

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

//

TInt CAHAppLauncher::ExtractDes8L( const CLiwMap* aMap,

    RBuf8& aString, const TDesC8& aMapName )

    {

    TInt errCode(KErrNotFound);

    TLiwVariant variant;

    variant.PushL( );

    TPtrC8 tempString( KNullDesC8 );

    if ( aMap->FindL( aMapName, variant ) )

        {

        variant.Get( tempString );

        aString.ReAllocL( tempString.Length( ) );

        aString.Append( tempString );

        errCode = KErrNone;

        }

    CleanupStack::PopAndDestroy( &variant );    

    return errCode;

    }    

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

// 

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

//

TInt CAHAppLauncher::ExtractUidL( const CLiwMap* aMap, TUid& aUid,

    const TDesC8& aMapName )

    {

    TInt errCode(KErrNotFound);

    TInt32 temp;

    TLiwVariant variant;

    variant.PushL( );

    if ( aMap->FindL( aMapName, variant ) )

        {

        variant.Get( temp );

        aUid = TUid::Uid( temp );

        errCode = KErrNone;

        }

    CleanupStack::PopAndDestroy( &variant );

    return errCode;

    }

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

// 

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

//

TInt CAHAppLauncher::ExtractViewIdL( const CLiwMap* aMap, TVwsViewId& aViewId )

    {

    TInt errCode(KErrNotFound);

    TLiwVariant variant;

    if ( aMap->FindL( KViewId, variant ) )

        {

        variant.Get( aViewId.iViewUid.iUid );

        variant.Reset( );

        if ( aMap->FindL( KViewAppUid, variant ) )

            {

            variant.Get( aViewId.iAppUid.iUid );

            variant.Reset( );

            errCode = KErrNone;

            }

        }

    return errCode;

    }

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

// 

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

//

TApaCommand CAHAppLauncher::GetCommandL( const CLiwMap* aMap )

    {

    TApaCommand command(EApaCommandOpen);

    RBuf appCommand;

    CleanupClosePushL( appCommand );

    if ( ExtractDesL( aMap, appCommand, KApaCommand ) == KErrNone )

        {

        if( appCommand.Compare( KApaCommandBackground ) == KErrNone )

            {

            command = EApaCommandBackground;

            }

        }

    CleanupStack::PopAndDestroy( &appCommand );

    return command;

    }

// End of file