/*

* 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:  This class offers AIW services

*

*/

#include <e32std.h>

#include <ecom/implementationproxy.h>

#include <w32std.h>

#include <apgtask.h>

#include <apgcli.h>

#include <apgwgnam.h>

#include <apacmdln.h>

#include <centralrepository.h>

#include "FileManagerDebug.h"

#include "FileManagerPrivateCRKeys.h"

#include "filemanageraiwprovider.h"

#include "FileManagerUID.h"

const TImplementationProxy ImplementationTable[] =

    {

    IMPLEMENTATION_PROXY_ENTRY( 0x200110F9, CFileManagerAiwProvider::NewL )

    };

const TUid KUidDefaultFileManager = { KFileManagerUID3 };

const TInt KMaxSortMethodStr = 20;

_LIT( KRootMatch, "?:\\" );

// ======== LOCAL FUNCTIONS ========

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

// FindStandaloneAppL

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

//

static TBool FindStandaloneAppL(

        RWsSession& aWs, const TUid& aUid, TInt& aWgId )

    {

    FUNC_LOG;

    aWgId = 0; // Used window group id is always greater than zero

    RArray< RWsSession::TWindowGroupChainInfo > windowChain;

    User::LeaveIfError( aWs.WindowGroupList( &windowChain ) );

    CleanupClosePushL( windowChain );

    TInt count( windowChain.Count() );

    for( TInt i( 0 ); i < count; ++i )

        {

        const RWsSession::TWindowGroupChainInfo& entry( windowChain[ i ] );

        CApaWindowGroupName* app = CApaWindowGroupName::NewLC(

            aWs, entry.iId );

        TUid appUid( app->AppUid() );

        CleanupStack::PopAndDestroy( app );

        // Match the app's UID and the embedded status.

        // The app is standalone when there is no parent window group.

        if ( appUid == aUid && entry.iParentId <= 0 )

            {

            // Standalone application found

            aWgId = entry.iId;

            break;

            }

        }

    CleanupStack::PopAndDestroy( &windowChain );

    return aWgId > 0;

    }

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

// IsValidFolderToOpenPath

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

//

static TBool IsValidFolderToOpenPath( const TDesC& aFullPath )

    {

    FUNC_LOG;

    TInt len( aFullPath.Length() );

    if ( !len )

        {

        return ETrue; // Allow empty to open main view

        }

    // Check that at least root folder exists

    if ( aFullPath.Left( KRootMatch().Length() ).MatchF(

            KRootMatch ) == KErrNotFound )

        {

        return EFalse;

        }

    return ETrue;

    }

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

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

// CFileManagerAiwProvider::CFileManagerAiwProvider

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

//

CFileManagerAiwProvider::CFileManagerAiwProvider()

    {

    FUNC_LOG;

    }

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

// CFileManagerAiwProvider::NewL

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

//

CFileManagerAiwProvider* CFileManagerAiwProvider::NewL()

    {

    FUNC_LOG;

    return new ( ELeave ) CFileManagerAiwProvider();

    }

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

// CFileManagerAiwProvider::~CFileManagerAiwProvider

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

//

CFileManagerAiwProvider::~CFileManagerAiwProvider()

    {

    FUNC_LOG;

    delete iService;

    delete iInParamList;

    }

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

// CFileManagerAiwProvider::InitialiseL

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

//

void CFileManagerAiwProvider::InitialiseL(

        MAiwNotifyCallback& /*aFrameworkCallback*/,

        const RCriteriaArray& /*aInterest*/ )

    {

    FUNC_LOG;

    }

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

// CFileManagerAiwProvider::HandleServiceCmdL

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

//

void CFileManagerAiwProvider::HandleServiceCmdL(

        const TInt& aCmdId,

        const CAiwGenericParamList& aInParamList,

        CAiwGenericParamList& /*aOutParamList*/,

        TUint /*aCmdOptions*/,

        const MAiwNotifyCallback* aCallback )

    {

    FUNC_LOG;

    INFO_LOG2(

        "CFileManagerAiwProvider::HandleServiceCmdL-aCmdId=%d,aCallback=0x%x",

        aCmdId, aCallback );

    TInt err( KErrNone );

    switch ( aCmdId )

        {

        case KAiwCmdEdit:

            {

            TRAP( err, CmdEditL( aInParamList, aCallback ) );

            break;

            }

        default:

            {

            ERROR_LOG1(

                "CFileManagerAiwProvider::HandleServiceCmdL-InvalidCmd=%d",

                aCmdId );

            break;

            }

        }

    LOG_IF_ERROR2(

        err,

        "CFileManagerAiwProvider::HandleServiceCmdL-aCmdId=%d-err=%d",

        aCmdId, err );

    User::LeaveIfError( err );

    }

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

// CFileManagerAiwProvider::HandleServerAppExit

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

//

void CFileManagerAiwProvider::HandleServerAppExit( TInt /*aReason*/ )

    {

    FUNC_LOG;

    TRAP_IGNORE( NotifyL( KAiwEventCompleted ) );

    iCallback = NULL; // No notifications are needed after app exit

    }

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

// CFileManagerAiwProvider::CmdEditL

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

//

void CFileManagerAiwProvider::CmdEditL(

        const CAiwGenericParamList& aInParamList,

        const MAiwNotifyCallback* aCallback )

    {

    FUNC_LOG;

    iCmd = KAiwCmdEdit;

    if ( IsFolderToOpenPathGiven( aInParamList ) )

        {

        if ( IsStandaloneLaunch( aInParamList ) )

            {

            LaunchStandaloneL( aInParamList );

            }

        else

            {

            LaunchEmbeddedL( aInParamList, aCallback );

            }

        }

    }

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

// CFileManagerAiwProvider::NotifyL

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

//

void CFileManagerAiwProvider::NotifyL( TInt aEvent )

    {

    FUNC_LOG;

    if ( iCallback && iInParamList )

        {

        CAiwGenericParamList* eventParamList = CAiwGenericParamList::NewL();

        CleanupStack::PushL( eventParamList );

        // Must cast this because of AIW design error

        const_cast< MAiwNotifyCallback* >( iCallback )->HandleNotifyL(

    	    iCmd, aEvent, *eventParamList, *iInParamList );

        CleanupStack::PopAndDestroy( eventParamList );

        }

    }

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

// CFileManagerAiwProvider::GetAppUidL

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

//

TUid CFileManagerAiwProvider::GetAppUidL()

    {

    FUNC_LOG;

    CRepository* cenRep = CRepository::NewLC( KCRUidFileManagerSettings );

    TInt uid( 0 );

    User::LeaveIfError( cenRep->Get( KFileManagerAppUidForAiwService, uid ) );

    CleanupStack::PopAndDestroy( cenRep );

    return TUid::Uid( uid );

    }

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

// CFileManagerAiwProvider::GetAppUid

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

//

TUid CFileManagerAiwProvider::GetAppUid()

    {

    FUNC_LOG;

    if ( !iAppUid.iUid )

        {

        // Read the application to start from CenRep

        TRAPD( err, iAppUid = GetAppUidL() );

        if ( err != KErrNone || !iAppUid.iUid )

            {

            // Use the default application

            iAppUid = KUidDefaultFileManager;

            }

        ERROR_LOG1(

            "CFileManagerAiwProvider::GetAppUid-Uid=0x%x", iAppUid.iUid );

        }

    return iAppUid;

    }

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

// CFileManagerAiwProvider::LaunchEmbeddedL

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

//

void CFileManagerAiwProvider::LaunchEmbeddedL(

        const CAiwGenericParamList& aInParamList,

        const MAiwNotifyCallback* aCallback )

    {

    FUNC_LOG;

    delete iService;

    iService = NULL;

    delete iInParamList;

    iInParamList = NULL;

    iCallback = NULL;

    // Copy the input params for the launcher and then do the launch

    iInParamList = CAiwGenericParamList::NewL();

    TInt count( aInParamList.Count() );

    for( TInt i( 0 ); i < count; ++i )

        {

        iInParamList->AppendL( aInParamList[ i ] );

        }

    iService = CAknLaunchAppService::NewL( GetAppUid(), this, iInParamList );

    iCallback = aCallback;

    }

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

// CFileManagerAiwProvider::IsStandaloneLaunch

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

//

TBool CFileManagerAiwProvider::IsStandaloneLaunch(

        const CAiwGenericParamList& aInParamList )

    {

    FUNC_LOG;

    TBool ret( EFalse );

    TInt i( 0 );

    // Get sort method first

    const TAiwGenericParam* param = aInParamList.FindFirst(

        i, EGenericParamDir, EVariantTypeTInt32 );

    if ( i != KErrNotFound && param )

        {

        // Then, check if standalone is requested

        param = aInParamList.FindNext( i, EGenericParamDir, EVariantTypeTInt32 );

        if ( i != KErrNotFound && param )

            {

            ret = param->Value().AsTInt32();

            }

        }

    return ret;

    }

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

// CFileManagerAiwProvider::LaunchStandaloneL

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

//

void CFileManagerAiwProvider::LaunchStandaloneL(

        const CAiwGenericParamList& aInParamList )

    {

    FUNC_LOG;

    TPtrC folderToOpen( KNullDesC );

    TInt sortMethod( KErrNotFound );

    TInt i( 0 );

    // Get folder path

    const TAiwGenericParam* param = aInParamList.FindFirst(

        i, EGenericParamDir, EVariantTypeDesC );

    if ( i != KErrNotFound && param )

        {

        folderToOpen.Set( param->Value().AsDes() );

        }

    // Get sort method

    param = aInParamList.FindFirst( i, EGenericParamDir, EVariantTypeTInt32 );

    if ( i != KErrNotFound && param )

        {

        sortMethod = param->Value().AsTInt32();

        }

    RWsSession wsSession;

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

    CleanupClosePushL( wsSession );

    TInt wgId( 0 );

    TUid appUid( GetAppUid() );

    if ( FindStandaloneAppL( wsSession, appUid, wgId ) )

        {

        // Bring the existing standalone app to foreground

        TApaTask apaTask( wsSession );

        apaTask.SetWgId( wgId );

        apaTask.BringToForeground();

        }

    else

        {

        // Start new standalone app

        TApaAppInfo appInfo;

        RApaLsSession apaLsSession;

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

        CleanupClosePushL( apaLsSession );

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

        CApaCommandLine* apaCmdLine = CApaCommandLine::NewLC();

        apaCmdLine->SetExecutableNameL( appInfo.iFullName );

        apaCmdLine->SetCommandL( EApaCommandOpen );

        apaCmdLine->SetDocumentNameL( folderToOpen );

        if ( sortMethod != KErrNotFound )

            {

            TBuf8< KMaxSortMethodStr > sortMethodStr;

            sortMethodStr.AppendNum( sortMethod );

            apaCmdLine->SetTailEndL( sortMethodStr );

            }

        TThreadId dummy;

        User::LeaveIfError( apaLsSession.StartApp( *apaCmdLine, dummy ) );

        CleanupStack::PopAndDestroy( apaCmdLine );

        CleanupStack::PopAndDestroy( &apaLsSession );

        }

    CleanupStack::PopAndDestroy( &wsSession );

    }

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

// CFileManagerAiwProvider::IsFolderToOpenPathGiven

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

//

TBool CFileManagerAiwProvider::IsFolderToOpenPathGiven(

        const CAiwGenericParamList& aInParamList )

    {

    FUNC_LOG;

    TBool ret( EFalse );

    TPtrC folderToOpen( KNullDesC );

    TInt i( 0 );

    // Ensure first that no files are defined, because only folder service

    // is offered by this provider

    const TAiwGenericParam* param = aInParamList.FindFirst(

        i, EGenericParamFile, EVariantTypeAny );

    if ( i == KErrNotFound )

        {

        // Get folder path and check it

        i = 0;

        param = aInParamList.FindFirst(

            i, EGenericParamDir, EVariantTypeDesC );

        if ( i != KErrNotFound && param )

            {

            folderToOpen.Set( param->Value().AsDes() );

            ret = IsValidFolderToOpenPath( folderToOpen );

            }

        }

    if ( !ret )

        {

        ERROR_LOG2(

            "CFileManagerAiwProvider::IsFolderToOpenPathGiven-ret=%d,given=%S",

            ret, &folderToOpen );

        }

    return ret;

    }

// ======== GLOBAL FUNCTIONS ========

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

// ImplementationGroupProxy.

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

//

EXPORT_C const TImplementationProxy* ImplementationGroupProxy( TInt& aTableCount )

    {

    FUNC_LOG;

    aTableCount = sizeof( ImplementationTable ) / sizeof( TImplementationProxy );

    return ImplementationTable;

    }