/*

* 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:  Tester class for mediamtpdp plugin

*

*/

#include <e32def.h>

#include <stiftestinterface.h>

#include <settingserverclient.h>

#include <mtp/mtpprotocolconstants.h>

#include <mtp/cmtptypeobjectinfo.h>

#include <mtp/cmtptypefile.h>

#include <mtp/cmtptypestring.h>

#include <mtp/cmtptypearray.h>

#include <mtp/cmtptypeobjectproplist.h>

#include <mtp/cmtptypeobjectpropdesc.h>

#include <bautils.h>

#include <f32file.h>

#include <mpxharvesterutility.h>

#include "cmediamtpdataprovidertester.h"

#include "logging.h"

#ifdef LOGGER

#undef LOGGER

#endif

#define LOGGER iLog

// definitions and constants for the test data

const TUint32 KTestStorageId = 0x10000;

const TInt KTestObjectsCount = 4;

const TUint KTestDirHandle = 1;

const TInt KTestDirDataproviderId = 0;

_LIT( KTempDirPath, "C:\\mtp_testdata\\temp\\" );

_LIT( KTestDirPath, "C:\\mtp_testdata\\temp\\TESTDIR\\" );

_LIT( KTestFileOrigPath, "C:\\mtp_testdata\\TEST.MP3" );

_LIT( KTestFileTempPath, "C:\\mtp_testdata\\temp\\TEST.MP3" );

_LIT( KTestDirOrigPath, "C:\\mtp_testdata\\TESTDIR\\*" );

_LIT( KTestDirTempPath, "C:\\mtp_testdata\\temp\\TESTDIR\\" );

_LIT( KTestDirPhysicalStorage, "C:\\mtp_testdata\\temp\\" );

_LIT( KTestDirLogicalStorage, "C:\\mtp_testdata\\temp\\" );

_LIT( KTestObjectPath1, "C:\\mtp_testdata\\temp\\TEST.MP3" );

_LIT( KTestObjectPath2, "C:\\mtp_testdata\\temp\\TESTDIR\\TEST1.MP3" );

_LIT( KTestObjectPath3, "C:\\mtp_testdata\\temp\\TESTDIR\\TEST2.MP3" );

_LIT( KSendTestObjectFile, "SENDTEST.MP3" );

_LIT( KSendTestObjectFileFullPath, "C:\\mtp_testdata\\SENDTEST.MP3" );

_LIT( KSendTestObjectPath, "C:\\mtp_testdata\\temp\\SENDTEST.MP3" );

_LIT( KSendTestObjectDateString, "20090511T091022+0800" );

_LIT( KCopyTestObjectPath, "C:\\mtp_testdata\\temp\\TEST1.MP3" );

_LIT( KCopyTestFileName, "TEST1.MP3" );

_LIT( KMoveTestObjectOldPath, "C:\\mtp_testdata\\temp\\TESTDIR\\TEST1.MP3" );

_LIT( KMoveTestObjectNewPath, "C:\\mtp_testdata\\temp\\TEST1.MP3" );

_LIT( KMoveTestFileName, "TEST1.MP3" );

_LIT( KRenameObjectName, "TESTDIR" );

_LIT( KRenameObjectPath, "C:\\mtp_testdata\\temp\\RENAMEDIR\\" );

//_LIT( KSendObjectNameString, "Test Object" );

_LIT( KPropObjectDate, "20090610T090000+0800" );

_LIT( KPropObjectName, "Test Object" );

_LIT( KPropObjectArtist, "Test Artist" );

_LIT( KPropObjectAlbumName, "Test Album" );

const TInt KTestFileSize = 271890;

const TInt KSendTestFileSize = 271890;

const TInt KCopyTestFileSize = 271890;

const TInt KMoveTestFileSize = 271890;

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

// Two-phased constructor.

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

//

CMediaMtpDataProviderTester* CMediaMtpDataProviderTester::NewL()

    {

    CMediaMtpDataProviderTester* self = 

            new ( ELeave ) CMediaMtpDataProviderTester();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// C++ default constructor can NOT contain any code, that might leave.

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

//

CMediaMtpDataProviderTester::CMediaMtpDataProviderTester()

        : CMmMtpDataProviderTester()

    {

    // no implementation required

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CMediaMtpDataProviderTester::ConstructL()

    {

    TFileName logFileName;

    logFileName.Copy( KMtpDataProviderTestModuleLogFile );

    iLog = CStifLogger::NewL( KMtpDataProviderTestModuleLogPath, 

                          logFileName,

                          CStifLogger::ETxt,

                          TRACE_TARGET,

                          ETrue, ETrue, ETrue, EFalse, ETrue );

    PRINTF0( ">CMediaMtpDataProviderTester::ConstructL" );

    iActiveSchedulerWait = new ( ELeave ) CActiveSchedulerWait();

    iFsSession.Connect();

    iFileMan = CFileMan::NewL( iFsSession );

    PRINTF0( "<CMediaMtpDataProviderTester::ConstructL" );

    }

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

// Destructor.

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

//  

CMediaMtpDataProviderTester::~CMediaMtpDataProviderTester()

    {

    PRINTF0( ">CMediaMtpDataProviderTester::~CMediaMtpDataProviderTester" );

    delete iActiveSchedulerWait;

    delete iFileMan;

    iFsSession.Close();

    PRINTF0( "<CMediaMtpDataProviderTester::~CMediaMtpDataProviderTester" );

    delete iLog;

    }

TInt CMediaMtpDataProviderTester::PrepareEnvironmentL()

    {

    PRINTF0( ">CMediaMtpDataProviderTester::PrepareEnvironmentL" );

    TInt result = KErrNone;

    result = iFileMan->RmDir( KTempDirPath );

    if ( result == KErrNone )

        {

        PRINTN0( "Warning: old temp directory found, deleted" );

        }

    result = KErrNone;

    // create the temp dir if it doesn't exist

    BaflUtils::EnsurePathExistsL( iFsSession, KTempDirPath );

    // copy the test data to temp dir

    result = iFileMan->Copy( KTestFileOrigPath, KTestFileTempPath );

    if ( result != KErrNone ) 

        {

        PRINTE1( "Failed to copy test file, error %d", result );

        }

    else

        {

        result = iFileMan->Copy( KTestDirOrigPath, KTestDirTempPath,

                CFileMan::EOverWrite | CFileMan::ERecurse );

        if ( result != KErrNone ) 

            {

            PRINTE1( "Failed to copy test dir, error %d", result );

            }

        }

    PRINTF1( "<CMediaMtpDataProviderTester::PrepareEnvironmentL result = %d", result );

    return result;

    }

TInt CMediaMtpDataProviderTester::CleanEnvironmentL()

    {

    PRINTF0( ">CMediaMtpDataProviderTester::CleanEnvironmentL" );

    TInt result = KErrNone;

    TMTPObjectMgrQueryParams queryParams ( KMTPStorageAll, KMTPFormatsAll,

            KMTPHandleNone );

    RMTPObjectMgrQueryContext context;

    RArray<TUint> handles;

    CleanupClosePushL( handles );

    PRINTN0( "Starting to delete entries from mpx" );

    MMPXHarvesterUtility* harvester = CMPXHarvesterFactory::NewL();

    CleanupClosePushL( *harvester );

    iTestObserver->ObjectMgr().GetObjectHandlesL( queryParams, context,

            handles );

    PRINTV1( "Handle count: %d", handles.Count() );

    context.Close();

    CMTPObjectMetaData* metadata = CMTPObjectMetaData::NewLC();

    for ( TInt i = 0; i < handles.Count(); i++ )

        {

        PRINTN0( "enter for loop" );

        TUint handle = handles[i];

            if ( handle != KTestDirHandle )

                {

                iTestObserver->ObjectMgr().ObjectL( handles[i], *metadata );

                TPtrC fileName = metadata->DesC( CMTPObjectMetaData::ESuid );

                PRINTV1( "Handle: %d", handles[i] );

                PRINTV1( "File name: %S", &fileName );

                PRINTN0( "Starting to delete the file from mpx" );

                iTestObserver->SetPendingOperation( CTestObserver::EHarvesterDeleteObject );

                PRINTN0( "before deletefilel" );

                harvester->DeleteFileL( fileName, iTestObserver );

                PRINTN0( "after deletefilel" );

                User::After( 1000000 );

                PRINTN0( "before waitforpendingoperation" );

                // waiting for asynchronous operation to complete

                result = iTestObserver->WaitForPendingOperation();

                PRINTN0( "after waitforpendingoperation" );

            if ( result != KErrNone )

                {

                PRINTE1( "Warning: failed to delete from mpx, error %d", result );

                result = KErrNone; // ignore for now, there are problems after DeleteObject

                }

            }

        }

    CleanupStack::PopAndDestroy( 3 ); // metadata, harvester, handles

    PRINTN0( "Finished deleting entries from mpx" );

    if ( result == KErrNone )

        {

        PRINTN0( "Deleting temp directory" );

        result = iFileMan->RmDir( KTempDirPath );

        if ( result != KErrNone )

            {

            PRINTE1( "Warning: failed to delete temp directory, error %d", result );

            result = KErrNone;

            }

        }

    PRINTF1( "<CMediaMtpDataProviderTester::CleanEnvironmentL result = %d", result );

    return result;

    }

TBool CMediaMtpDataProviderTester::ObjectEnumerationL_prepare(

        CMTPStorageMetaData* aPhysicalStorage,

        CMTPStorageMetaData* aLogicalStorage )

    {

    PRINTF0( ">CMediaMtpDataProviderTester::ObjectEnumerationL_prepare" );

    TBool result = ETrue;

    aPhysicalStorage->SetDesCL( CMTPStorageMetaData::EStorageSuid,

            KTestDirPhysicalStorage() );

    aPhysicalStorage->SetUint( CMTPStorageMetaData::EStorageSystemType,

            CMTPStorageMetaData::ESystemTypeDefaultFileSystem );

    aLogicalStorage->SetDesCL( CMTPStorageMetaData::EStorageSuid,

            KTestDirLogicalStorage() );

    aLogicalStorage->SetUint( CMTPStorageMetaData::EStorageSystemType,

            CMTPStorageMetaData::ESystemTypeDefaultFileSystem );

    // insert TESTDIR object manually

    CMTPObjectMetaData* object( CMTPObjectMetaData::NewLC( 0,

            EMTPFormatCodeAssociation, // a folder object

            KTestStorageId, KTestDirPath ) );

    // object is in storage root

    object->SetInt( CMTPObjectMetaData::EParentId, KErrNotFound );

    iTestObserver->ObjectMgr().InsertObjectL( *object );

    CleanupStack::PopAndDestroy( object );

    PRINTF1( "<CMediaMtpDataProviderTester::ObjectEnumerationL_prepare result = %d", result );

    return result;

    }

TInt CMediaMtpDataProviderTester::ObjectEnumerationL_checkresults(

        MMTPObjectMgr& aObjectManager )

    {

    PRINTF0( ">CMediaMtpDataProviderTester::ObjectEnumerationL_checkresults" );

    TInt result = KErrNone;

    TMTPObjectMgrQueryParams queryParams ( KMTPStorageAll, KMTPFormatsAll,

            KMTPHandleNone );

    RMTPObjectMgrQueryContext context;

    RArray<TUint> handles;

    CleanupClosePushL( handles );

    MMPXHarvesterUtility* harvester = CMPXHarvesterFactory::NewL();

    CleanupClosePushL( *harvester );

    aObjectManager.GetObjectHandlesL( queryParams, context, handles );

    context.Close();

    TInt count = handles.Count();

    PRINTV1( "Handle count: %d", count );

    if ( count != KTestObjectsCount ) 

        {

        PRINTE2( "Wrong number of handles: %d != %d", count, KTestObjectsCount );

        result = KErrGeneral;

        }

    CMTPObjectMetaData* metadata = CMTPObjectMetaData::NewLC();

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

        {

        TUint handle = handles[i];

        aObjectManager.ObjectL( handle, *metadata );

        TPtrC suid = metadata->DesC( CMTPObjectMetaData::ESuid );

        TUint formatCode = metadata->Uint( CMTPObjectMetaData::EFormatCode );

        TUint dataproviderId = metadata->Uint( CMTPObjectMetaData::EDataProviderId );

        TUint storageId = metadata->Uint( CMTPObjectMetaData::EStorageId );

        TInt parentId = metadata->Int( CMTPObjectMetaData::EParentId );

        PRINTN1( "Handle: %d", handle );

        PRINTN1( "Suid: %S", &suid );

        if ( dataproviderId != iTestObserver->DataProviderId() )

            {

            if ( !( ( handle == KTestDirHandle ) &&

                    ( dataproviderId == KTestDirDataproviderId ) ) )

                {

                PRINTE2( "Wrong dataprovider id: %d != %d", dataproviderId, iTestObserver->DataProviderId() );

                result = KErrGeneral;

                }

            }

        if ( storageId != KTestStorageId )

            {

            PRINTE2( "Wrong storage id: %d != %d", storageId, KTestStorageId );

            result = KErrGeneral;

            }

        switch ( handle )

            {

            case 1:

                {

                if ( suid.Match( KTestDirPath ) != 0 )

                    {

                    PRINTE2( "Wrong test dir path: %S != %S", &suid, &KTestDirPath );

                    result = KErrGeneral;

                    }

                if ( formatCode != EMTPFormatCodeAssociation )

                    {

                    PRINTE2( "Wrong format code: 0x%x != 0x%x", formatCode, EMTPFormatCodeAssociation );

                    result = KErrGeneral;

                    }

                if ( parentId != KErrNotFound )

                    {

                    PRINTE2( "Wrong parent id: %d != %d", parentId, KErrNotFound );

                    result = KErrGeneral;

                    }

                break;

                }

            case 2:

                {

                if ( suid.Match( KTestObjectPath1 ) != 0 )

                    {

                    PRINTE2( "Wrong test object 1 path: %S != %S", &suid, &KTestObjectPath1 );

                    result = KErrGeneral;

                    }

                if ( formatCode != EMTPFormatCodeMP3 )

                    {

                    PRINTE2( "Wrong format code: 0x%x != 0x%x", formatCode, EMTPFormatCodeMP3 );

                    result = KErrGeneral;

                    }

                if ( parentId != KErrNotFound )

                    {

                    PRINTE2( "Wrong parent id: %d != %d", parentId, KErrNotFound );

                    result = KErrGeneral;

                    }

                break;

                }

            case 3:

                {

                if ( suid.Match( KTestObjectPath2 ) != 0 )

                    {

                    PRINTE2( "Wrong test object 2 path: %S != %S", &suid, KTestObjectPath2 );

                    result = KErrGeneral;

                    }

                if ( formatCode != EMTPFormatCodeMP3 )

                    {

                    PRINTE2( "Wrong format code: 0x%x != 0x%x", formatCode, EMTPFormatCodeMP3 );

                    result = KErrGeneral;

                    }

                if ( parentId != 1 )

                    {

                    PRINTE2( "Wrong parent id: %d != %d", parentId, 1 );

                    result = KErrGeneral;

                    }

                break;

                }

            case 4:

                {

                if ( suid.Match( KTestObjectPath3 ) != 0 )

                    {

                    PRINTE2( "Wrong test object 3 path: %S != %S", &suid, &KTestObjectPath3 );

                    result = KErrGeneral;

                    }

                if ( formatCode != EMTPFormatCodeMP3 )

                    {

                    PRINTE2( "Wrong format code: 0x%x != 0x%x", formatCode, EMTPFormatCodeMP3 );

                    result = KErrGeneral;

                    }

                if ( parentId != 1 )

                    {

                    PRINTE2( "Wrong parent id: %d != %d", parentId, 1 );

                    result = KErrGeneral;

                    }

                break;

                }

            default:

                {

                PRINTE1( "Unexpected handle: %d", handle );

                result = KErrGeneral;

                }

            }

        if ( ( result == KErrNone ) && ( handle != KTestDirHandle ) )

            {

            PRINTN0( "Starting to harvest the file" );

            iTestObserver->SetPendingOperation( CTestObserver::EHarvesterAddObject );

            harvester->AddFileL( metadata->DesC( CMTPObjectMetaData::ESuid ), iTestObserver );

            PRINTN0( "Waiting for harvesting to complete" );

            result = iTestObserver->WaitForPendingOperation();

            if ( result != KErrNone )

                {

                PRINTE1( "Harvesting error: %d", result );

                }

            }

        }

    CleanupStack::PopAndDestroy( 3 ); // handles, harvester, metadata

    PRINTF1( "<CMediaMtpDataProviderTester::ObjectEnumerationL_checkresults result = %d", result );

    return result;

    }

TInt CMediaMtpDataProviderTester::GetObjectInfoL_checkresults(

        const CMTPTypeObjectInfo* aObjectInfo )

    {

    PRINTF0( ">CMediaMtpDataProviderTester::GetObjectInfoL_checkresults" );

    _LIT( KTestFileName, "TEST.MP3" );

    TInt result = KErrNone;

    if ( aObjectInfo )

        {

        PRINTV1( "Object filename: %S", &aObjectInfo->StringCharsL( CMTPTypeObjectInfo::EFilename ) );

        if ( aObjectInfo->StringCharsL( CMTPTypeObjectInfo::EFilename ).

                CompareF( KTestFileName ) != 0 )

            {

            PRINTE0( "ObjectInfo filename not correct" );

            result = KErrGeneral;

            }

        PRINTV1( "Object modified date: %S", &aObjectInfo->StringCharsL( CMTPTypeObjectInfo::EDateModified ) );

        if ( aObjectInfo->StringCharsL( CMTPTypeObjectInfo::EDateModified ).

                Length() == 0 )

            {

            PRINTE0( "ObjectInfo modified date not set" );

            }

        PRINTV1( "Object formatcode: 0x%x", aObjectInfo->Uint16L( CMTPTypeObjectInfo::EObjectFormat ) );

        if ( aObjectInfo->Uint16L( CMTPTypeObjectInfo::EObjectFormat ) !=

                EMTPFormatCodeMP3 )

            {

            PRINTE0( "ObjectInfo format code not correct" );

            result=KErrGeneral;

            }

        }

    else

        {

        PRINTE0( "ObjectInfo not received correctly" );

        result = KErrArgument;

        }

    PRINTF1( "<CMediaMtpDataProviderTester::GetObjectInfoL_checkresults result = %d", result );

    return result;

    }

TInt CMediaMtpDataProviderTester::GetObjectL_checkresults(

        CMTPTypeFile* aObjectInfo )

    {

    PRINTF0( ">CMediaMtpDataProviderTester::GetObjectL_checkresults" );

    // just check the handle is correct, based on the size

    TInt result = KErrNone;

    if ( aObjectInfo )

        {

        TInt size = aObjectInfo->Size();

        PRINTV1( "Received object size: %d", size );

        if ( size != KTestFileSize )

            {

            PRINTE2( "Wrong received object size: %d != %d", KTestFileSize, size );

            result =  KErrGeneral;

            }

        aObjectInfo->File().Close();

        }

    else

        {

        PRINTE0( "Object info not received" );

        result = KErrArgument;

        }

    PRINTF1( "<CMediaMtpDataProviderTester::GetObjectL_checkresults result = %d", result );

    return result;

    }

TInt CMediaMtpDataProviderTester::GetObjectPropValueL_checkresults(

        const MMTPType* aObjectPropValue, const TUint aPropCode )

    {

    PRINTF0( ">CMediaMtpDataProviderTester::GetObjectPropValueL_checkresults" );

    TInt type = aObjectPropValue->Type();

    PRINTV1( "Received data type: 0x%x", type );

    TInt result = KErrNone;

    switch ( aPropCode )

        {

        case EMTPObjectPropCodeStorageID:

            {

            TUint32 value = static_cast<const TMTPTypeUint32*>( aObjectPropValue )->Value();

            PRINTV1( "Storage ID: 0x%x", value );

            if ( value == KTestStorageId )

                {

                result = KErrNone;

                }

            }

            break;

        case EMTPObjectPropCodeObjectFormat:

            {

            TUint16 value = static_cast<const TMTPTypeUint16*>( aObjectPropValue )->Value();

            PRINTV1( "Format: 0x%x", value );

            if ( value == EMTPFormatCodeMP3 )

                {

                result = KErrNone;

                }

            }

            break;

        case EMTPObjectPropCodeProtectionStatus:

            {

            TUint16 value = static_cast<const TMTPTypeUint16*>( aObjectPropValue )->Value();

            PRINTV1( "Protections status: 0x%x", value );

            if ( value == EMTPProtectionNoProtection )