/*

* 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:   AppMngr2 Runtime API STIF test module

*

*/

#include "appmngr2runtimeapitest.h"     // CRuntimeApiTest

#include "appmngr2testcommand.h"        // CAppMngr2TestCommand

#include <StifLogger.h>                 // CStifLogger

#include <SettingServerClient.h>        // RSettingServer

#include <ecom/ecom.h>                  // REComSession

#include <appmngr2runtime.h>            // AppMngr2 Runtime API

#include <appmngr2appinfo.h>            // AppMngr2 Runtime API

#include <appmngr2packageinfo.h>        // AppMngr2 Runtime API

#include <appmngr2recognizedfile.h>     // AppMngr2 Runtime API

#include <appmngr2driveutils.h>         // AppMngr2 Runtime API

#include <appmngr2common.hrh>           // AppMngr2 Runtime API

#include <appmngr2cleanuputils.h>       // CleanupResetAndDestroyPushL

#include <apmstd.h>                     // TDataType

#include <caf/caf.h>                    // ContentAccess

#include <bautils.h>                    // BaflUtils

#include <AknIconArray.h>               // CAknIconArray

#include <gulicon.h>                    // CGulIcon

#include <data_caging_path_literals.hrh> // KDC_APP_RESOURCE_DIR

const TInt KMaxLineLength = 256;

const TInt KGranularity = 8;

_LIT( KSWInstCommonUIResourceFileName, "SWInstCommonUI.rsc" );

_LIT( KAppMngr2UIResourceFileName, "appmngr2.rsc" );

_LIT( KAppRscFormat, "z:%S%S" );

_LIT( KAppMngr2Tag, "AppMngr2" );

_LIT( KTestStartFormat, "%S: start" );

_LIT( KTestDoneFormat, "%S: done (error %d)" );

_LIT( KResultFormat, "%S: %S, result %d" );

_LIT( KNotFoundFormat, "%S: %S not found" );

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

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

// CAppMngr2RuntimeApiTest::NewL()

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

//

CAppMngr2RuntimeApiTest* CAppMngr2RuntimeApiTest::NewL( CTestModuleIf& aTestModuleIf )

    {

    CAppMngr2RuntimeApiTest* self = new (ELeave) CAppMngr2RuntimeApiTest( aTestModuleIf );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CAppMngr2RuntimeApiTest::~CAppMngr2RuntimeApiTest()

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

//

CAppMngr2RuntimeApiTest::~CAppMngr2RuntimeApiTest()

    {

    delete iInstallCommand;

    delete iUninstallCommand;

    delete iShowDetailsCommand;

    iInstalledApps.ResetAndDestroy();

    iInstallationPackages.ResetAndDestroy();

    iPlugins.ResetAndDestroy();

    CCoeEnv* coeEnv = CCoeEnv::Static();

    if( coeEnv )

        {

        if( iSWInstCommonResourceFileOffset )

            {

            coeEnv->DeleteResourceFile( iSWInstCommonResourceFileOffset );

            }

        if( iAppMngr2ResourceFileOffset )

            {

            coeEnv->DeleteResourceFile( iAppMngr2ResourceFileOffset );

            }

        }

    delete iLog;

    iFs.Close();

    }

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

// CAppMngr2RuntimeApiTest::RunMethodL()

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

//

TInt CAppMngr2RuntimeApiTest::RunMethodL( CStifItemParser& aItem )

    {

    static TStifFunctionInfo const KFunctions[] =

        {

        ENTRY( "CheckFilesExist", CAppMngr2RuntimeApiTest::CheckFilesExistL ),

        ENTRY( "LoadAllPlugins", CAppMngr2RuntimeApiTest::LoadAllPluginsL ),

        ENTRY( "LoadPlugin", CAppMngr2RuntimeApiTest::LoadPluginL ),

        ENTRY( "CheckPluginsLoaded", CAppMngr2RuntimeApiTest::CheckPluginsLoadedL ),

        ENTRY( "LoadIcons", CAppMngr2RuntimeApiTest::LoadIconsL ),

        ENTRY( "GetAdditionalDirsToScan", CAppMngr2RuntimeApiTest::GetAdditionalDirsToScanL ),

        ENTRY( "GetInstallationFiles", CAppMngr2RuntimeApiTest::GetInstallationFilesL ),

        ENTRY( "CheckInstallationFiles", CAppMngr2RuntimeApiTest::CheckInstallationFilesL ),

        ENTRY( "ShowInstallationFileDetails", CAppMngr2RuntimeApiTest::ShowInstallationFileDetailsL  ),

        ENTRY( "CheckShowDetailsEnded", CAppMngr2RuntimeApiTest::CheckShowDetailsEndedL ),

        ENTRY( "CheckNoInstallationFiles", CAppMngr2RuntimeApiTest::CheckNoInstallationFilesL ),

        ENTRY( "StartInstallFile", CAppMngr2RuntimeApiTest::StartInstallFileL ),

        ENTRY( "CheckInstallEnded", CAppMngr2RuntimeApiTest::CheckInstallEndedL ),

        ENTRY( "GetInstalledApps", CAppMngr2RuntimeApiTest::GetInstalledAppsL ),

        ENTRY( "CheckAppInstalled", CAppMngr2RuntimeApiTest::CheckAppInstalledL ),

        ENTRY( "ShowInstalledDetails", CAppMngr2RuntimeApiTest::ShowInstalledDetailsL  ),

        ENTRY( "CheckNoAppsInstalled", CAppMngr2RuntimeApiTest::CheckNoAppsInstalledL ),

        ENTRY( "StartUninstallApp", CAppMngr2RuntimeApiTest::StartUninstallAppL ),

        ENTRY( "CheckUninstallEnded", CAppMngr2RuntimeApiTest::CheckUninstallEndedL )

        };

    const TInt count = sizeof( KFunctions ) / sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

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

// CAppMngr2RuntimeApiTest::RefreshInstalledApps()

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

//

void CAppMngr2RuntimeApiTest::RefreshInstalledApps()

    {

    _LIT( KFunctionName, "RefreshInstalledApps()" );

    Print( KFunctionName );

    }

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

// CAppMngr2RuntimeApiTest::RefreshInstallationFiles()

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

//

void CAppMngr2RuntimeApiTest::RefreshInstallationFiles()

    {

    _LIT( KFunctionName, "RefreshInstallationFiles()" );

    Print( KFunctionName );

    }

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

// CAppMngr2RuntimeApiTest::CommandResult()

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

//

void CAppMngr2RuntimeApiTest::CommandResult( CAppMngr2TestCommand& aCommand,

        TInt aCompletionCode )

    {

    _LIT( KCommandResultFormat, "async command completed (%S), result %d" );

    if( &aCommand == iInstallCommand )

        {

        _LIT( KCommandName, "install" );

        Print( KCommandResultFormat, &KCommandName, aCompletionCode );

        }

    else if( &aCommand == iUninstallCommand )

        {

        _LIT( KCommandName, "uninstall" );

        Print( KCommandResultFormat, &KCommandName, aCompletionCode );

        }

    else

        {

        _LIT( KCommandName, "UNKNOWN" );

        Print( KCommandResultFormat, &KCommandName, aCompletionCode );

        }

    Signal();       // releases "waittestclass" command in cfg file

    }

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

// CAppMngr2RuntimeApiTest::CAppMngr2RuntimeApiTest()

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

//

CAppMngr2RuntimeApiTest::CAppMngr2RuntimeApiTest( CTestModuleIf& aTestModuleIf )

        : CScriptBase( aTestModuleIf )

    {

    }

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

// CAppMngr2RuntimeApiTest::ConstructL()

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

//

void CAppMngr2RuntimeApiTest::ConstructL()

    {

    // Logger settings define if test case name must be appended to log file name

    RSettingServer settingServer;

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

    CleanupClosePushL( settingServer );

    TLoggerSettings loggerSettings;

    User::LeaveIfError( settingServer.GetLoggerSettings( loggerSettings ) );

    CleanupStack::PopAndDestroy( &settingServer );

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

    TFileName logFileName;

    if( loggerSettings.iAddTestCaseTitle )

        {

        TName title;

        TestModuleIf().GetTestCaseTitleL( title );

        logFileName.Format( KAppMngr2RuntimeApiTestLogFileWithTitle, &title );

        }

    else

        {

        logFileName.Copy( KAppMngr2RuntimeApiTestLogFile );

        }

    iLog = CStifLogger::NewL( KAppMngr2RuntimeApiTestLogPath, logFileName,

        CStifLogger::ETxt, CStifLogger::EFile, EFalse );

    SendTestClassVersion();

    _LIT( KRuntimeApiTest, "CAppMngr2RuntimeApiTest::ConstructL()" );

    Print( KTestStartFormat, &KRuntimeApiTest );

    // Ensure that CCoeEnv exists, RuntimeAPI needs it

    CCoeEnv* coeEnv = CCoeEnv::Static();

    _LIT( KRuntimeApiTestCoeEnvFormat, "%S: coeEnv = 0x%08x");

    Print( KRuntimeApiTestCoeEnvFormat, &KRuntimeApiTest, coeEnv );

    User::LeaveIfNull( coeEnv );

    // Load resource files used by AppMngr2 Runtime API and plug-ins

    TFileName* fullName = TAppMngr2DriveUtils::NearestResourceFileLC(

            KSWInstCommonUIResourceFileName, iFs );

    _LIT( KRuntimeApiTestResourceFileFormat, "%S: resource file %S");

    Print( KRuntimeApiTestResourceFileFormat, &KRuntimeApiTest, fullName );

    iSWInstCommonResourceFileOffset = coeEnv->AddResourceFileL( *fullName );

    CleanupStack::PopAndDestroy( fullName );

    fullName = new (ELeave) TFileName;

    CleanupStack::PushL( fullName );

    fullName->Format( KAppRscFormat, &KDC_APP_RESOURCE_DIR, &KAppMngr2UIResourceFileName );

    BaflUtils::NearestLanguageFile( iFs, *fullName );

    Print( KRuntimeApiTestResourceFileFormat, &KRuntimeApiTest, fullName );

    iAppMngr2ResourceFileOffset = coeEnv->AddResourceFileL( *fullName );

    CleanupStack::PopAndDestroy( fullName );

    _LIT( KCompleteFormat, "%S: complete");

    Print( KCompleteFormat, &KRuntimeApiTest );

    }

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

// CAppMngr2RuntimeApiTest::SendTestClassVersion()

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

//

void CAppMngr2RuntimeApiTest::SendTestClassVersion()

    {

    TVersion moduleVersion;

    moduleVersion.iMajor = TEST_CLASS_VERSION_MAJOR;

    moduleVersion.iMinor = TEST_CLASS_VERSION_MINOR;

    moduleVersion.iBuild = TEST_CLASS_VERSION_BUILD;

    TFileName moduleName;

    moduleName = KAppMngr2RuntimeApiTestModuleName;

    TBool newVersionOfMethod = ETrue;

    TestModuleIf().SendTestModuleVersion( moduleVersion, moduleName, newVersionOfMethod );

    }

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

// CAppMngr2RuntimeApiTest::Print()

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

//

void CAppMngr2RuntimeApiTest::Print( TRefByValue<const TDesC> aFmt, ... )

    {

    VA_LIST list;

    VA_START( list, aFmt );

    TBuf<KMaxLineLength> buf;

    buf.FormatList( aFmt, list );

    TestModuleIf().Printf( 0, KAppMngr2Tag, buf );

    iLog->Log( buf );

    }

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

// CAppMngr2RuntimeApiTest::GetUidFromStringL()

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

//

void CAppMngr2RuntimeApiTest::GetUidFromStringL( const TDesC& aString, TUid& aUid )

    {

    TUint32 uidValue;

    TLex lex( aString );

    User::LeaveIfError( lex.Val( uidValue, EHex ) );

    aUid.iUid = uidValue;

    }

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

// CAppMngr2RuntimeApiTest::FindInstallationPackage()

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

//

CAppMngr2PackageInfo* CAppMngr2RuntimeApiTest::FindInstallationPackage(

        const TDesC& aName )

    {

    TInt count = iInstallationPackages.Count();

    for( TInt index = 0; index < count; index++ )

        {

        if( iInstallationPackages[ index ]->Name().CompareC( aName ) == 0 )

            {

            return iInstallationPackages[ index ];

            }

        }

    return NULL;

    }

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

// CAppMngr2RuntimeApiTest::FindInstalledApp()

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

//

CAppMngr2AppInfo* CAppMngr2RuntimeApiTest::FindInstalledApp(

        const TDesC& aName )

    {

    TInt count = iInstalledApps.Count();

    for( TInt index = 0; index < count; index++ )

        {

        if( iInstalledApps[ index ]->Name().CompareC( aName ) == 0 )

            {

            return iInstalledApps[ index ];

            }

        }

    return NULL;

    }

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

// CAppMngr2RuntimeApiTest::CallInfoBaseFunctionsL()

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

//

void CAppMngr2RuntimeApiTest::CallInfoBaseFunctionsL( CAppMngr2InfoBase& aInfo,

        const TDesC& aTestName )

    {

    // Call CAppMngr2InfoBase and CAppMngr2Runtime members to get better code coverage.

    CAppMngr2Runtime& runtime( aInfo.Runtime() );

    MAppMngr2RuntimeObserver& runtimeObserver( runtime.Observer() );

    TInt testResult = KErrNone;

    RPointerArray<CEikMenuPaneItem::SData> menuPaneData;

    CleanupResetAndDestroyPushL( menuPaneData );

    TRAP( testResult, aInfo.GetMenuItemsL( menuPaneData ) );

    _LIT( KGetMenuItemsFormat, "%S: GetMenuItemsL, count %d, result %d" );

    Print( KGetMenuItemsFormat, &aTestName, menuPaneData.Count(), testResult );

    User::LeaveIfError( testResult );

    CleanupStack::PopAndDestroy( &menuPaneData );

    TBool isDetailsSupported = aInfo.SupportsGenericCommand( EAppMngr2CmdViewDetails );

    _LIT( KIsDetailsSupportedFormat, "%S: SupportsGenericCommand returned %d" );

    Print( KIsDetailsSupportedFormat, &aTestName, isDetailsSupported );

    TInt resourceId;

    TInt commandId;

    TRAP( testResult, aInfo.GetMiddleSoftkeyCommandL( resourceId, commandId ) );

    _LIT( KGetMiddleSoftkeyCmdFormat, "%S: GetMiddleSoftkeyCommandL, result %d" );

    Print( KGetMiddleSoftkeyCmdFormat, &aTestName, testResult );

    User::LeaveIfError( testResult );

    TBool isShowOnTop = aInfo.IsShowOnTop();

    _LIT( KIsShowOnTopFormat, "%S: IsShowOnTop returned %d" );

    Print( KIsShowOnTopFormat, &aTestName, isShowOnTop );

    TInt iconIndex = aInfo.IconIndex();

    _LIT( KIconIndexFormat, "%S: IconIndex returned %d" );

    Print( KIconIndexFormat, &aTestName, iconIndex );

    CGulIcon* icon = NULL;

    TRAP( testResult, icon = aInfo.SpecificIconL() );

    delete icon;

    icon = NULL;

    _LIT( KSpecificIconFormat, "%S: SpecificIcon, result %d" );

    Print( KSpecificIconFormat, &aTestName, testResult );

    if( testResult != KErrNone && testResult != KErrNotSupported )

        {

        User::Leave( testResult );

        }

    TInt indIconIndex = aInfo.IndicatorIconIndex();

    _LIT( KIndIconIndexFormat, "%S: IndicatorIconIndex returned %d" );

    Print( KIndIconIndexFormat, &aTestName, indIconIndex );

    TRAP( testResult, icon = aInfo.SpecificIndicatorIconL() );

    delete icon;

    icon = NULL;

    _LIT( KSpecificIndIconFormat, "%S: SpecificIndicatorIcon, result %d" );

    Print( KSpecificIndIconFormat, &aTestName, testResult );

    if( testResult != KErrNone && testResult != KErrNotSupported )

        {

        User::Leave( testResult );

        }

    TAppMngr2Location location = aInfo.Location();

    _LIT( KLocationFormat, "%S: Location returned %d" );

    Print( KLocationFormat, &aTestName, location );

    TDriveUnit driveUnit = aInfo.LocationDrive();

    _LIT( KLocationDriveFormat, "%S: LocationDrive returned %S" );

    TDriveName driveName( driveUnit.Name() );

    Print( KLocationDriveFormat, &aTestName, &driveName );

    }

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

// CAppMngr2RuntimeApiTest::CheckFilesExistL()

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

//

TInt CAppMngr2RuntimeApiTest::CheckFilesExistL( CStifItemParser& aItem )

    {

    _LIT( KTestName, "CheckFilesExist" );

    Print( KTestStartFormat, &KTestName );

    TInt testResult = KErrNone;

    TPtrC dirName;

    User::LeaveIfError( aItem.GetNextString( dirName ) );

    TPtrC fileName;

    while( aItem.GetNextString( fileName ) == KErrNone )

        {

        TParse parse;

        User::LeaveIfError( parse.SetNoWild( fileName, &dirName, NULL ) );

        TPtrC fullName = parse.FullName();

        TEntry entry;

        testResult = iFs.Entry( fullName, entry );

        Print( KResultFormat, &KTestName, &fileName, testResult );

        }

    Print( KTestDoneFormat, &KTestName, testResult );

    return testResult;

    }

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

// CAppMngr2RuntimeApiTest::LoadAllPluginsL()

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

//

TInt CAppMngr2RuntimeApiTest::LoadAllPluginsL( CStifItemParser& /*aItem*/ )

    {

    _LIT( KTestName, "LoadAllPlugins" );

    Print( KTestStartFormat, &KTestName );

    TInt testResult = KErrNone;

    iPlugins.ResetAndDestroy();

    RImplInfoPtrArray implInfoArray;

    CleanupResetAndDestroyPushL( implInfoArray  );

    REComSession::ListImplementationsL( KAppMngr2PluginInterface, implInfoArray );

    TInt count = implInfoArray.Count();

    _LIT( KPluginCountFormat, "%S: %d plugins found" );

    Print( KPluginCountFormat, &KTestName, count );

    for( TInt index = 0; index < count; index++ )

        {

        CImplementationInformation* implInfo = implInfoArray[ index ];

        CAppMngr2Runtime* plugin = NULL;

        TPtrC pluginName = implInfo->DisplayName();

        TUid pluginUid = implInfo->ImplementationUid();

        TRAP( testResult, plugin = CAppMngr2Runtime::NewL( pluginUid, *this ) );

        _LIT( KLoadingFormat,  "%S: index %d, loading %S (0x%08x), result %d" );

        Print( KLoadingFormat, &KTestName, index, &pluginName, pluginUid.iUid, testResult );

        if( testResult == KErrNone )

            {

            CleanupStack::PushL( plugin );

            iPlugins.AppendL( plugin );

            CleanupStack::Pop( plugin );

            }

        }

    CleanupStack::PopAndDestroy( &implInfoArray );

    REComSession::FinalClose();

    Print( KTestDoneFormat, &KTestName, testResult );

    return testResult;

    }

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

// CAppMngr2RuntimeApiTest::LoadPluginL()

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

//

TInt CAppMngr2RuntimeApiTest::LoadPluginL( CStifItemParser& aItem )

    {

    _LIT( KTestName, "LoadPlugin" );

    Print( KTestStartFormat, &KTestName );

    TInt testResult = KErrNone;

    TPtrC string;

    User::LeaveIfError( aItem.GetNextString ( string ) );

    TUid uid;

    GetUidFromStringL( string, uid );

    _LIT( KPluginCountFormat, "%S: plugin UID 0x%08x" );

    Print( KPluginCountFormat, &KTestName, uid.iUid );

    RImplInfoPtrArray implInfoArray;

    CleanupResetAndDestroyPushL( implInfoArray  );

    REComSession::ListImplementationsL( KAppMngr2PluginInterface, implInfoArray );

    CImplementationInformation* implInfo;

    TInt count = implInfoArray.Count();

    TBool found = EFalse;

    for( TInt index = 0; index < count && !found; index++ )

        {

        implInfo = implInfoArray[ index ];

        if( implInfo->ImplementationUid() == uid )

            {

            CAppMngr2Runtime* plugin = NULL;

            found = ETrue;

            _LIT( KLoadingFormat, "%S: loading %S" );

            Print( KLoadingFormat, &KTestName, &( implInfo->DisplayName() ) );

            TRAP( testResult, plugin = CAppMngr2Runtime::NewL(

                    implInfo->ImplementationUid(), *this ) );

            if( testResult == KErrNone )

                {

                CleanupStack::PushL( plugin );

                iPlugins.AppendL( plugin );

                CleanupStack::Pop( plugin );

                }

            }

        }

    if( !found )

        {

        _LIT( KPluginNotFound, "%S: plugin not found" );

        Print( KPluginNotFound, &KTestName );

        testResult = KErrNotFound;

        }

    CleanupStack::PopAndDestroy( &implInfoArray );

    REComSession::FinalClose();

    Print( KTestDoneFormat, &KTestName, testResult );

    return testResult;

    }