/*

* Copyright (c) 2009 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: 

*

*/

#include <W32STD.H>

#include <e32property.h>

#include <cadef.h>

#include <badesca.h>

#include <apgtask.h>

#include <AknTaskList.h>

#include <apgcli.h>

#include <APACMDLN.h>

#include <EIKENV.h>

#include "cadef.h"

#include "castorageproxy.h"

#include "cainnerentry.h"

#include "cainnerquery.h"

#include "caarraycleanup.inl"

#include "casrvplugin.h"

#include "waitactive.h"

#include "carunningappmonitortestutils.h"

#include "testconsts.h"

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

// CONSTRUCTION

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

//

CTestUtils* CTestUtils::NewL()

    {

    CTestUtils* self = CTestUtils::NewLC();

    CleanupStack::Pop();

    return self;

    }

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

//

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

//

CTestUtils* CTestUtils::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor (virtual by CBase)

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

//

CTestUtils::~CTestUtils()

    {

	iFileManager->Delete(KTestDbDest);

    delete iFileManager;    iFileManager = NULL;

    iFs.Close();

    }

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

// Default constructor

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

//

CTestUtils::CTestUtils()

    {

    }

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

// Second phase construct

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

//

void CTestUtils::ConstructL()

    {

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

    iFileManager = CFileMan::NewL( iFs );

    }

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

//

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

TInt CTestUtils::Copy( const TDesC& aSource, const TDesC& aDest )

    {

    return iFileManager->Copy(aSource, aDest);

    }

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

//

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

TInt CTestUtils::CopyDb()

    {

    return Copy(KTestDbSource, KTestDbDest);

    }

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

//

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

//

TInt CTestUtils::LaunchApplicationL( const TUid aUid )

    {

    RWsSession wsSession;

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

    CleanupClosePushL<RWsSession>( wsSession );

    CAknTaskList* taskList = CAknTaskList::NewL( wsSession );

    TApaTask task = taskList->FindRootApp( aUid );

    delete taskList;

    if ( task.Exists() )

        {

        task.BringToForeground();

        }

    else

        {

        TApaAppInfo appInfo;

        TApaAppCapabilityBuf capabilityBuf;

        RApaLsSession appArcSession;

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

        CleanupClosePushL<RApaLsSession>( appArcSession );

        User::LeaveIfError( appArcSession.GetAppInfo( appInfo, aUid ) );

        User::LeaveIfError( appArcSession.GetAppCapability( capabilityBuf, aUid ) );

        TApaAppCapability& caps = capabilityBuf();

        TFileName appName = appInfo.iFullName;

        CApaCommandLine* cmdLine = CApaCommandLine::NewLC();

        cmdLine->SetExecutableNameL( appName );

        if ( caps.iLaunchInBackground )

            {

            cmdLine->SetCommandL( EApaCommandBackground );

            }

        else

            {

            cmdLine->SetCommandL( EApaCommandRun );

            }

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

        CleanupStack::PopAndDestroy( cmdLine );

        CleanupStack::PopAndDestroy( &appArcSession );

        }

    CleanupStack::PopAndDestroy( &wsSession );

    //verification if app has really launched

    WaitL(2000000);

    RWsSession verWsSession;

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

    CleanupClosePushL<RWsSession>( verWsSession );

    CAknTaskList* verTaskList = CAknTaskList::NewL( verWsSession );

    TApaTask verTask = verTaskList->FindRootApp( aUid );

    delete verTaskList;

    TInt result(KErrGeneral);

    if ( verTask.Exists() )

        {

        result = KErrNone;

        }

    CleanupStack::PopAndDestroy( &verWsSession );

    return result;

    }

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

//

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

//

TInt CTestUtils::TerminateApplicationL( const TUid aUid )

    {

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

    TApaTask task = taskList.FindApp(aUid);

    if (!task.Exists()) 

        {

        return KErrNotFound; 

        }

    task.EndTask();

    WaitL(2000000);

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

    return newTaskList.FindApp(aUid).Exists() ? KErrGeneral : KErrNone;

    }

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

//

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

//

void CTestUtils::WaitL(TInt aMicroSec)

    {

    CWaitActive* wait = CWaitActive::NewL();

    wait->Wait(aMicroSec);

    delete wait;

    }

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

//

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

//

TBool CTestUtils::IsRunningL(TUid aAppUid, CCaStorageProxy& aStorage)const

    {

    TBool retVal(EFalse);

    RPointerArray<CCaInnerEntry> array;

    CleanupResetAndDestroyPushL(array);

    CCaInnerQuery* allAppQuery = CCaInnerQuery::NewLC();

    allAppQuery->SetUid(static_cast<TUint>(aAppUid.iUid));

    aStorage.GetEntriesL(allAppQuery, array);

    CleanupStack::PopAndDestroy( allAppQuery );

    if(0 >= array.Count())

        {

        User::Leave(KErrNotFound);

        }

    CCaInnerEntry* entry = array[0];

    if( entry->GetFlags() & ERunning )

        {

        RBuf value;

        CleanupClosePushL(value);

        value.CreateL(KCaMaxAttrValueLen);

        if( entry->FindAttribute(KCaAttrWindowGroupId, value) )

            {

            retVal = ETrue;

            }

        CleanupStack::PopAndDestroy(&value);

        }

    CleanupStack::PopAndDestroy(&array);

    return retVal;

    }