--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmappcomponents/mmmtpdataprovider/tsrc/mtpdataprovidertestmodule/src/cmediamtpdataprovidertester.cpp Thu Dec 17 08:55:47 2009 +0200
@@ -0,0 +1,1557 @@
+/*
+* 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 )
+ {
+ result = KErrNone;
+ }
+ }
+ break;
+ case EMTPObjectPropCodeObjectSize:
+ {
+ TUint64 value = static_cast<const TMTPTypeUint64*>( aObjectPropValue )->Value();
+ PRINTV1( "Object size: %d", value );
+ if ( value == KTestFileSize )
+ {
+ result = KErrNone;
+ }
+ }
+ break;
+ case EMTPObjectPropCodeObjectFileName:
+ {
+ TPtrC value = static_cast<const CMTPTypeString*>( aObjectPropValue )->StringChars();
+ PRINTV1( "Object file name: '%S'", &value );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeParentObject:
+ {
+ TUint32 value = static_cast<const TMTPTypeUint32*>( aObjectPropValue )->Value();
+ PRINTV1( "Parent object: %d", value );
+ if ( value == KMaxTUint32 )
+ {
+ result = KErrNone;
+ }
+ }
+ break;
+ case EMTPObjectPropCodePersistentUniqueObjectIdentifier:
+ {
+ /*
+ TUint64 lower = static_cast<const TMTPTypeUint128*>( aObjectPropValue )->LowerValue();
+ TUint64 upper = static_cast<const TMTPTypeUint128*>( aObjectPropValue )->UpperValue();
+ __TRACE( KPrint, ( _L( "Unique identifier: 0x%x 0x%x" ), lower, upper ) );
+ if ( ( lower == 1) && ( upper == 1 ) )
+ {
+ result = KErrNone;
+ }
+ */
+ }
+ break;
+ case EMTPObjectPropCodeName:
+ {
+ TPtrC value = static_cast<const CMTPTypeString*>( aObjectPropValue )->StringChars();
+ PRINTV1( "Object name: '%S'", &value );
+ if ( value.Match( KPropObjectName ) != 0 )
+ {
+ PRINTE2( "Received object name does not match: '%S' != '%S'", &value, &KPropObjectName );
+ result = KErrGeneral;
+ }
+ }
+ break;
+ case EMTPObjectPropCodeNonConsumable:
+ {
+ TUint8 value = static_cast<const TMTPTypeUint8*>( aObjectPropValue )->Value();
+ PRINTV1( "Non-consumable: %d", value );
+ if ( value == 1 )
+ {
+ result = KErrNone;
+ }
+ }
+ break;
+ case EMTPObjectPropCodeDateAdded:
+ {
+ TPtrC value = static_cast<const CMTPTypeString*>( aObjectPropValue )->StringChars();
+ PRINTV1( "Date added: '%S'", &value );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeDateCreated:
+ {
+ TPtrC value = static_cast<const CMTPTypeString*>( aObjectPropValue )->StringChars();
+ PRINTV1( "Date created: '%S'", &value );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeDateModified:
+ {
+ TPtrC value = static_cast<const CMTPTypeString*>( aObjectPropValue )->StringChars();
+ PRINTV1( "Date modified: '%S'", &value );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeArtist:
+ {
+ TPtrC value = static_cast<const CMTPTypeString*>( aObjectPropValue )->StringChars();
+ PRINTV1( "Artist: '%S'", &value );
+ if ( value.Match( KPropObjectArtist ) != 0 )
+ {
+ PRINTE2( "Received object artist does not match: '%S' != '%S'", &value, &KPropObjectArtist );
+ result = KErrGeneral;
+ }
+ }
+ break;
+ case EMTPObjectPropCodeTrack:
+ {
+ TUint16 value = static_cast<const TMTPTypeUint16*>( aObjectPropValue )->Value();
+ PRINTV1( "Track: %d", value );
+ if ( value == 1 )
+ {
+ result = KErrNone;
+ }
+ }
+ break;
+ case EMTPObjectPropCodeGenre:
+ {
+ TPtrC value = static_cast<const CMTPTypeString*>( aObjectPropValue )->StringChars();
+ PRINTV1( "Genre: '%S'", &value );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeAlbumName:
+ {
+ TPtrC value = static_cast<const CMTPTypeString*>( aObjectPropValue )->StringChars();
+ PRINTV1( "Album name: '%S'", &value );
+ if ( value.Match( KPropObjectAlbumName ) != 0 )
+ {
+ PRINTE2( "Received object album name does not match: '%S' != '%S'", &value, &KPropObjectAlbumName );
+ result = KErrGeneral;
+ }
+ }
+ break;
+ case EMTPObjectPropCodeSampleRate:
+ {
+ TUint32 value = static_cast<const TMTPTypeUint16*>( aObjectPropValue )->Value();
+ PRINTV1( "Sample rate: %d", value );
+ if ( value == 1 )
+ {
+ result = KErrNone;
+ }
+ }
+ break;
+ case EMTPObjectPropCodeNumberOfChannels:
+ {
+ TUint16 value = static_cast<const TMTPTypeUint16*>( aObjectPropValue )->Value();
+ PRINTV1( "Number of channels: %d", value );
+ if ( value == 1 )
+ {
+ result = KErrNone;
+ }
+ }
+ break;
+ case EMTPObjectPropCodeAudioWAVECodec:
+ {
+ TUint32 value = static_cast<const TMTPTypeUint16*>( aObjectPropValue )->Value();
+ PRINTV1( "WAVE codec: %d", value );
+ if ( value == 1 )
+ {
+ result = KErrNone;
+ }
+ }
+ break;
+ case EMTPObjectPropCodeAudioBitRate:
+ {
+ TUint32 value = static_cast<const TMTPTypeUint16*>( aObjectPropValue )->Value();
+ PRINTV1( "Audio bit rate: %d", value );
+ if ( value == 1 )
+ {
+ result = KErrNone;
+ }
+ }
+ break;
+ case EMTPObjectPropCodeDuration:
+ {
+ TUint32 value = static_cast<const TMTPTypeUint16*>( aObjectPropValue )->Value();
+ PRINTV1( "Duration: %d", value );
+ if ( value == 1 )
+ {
+ result = KErrNone;
+ }
+ }
+ break;
+ case EMTPObjectPropCodeOriginalReleaseDate:
+ {
+ TPtrC value = static_cast<const CMTPTypeString*>( aObjectPropValue )->StringChars();
+ PRINTV1( "Original release date: '%S'", &value );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeDescription:
+ {
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeComposer:
+ {
+ TPtrC value = static_cast<const CMTPTypeString*>( aObjectPropValue )->StringChars();
+ PRINTV1( "Composer: '%S'", &value );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeWidth:
+ case EMTPObjectPropCodeHeight:
+ case EMTPObjectPropCodeUseCount:
+ case EMTPObjectPropCodeScanType:
+ case EMTPObjectPropCodeVideoFourCCCodec:
+ case EMTPObjectPropCodeVideoBitRate:
+ case EMTPObjectPropCodeFramesPerThousandSeconds:
+ case EMTPObjectPropCodeKeyFrameDistance:
+ case EMTPObjectPropCodeEncodingProfile:
+ case EMTPObjectPropCodeParentalRating:
+ {
+ result = KErrNone;
+ }
+ break;
+ default:
+ {
+ PRINTE1( "Unsupported prop code: %d", aPropCode );
+ result = KErrArgument;
+ }
+ }
+ PRINTF1( "<CMediaMtpDataProviderTester::GetObjectPropValueL_checkresults result = %d", result );
+ return result;
+ }
+
+TInt CMediaMtpDataProviderTester::GetObjectPropListL_checkresults(
+ const CMTPTypeObjectPropList* aObjectPropList )
+ {
+ PRINTF0( ">CMediaMtpDataProviderTester::GetObjectPropListL_checkresults" );
+ TInt result = KErrNone;
+ TUint32 count = aObjectPropList->NumberOfElements();
+ PRINTV1( "PropList elements received: %d", count );
+ for ( TUint32 i = 0; i < count; i++ )
+ {
+ CMTPTypeObjectPropListElement& element = aObjectPropList->Element( i );
+ TUint32 handle = element.Uint32L( CMTPTypeObjectPropListElement::EObjectHandle );
+ PRINTV1( "Object handle: %d", handle );
+ TUint16 dataType = element.Uint16L( CMTPTypeObjectPropListElement::EDatatype );
+ PRINTV1( "Data type: 0x%x", dataType );
+ TUint16 propCode = element.Uint16L( CMTPTypeObjectPropListElement::EPropertyCode );
+ PRINTV1( "Prop code: 0x%x", propCode );
+ if ( propCode == EMTPObjectPropCodeName )
+ {
+ if ( dataType == EMTPTypeString )
+ {
+ TPtrC name = element.StringCharsL( CMTPTypeObjectPropListElement::EValue );
+ PRINTN1( "Object name: %S", &name );
+ if ( name.Match( KPropObjectName ) != 0 )
+ {
+ PRINTE2( "Object modified date is incorrect: %S != %S", &name, &KPropObjectName );
+ result = KErrGeneral;
+ }
+ }
+ else
+ {
+ PRINTE2( "Wrong datatype received, 0x%x != 0x%x", dataType, EMTPTypeString );
+ result = KErrArgument;
+ }
+ }
+ }
+
+ PRINTF1( "<CMediaMtpDataProviderTester::GetObjectPropListL_checkresults result = %d", result );
+ return result;
+ }
+
+TInt CMediaMtpDataProviderTester::GetObjectPropDescL_checkresults(
+ const CMTPTypeObjectPropDesc* aObjectPropDesc, const TUint aPropCode )
+ {
+ PRINTF0( ">CMediaMtpDataProviderTester::GetObjectPropDescL_checkresults" );
+ TUint16 propertyCode = aObjectPropDesc->Uint16L( CMTPTypeObjectPropDesc::EPropertyCode );
+ TUint16 dataType = aObjectPropDesc->Uint16L( CMTPTypeObjectPropDesc::EDatatype );
+ TUint8 getSet = aObjectPropDesc->Uint8L( CMTPTypeObjectPropDesc::EGetSet );
+ TUint8 formFlag = aObjectPropDesc->Uint8L( CMTPTypeObjectPropDesc::EFormFlag );
+
+ TInt result = KErrNone;
+
+ PRINTV4( "Property code: 0x%x, data type: 0x%x, form flag: 0x%x, get/set: 0x%x", propertyCode, dataType, formFlag, getSet );
+
+ if ( formFlag != CMTPTypeObjectPropDesc::ENone )
+ {
+ switch ( formFlag )
+ {
+ case CMTPTypeObjectPropDesc::ERangeForm:
+ PRINTV0( "Range form" );
+ break;
+ case CMTPTypeObjectPropDesc::EEnumerationForm:
+ PRINTV0( "Enumeration form" );
+ break;
+ case CMTPTypeObjectPropDesc::EDateTimeForm:
+ PRINTV0( "Datetime form" );
+ break;
+ case CMTPTypeObjectPropDesc::EFixedLengthArrayForm:
+ PRINTV0( "Fixed length array form" );
+ break;
+ case CMTPTypeObjectPropDesc::ERegularExpressionForm:
+ PRINTV0( "Regular expression form" );
+ break;
+ case CMTPTypeObjectPropDesc::EByteArrayForm:
+ PRINTV0( "Byte array form" );
+ break;
+ case CMTPTypeObjectPropDesc::ELongStringForm:
+ PRINTV0( "Long string form" );
+ default:
+ {
+ PRINTE0( "Invalid form" );
+ result = KErrArgument;
+ }
+ }
+ }
+
+ switch ( aPropCode )
+ {
+ case EMTPObjectPropCodeStorageID:
+ {
+ PRINTV0( "Storage ID" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeObjectFormat:
+ {
+ PRINTV0( "Object format" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeProtectionStatus:
+ {
+ PRINTV0( "Protection status" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeObjectSize:
+ {
+ PRINTV0( "Object size" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeObjectFileName:
+ {
+ PRINTV0( "Object file name" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeParentObject:
+ {
+ PRINTV0( "Parent object" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodePersistentUniqueObjectIdentifier:
+ {
+ PRINTV0( "Unique object identifier" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeName:
+ {
+ PRINTV0( "Name" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeNonConsumable:
+ {
+ PRINTV0( "Non consumable" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeDateAdded:
+ {
+ PRINTV0( "Date added" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeDateCreated:
+ {
+ PRINTV0( "Date created" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeDateModified:
+ {
+ PRINTV0( "Date modified" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeArtist:
+ {
+ PRINTV0( "Artist" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeTrack:
+ {
+ PRINTV0( "Track" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeGenre:
+ {
+ PRINTV0( "Genre" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeAlbumName:
+ {
+ PRINTV0( "Album name" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeSampleRate:
+ {
+ PRINTV0( "Sample rate" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeNumberOfChannels:
+ {
+ PRINTV0( "Number of channels" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeAudioWAVECodec:
+ {
+ PRINTV0( "Audio wave codec" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeAudioBitRate:
+ {
+ PRINTV0( "Audio bitrate" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeDuration:
+ {
+ PRINTV0( "Duration" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeOriginalReleaseDate:
+ {
+ PRINTV0( "Original release date" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeDescription:
+ {
+ PRINTV0( "Description" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeComposer:
+ {
+ PRINTV0( "Composer" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeWidth:
+ {
+ PRINTV0( "Width" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeHeight:
+ {
+ PRINTV0( "Height" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeUseCount:
+ {
+ PRINTV0( "Use count" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeScanType:
+ {
+ PRINTV0( "Scan type" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeVideoFourCCCodec:
+ {
+ PRINTV0( "Video 4cc codec" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeVideoBitRate:
+ {
+ PRINTV0( "Video bitrate" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeFramesPerThousandSeconds:
+ {
+ PRINTV0( "Frames per thousand seconds" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeKeyFrameDistance:
+ {
+ PRINTV0( "Key frame distance" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeEncodingProfile:
+ {
+ PRINTV0( "Encoding profile" );
+ result = KErrNone;
+ }
+ break;
+ case EMTPObjectPropCodeParentalRating:
+ {
+ PRINTV0( "Parental rating" );
+ result = KErrNone;
+ }
+ break;
+ default:
+ {
+ PRINTE1( "Unsupported prop code: %d", aPropCode );
+ result = KErrArgument;
+ }
+ }
+ PRINTF1( "<CMediaMtpDataProviderTester::GetObjectPropDescL_checkresults result = %d", result );
+ return result;
+ }
+
+TBool CMediaMtpDataProviderTester::SendObjectInfoL_prepare(
+ TMTPTypeRequest& aRequest )
+ {
+ PRINTF0( ">CMediaMtpDataProviderTester::SendObjectInfoL_prepare" );
+ TBool result = ETrue;
+ TUint32 storageId = KTestStorageId; // physical storage
+ aRequest.SetUint32( TMTPTypeRequest::ERequestParameter1, storageId );
+ PRINTF1( "<CMediaMtpDataProviderTester::SendObjectInfoL_prepare result = %d", result );
+ return result;
+ }
+
+void CMediaMtpDataProviderTester::SendObjectInfoReceiveData(
+ CMTPTypeObjectInfo* aData )
+ {
+ PRINTF0( ">CMediaMtpDataProviderTester::SendObjectInfoReceiveData" );
+ aData->SetUint32L( CMTPTypeObjectInfo::EStorageID, KTestStorageId );
+ aData->SetUint16L( CMTPTypeObjectInfo::EObjectFormat, EMTPFormatCodeMP3 );
+ aData->SetStringL( CMTPTypeObjectInfo::EFilename, KSendTestObjectFile );
+ aData->SetStringL( CMTPTypeObjectInfo::EDateModified, KSendTestObjectDateString );
+ aData->SetUint32L( CMTPTypeObjectInfo::EObjectCompressedSize, KSendTestFileSize );
+ PRINTF0( "<CMediaMtpDataProviderTester::SendObjectInfoReceiveData" );
+ }
+
+TBool CMediaMtpDataProviderTester::SendObjectL_prepare(
+ TMTPTypeRequest& aRequest )
+ {
+ PRINTF0( ">CMediaMtpDataProviderTester::SendObjectL_prepare" );
+ TBool result = ETrue;
+ TUint32 storageId = KTestStorageId; // physical storage
+ aRequest.SetUint32( TMTPTypeRequest::ERequestParameter1, storageId );
+ PRINTF1( "<CMediaMtpDataProviderTester::SendObjectL_prepare result = %d", result );
+ return result;
+ }
+
+void CMediaMtpDataProviderTester::SendObjectReceiveDataL( CMTPTypeFile* aData )
+ {
+ PRINTF0( ">CMediaMtpDataProviderTester::SendObjectReceiveDataL" );
+ CMTPTypeFile* fileObject = CMTPTypeFile::NewL( iFsSession,
+ KSendTestObjectFileFullPath, EFileRead );
+ CMTPTypeFile::CopyL( *fileObject, *aData );
+ delete fileObject;
+ aData->File().Close();
+ PRINTF0( "<CMediaMtpDataProviderTester::SendObjectReceiveDataL" );
+ }
+
+TInt CMediaMtpDataProviderTester::SendObjectL_checkresults()
+ {
+ PRINTF0( ">CMediaMtpDataProviderTester::SendObjectL_checkresults" );
+ TInt result = KErrNone;
+ TEntry entry;
+ if ( !BaflUtils::FileExists( iFsSession, KSendTestObjectPath ) )
+ {
+ PRINTE0( "Sent file does not exist" );
+ result = KErrGeneral;
+ }
+ else
+ {
+ result = iFsSession.Entry( KSendTestObjectPath, entry );
+ if ( result != KErrNone )
+ {
+ PRINTE1( "Could not read file entry, error: %d", result );
+ }
+ else
+ {
+ if ( entry.iSize != KSendTestFileSize )
+ {
+ PRINTE2( "Sent file size is incorrect: %d != %d", entry.iSize, KSendTestFileSize );
+ result = KErrGeneral;
+ }
+ }
+ }
+ if ( result == KErrNone )
+ {
+ CMTPObjectMetaData* metadata = CMTPObjectMetaData::NewLC();
+ iTestObserver->ObjectMgr().ObjectL( KSendTestObjectPath, *metadata );
+ if ( metadata->Uint( CMTPObjectMetaData::EHandle ) <= 0 )
+ {
+ PRINTE1( "Object handle not found: %d", metadata->Uint( CMTPObjectMetaData::EHandle ) );
+ result = KErrGeneral;
+ }
+ if ( metadata->Uint( CMTPObjectMetaData::EFormatCode ) != EMTPFormatCodeMP3 )
+ {
+ PRINTE1( "Wrong format code: %d", metadata->Uint( CMTPObjectMetaData::EFormatCode ) );
+ result = KErrGeneral;
+ }
+ CleanupStack::PopAndDestroy( metadata );
+ }
+ PRINTF1( "<CMediaMtpDataProviderTester::SendObjectL_checkresults result = %d", result );
+ return result;
+ }
+
+void CMediaMtpDataProviderTester::SetObjectPropValueReceiveDataL(
+ const TMTPTypeRequest& aRequest, MMTPType* aData )
+ {
+ TUint32 propCode = aRequest.Uint32( TMTPTypeRequest::ERequestParameter2 );
+ TUint type = aData->Type();
+ switch ( propCode )
+ {
+ case EMTPObjectPropCodeName:
+ if ( type != EMTPTypeString )
+ {
+ PRINTE2( "Incorrect data type: 0x%x != 0x%x", type, EMTPTypeString );
+ User::Leave( KErrArgument );
+ }
+ static_cast<CMTPTypeString*>( aData )->SetL( KPropObjectName );
+ break;
+ case EMTPObjectPropCodeArtist:
+ if ( type != EMTPTypeString )
+ {
+ PRINTE2( "Incorrect data type: 0x%x != 0x%x", type, EMTPTypeString );
+ User::Leave( KErrArgument );
+ }
+ static_cast<CMTPTypeString*>( aData )->SetL( KPropObjectArtist );
+ break;
+ case EMTPObjectPropCodeAlbumName:
+ if ( type != EMTPTypeString )
+ {
+ PRINTE2( "Incorrect data type: 0x%x != 0x%x", type, EMTPTypeString );
+ User::Leave( KErrArgument );
+ }
+ static_cast<CMTPTypeString*>( aData )->SetL( KPropObjectAlbumName );
+ break;
+ default:
+ PRINTE1( "Property code not supported: 0x%x", propCode );
+ User::Leave( KErrNotSupported );
+ break;
+ }
+ }
+
+void CMediaMtpDataProviderTester::SetObjectPropListReceiveDataL(
+ CMTPTypeObjectPropList* aData )
+ {
+ PRINTF0( ">CMediaMtpDataProviderTester::SetObjectPropListReceiveDataL" );
+ CMTPTypeString* nameString = CMTPTypeString::NewLC( KPropObjectName );
+ CMTPTypeObjectPropListElement* newElement;
+ newElement = CMTPTypeObjectPropListElement::NewL( 1, static_cast<TUint16>( EMTPObjectPropCodeName ), *nameString );
+ aData->AppendL( newElement );
+ newElement = CMTPTypeObjectPropListElement::NewL( 2, static_cast<TUint16>( EMTPObjectPropCodeName ), *nameString );
+ aData->AppendL( newElement );
+ newElement = CMTPTypeObjectPropListElement::NewL( 3, static_cast<TUint16>( EMTPObjectPropCodeName ), *nameString );
+ aData->AppendL( newElement );
+ CleanupStack::Pop( nameString );
+ PRINTF0( "<CMediaMtpDataProviderTester::SetObjectPropListReceiveDataL" );
+ }
+
+TInt CMediaMtpDataProviderTester::DeleteObjectL_checkresults(
+ MMTPObjectMgr& aObjectManager )
+ {
+ PRINTF0( ">CMediaMtpDataProviderTester::DeleteObjectL_checkresults" );
+ TInt result = KErrNone;
+ // check that everything has been deleted from the file system
+ if ( BaflUtils::FileExists( iFsSession, KTestObjectPath1 ) )
+ {
+ PRINTE0( "Test file 1 was not deleted successfully" );
+ result = KErrGeneral;
+ }
+ if ( BaflUtils::FileExists( iFsSession, KTestObjectPath2 ) )
+ {
+ PRINTE0( "Test file 2 was not deleted successfully" );
+ result = KErrGeneral;
+ }
+ if ( BaflUtils::FileExists( iFsSession, KTestObjectPath3 ) )
+ {
+ PRINTE0( "Test file 3 was not deleted successfully" );
+ result = KErrGeneral;
+ }
+ PRINTF1( ">CMediaMtpDataProviderTester::DeleteObjectL_checkresults result = %d", result );
+ return result;
+ }
+
+TBool CMediaMtpDataProviderTester::CopyObjectL_prepare(
+ TMTPTypeRequest& aRequest )
+ {
+ PRINTF0( ">CMediaMtpDataProviderTester::CopyObjectL_prepare" );
+ TBool result = ETrue;
+ TUint32 storageId = KTestStorageId; // physical storage
+ aRequest.SetUint32( TMTPTypeRequest::ERequestParameter2, storageId );
+ PRINTF1( "<CMediaMtpDataProviderTester::CopyObjectL_prepare result = %d", result );
+ return result;
+ }
+
+TInt CMediaMtpDataProviderTester::CopyObjectL_checkresults(
+ const CMTPObjectMetaData* aMetaData )
+ {
+ PRINTF0( ">CMediaMtpDataProviderTester::CopyObjectL_checkresults" );
+ TInt result = KErrNone;
+ if ( !BaflUtils::FileExists( iFsSession, KCopyTestObjectPath ) )
+ {
+ PRINTE0( "Copied file does not exist" );
+ result = KErrGeneral;
+ }
+ else
+ {
+ TEntry entry;
+ result = iFsSession.Entry( KCopyTestObjectPath, entry );
+ if ( result != KErrNone )
+ {
+ PRINTE1( "Could not read file entry, error: %d", result );
+ }
+ else
+ {
+ if ( entry.iSize != KCopyTestFileSize )
+ {
+ PRINTE2( "Copied file size is incorrect: %d != %d", entry.iSize, KCopyTestFileSize );
+ result = KErrGeneral;
+ }
+ }
+ }
+
+ if ( aMetaData )
+ {
+ PRINTV1( "Suid: %S", &aMetaData->DesC( CMTPObjectMetaData::ESuid ) );
+
+ if ( aMetaData->Uint( CMTPObjectMetaData::EParentHandle ) != KMTPHandleNoParent )
+ {
+ PRINTV1( "Parent handle = %d", aMetaData->Uint( CMTPObjectMetaData::EParentHandle ) );
+ //TODO: parent handles don't work yet properly
+ //result = KErrGeneral;
+ }
+
+ if ( aMetaData->Int( CMTPObjectMetaData::EParentId ) != KErrNotFound )
+ {
+ PRINTV1( "Parent id = %d", aMetaData->Int( CMTPObjectMetaData::EParentId ) );
+ //TODO: parent ids don't work yet properly
+ //result = KErrGeneral;
+ }
+ if ( aMetaData->Uint( CMTPObjectMetaData::EDataProviderId ) != 0 )
+ {
+ PRINTV1( "Dataprovider id = %d", aMetaData->Uint( CMTPObjectMetaData::EDataProviderId ) );
+ //TODO: not sure if this is necessary
+ //result = KErrGeneral;
+ }
+ if ( aMetaData->Uint( CMTPObjectMetaData::EFormatCode ) != EMTPFormatCodeMP3 )
+ {
+ PRINTV1( "Format code = %d", aMetaData->Uint( CMTPObjectMetaData::EFormatCode ) );
+ result = KErrGeneral;
+ }
+ if ( aMetaData->Uint( CMTPObjectMetaData::EStorageId ) != KTestStorageId )
+ {
+ PRINTV1( "StorageId = %d ", aMetaData->Uint( CMTPObjectMetaData::EStorageId ) );
+ result = KErrGeneral;
+ }
+ if ( ( aMetaData->DesC( CMTPObjectMetaData::ESuid ) ).Match( KCopyTestObjectPath ) != 0 )
+ {
+ PRINTV0( "Copied object path incorrect" );
+ result = KErrGeneral;
+ }
+ }
+ else
+ {
+ PRINTV0( "Object metadata not received correctly" );
+ result = KErrArgument;
+ }
+ PRINTF1( "<CMediaMtpDataProviderTester::CopyObjectL_checkresults result = %d", result );
+ return result;
+ }
+
+TBool CMediaMtpDataProviderTester::MoveObjectL_prepare(
+ TMTPTypeRequest& aRequest )
+ {
+ PRINTF0( ">CMediaMtpDataProviderTester::MoveObjectL_prepare" );
+ TBool result = ETrue;
+ TUint32 storageId = KTestStorageId; // physical storage
+ aRequest.SetUint32( TMTPTypeRequest::ERequestParameter2, storageId );
+ PRINTF1( "<CMediaMtpDataProviderTester::MoveObjectL_prepare result = %d", result );
+ return result;
+ }
+
+TInt CMediaMtpDataProviderTester::MoveObjectL_checkresults( const CMTPObjectMetaData* aMetaData )
+ {
+ PRINTF0( ">CMediaMtpDataProviderTester::MoveObjectL_checkresults" );
+ TInt result = KErrNone;
+ if ( BaflUtils::FileExists( iFsSession, KMoveTestObjectOldPath ) )
+ {
+ PRINTE0( "Moved file still exists in original location" );
+ result = KErrGeneral;
+ }
+ if ( !BaflUtils::FileExists( iFsSession, KMoveTestObjectNewPath ) )
+ {
+ PRINTE0( "Moved file does not exist in new location" );
+ result = KErrGeneral;
+ }
+ else
+ {
+ TEntry entry;
+ result = iFsSession.Entry( KMoveTestObjectNewPath, entry );
+ if ( result != KErrNone )
+ {
+ PRINTE1( "Could not read file entry, error: %d", result );
+ }
+ else
+ {
+ if ( entry.iSize != KMoveTestFileSize )
+ {
+ PRINTE2( "Moved file size is incorrect: %d != %d", entry.iSize, KCopyTestFileSize );
+ result = KErrGeneral;
+ }
+ }
+ }
+
+ if ( aMetaData )
+ {
+ PRINTV1( "Suid: %S", &aMetaData->DesC( CMTPObjectMetaData::ESuid ) );
+
+ if ( aMetaData->Uint( CMTPObjectMetaData::EParentHandle ) != KMTPHandleNoParent )
+ {
+ PRINTV1( "Parent handle = %d", aMetaData->Uint( CMTPObjectMetaData::EParentHandle ) );
+ //TODO: parent handles don't work yet properly
+ //result = KErrGeneral;
+ }
+
+ if ( aMetaData->Int( CMTPObjectMetaData::EParentId ) != KErrNotFound )
+ {
+ PRINTV1( "Parent id = %d", aMetaData->Int( CMTPObjectMetaData::EParentId ) );
+ //TODO: parent ids don't work yet properly
+ //result = KErrGeneral;
+ }
+ if ( aMetaData->Uint( CMTPObjectMetaData::EDataProviderId ) != 0 )
+ {
+ PRINTV1( "Dataprovider id = %d", aMetaData->Uint( CMTPObjectMetaData::EDataProviderId ) );
+ //TODO: not sure if this is necessary
+ //result = KErrGeneral;
+ }
+ if ( aMetaData->Uint( CMTPObjectMetaData::EFormatCode ) != EMTPFormatCodeMP3 )
+ {
+ PRINTV1( "Format code = %d", aMetaData->Uint( CMTPObjectMetaData::EFormatCode ) );
+ result = KErrGeneral;
+ }
+ if ( aMetaData->Uint( CMTPObjectMetaData::EStorageId ) != KTestStorageId )
+ {
+ PRINTV1( "StorageId = %d ", aMetaData->Uint( CMTPObjectMetaData::EStorageId ) );
+ result = KErrGeneral;
+ }
+ if ( ( aMetaData->DesC( CMTPObjectMetaData::ESuid ) ).Match( KMoveTestObjectNewPath ) != 0 )
+ {
+ PRINTV0( "Copied object path incorrect" );
+ result = KErrGeneral;
+ }
+ }
+ else
+ {
+ PRINTV0( "Object metadata not received correctly" );
+ result = KErrArgument;
+ }
+ PRINTF1( "<CMediaMtpDataProviderTester::MoveObjectL_checkresults result = %d", result );
+ return KErrNone;
+ }
+
+TInt CMediaMtpDataProviderTester::GetPartialObjectL_checkresults( CMTPTypeFile *aObjectInfo )
+ {
+ PRINTF0( ">CMediaMtpDataProviderTester::GetPartialObjectL_checkresults" );
+ // just check the handle is correct, based on the size...
+ TInt result = KErrNone;
+ if ( aObjectInfo )
+ {
+ TInt size = aObjectInfo->Size();
+ __TRACE( KPrint, ( _L("Received object size: %d"), size ) );
+ if ( size != KTestFileSize )
+ {
+ __TRACE( KError, ( _L("Wrong received object size: %d != %d" ), KTestFileSize, size ) );
+ result = KErrGeneral;
+ }
+ aObjectInfo->File().Close();
+ }
+ else
+ {
+ __TRACE( KError, ( _L("Object info not received" ) ) );
+ result = KErrArgument;
+ }
+ PRINTF1( "<CMediaMtpDataProviderTester::GetPartialObjectL_checkresults result = %d", result );
+ return result;
+ }
+
+TBool CMediaMtpDataProviderTester::RenameObjectL_prepare( TMTPNotificationParamsHandle& aParam )
+ {
+ PRINTF0( ">CMediaMtpDataProviderTester::RenameObjectL_prepare" );
+ TBool result = ETrue;
+ TFileName fileName( KRenameObjectName );
+ aParam.iHandleId = KTestDirHandle;
+ aParam.iFileName = fileName;
+
+ TInt moveResult = iFileMan->Move( KTestDirPath, KRenameObjectPath,
+ CFileMan::ERecurse );
+ if ( moveResult != KErrNone )
+ {
+ PRINTE1( "Moving directory failed with error %d", moveResult );
+ }
+ CMTPObjectMetaData* metadata = CMTPObjectMetaData::NewLC();
+ iTestObserver->ObjectMgr().ObjectL( KTestDirPath, *metadata );
+ metadata->SetDesCL( CMTPObjectMetaData::ESuid, KRenameObjectPath );
+ iTestObserver->ObjectMgr().ModifyObjectL( *metadata );
+ CleanupStack::PopAndDestroy( metadata );
+ PRINTF1( "<CMediaMtpDataProviderTester::RenameObjectL_prepare result = %d", result );
+ return result;
+ }
+
+TInt CMediaMtpDataProviderTester::RenameObjectL_checkresults( const CMTPObjectMetaData* aMetaData )
+ {
+ PRINTF0( ">CMediaMtpDataProviderTester::RenameObjectL_checkresults" );
+ TInt result = KErrNone;
+
+ TMTPObjectMgrQueryParams queryParams ( KMTPStorageAll, KMTPFormatsAll, KMTPHandleNone );
+ RMTPObjectMgrQueryContext context;
+ RArray<TUint> handles;
+ CleanupClosePushL( handles );
+
+ iTestObserver->ObjectMgr().GetObjectHandlesL( queryParams, context, handles );
+ context.Close();
+ TInt count = handles.Count();
+ PRINTV1( "Handle count: %d", count );
+
+ CMTPObjectMetaData* metadata = CMTPObjectMetaData::NewLC();
+ for ( TInt i = 0; i < count; i++ )
+ {
+ TUint handle = handles[i];
+ iTestObserver->ObjectMgr().ObjectL( handle, *metadata );
+ TPtrC fileName = metadata->DesC( CMTPObjectMetaData::ESuid );
+ PRINTV1( "Handle: %d", handle );
+ PRINTV1( "File name: %S", &fileName );
+ }
+ CleanupStack::PopAndDestroy( 2 ); // metadata, handles
+ PRINTF1( "<CMediaMtpDataProviderTester::RenameObjectL_checkresults result = %d", result );
+ return result;
+ }
+
+TBool CMediaMtpDataProviderTester::GetObjectPropsSupportedL_prepare( TMTPTypeRequest& aRequest )
+ {
+ PRINTF0( ">CMediaMtpDataProviderTester::GetObjectPropsSupportedL_prepare" );
+ TBool result = ETrue;
+ aRequest.SetUint32( TMTPTypeRequest::ERequestParameter1, EMTPFormatCodeMP3 );
+ PRINTF1( "<CMediaMtpDataProviderTester::GetObjectPropsSupportedL_prepare result = %d", result );
+ return result;
+ }
+
+TInt CMediaMtpDataProviderTester::GetObjectPropsSupportedL_checkresults( const CMTPTypeArray* aObjectProps )
+ {
+ PRINTF0( ">CMediaMtpDataProviderTester::GetObjectPropsSupportedL_checkresults" );
+ TInt result = KErrNone;
+ TInt count = aObjectProps->NumElements();
+ PRINTV1( "Object props found: %d", count );
+ PRINTF1( "<CMediaMtpDataProviderTester::GetObjectPropsSupportedL_checkresults result = %d", result );
+ return result;
+ }
+
+TBool CMediaMtpDataProviderTester::ProcessRequestIllegalIdL_prepare(TInt aOpCode)
+ {
+ PRINTF0( ">CMediaMtpDataProviderTester::ProcessRequestIllegalIdL_prepare" );
+ // EMTPOpCodeGetObjectPropValue cannot be tested with the invalid session id, as the object
+ // must exist or the data provider fails in __ASSERT_DEBUG(aObjectInfo, Panic(EMTPPictureDpObjectNull));
+ TBool result = ETrue;
+ if ( aOpCode == EMTPOpCodeGetObjectPropValue )
+ {
+ result = EFalse;
+ }
+ PRINTF1( "<CMediaMtpDataProviderTester::ProcessRequestIllegalIdL_prepare result = %d", result );
+ return result;
+ }
+
+TInt CMediaMtpDataProviderTester::ProcessRequestIllegalIdL_checkresults(TInt aOpCode, TInt aResponseCode)
+ {
+ PRINTF0( ">CMediaMtpDataProviderTester::ProcessRequestIllegalIdL_checkresults" );
+ TInt result = KErrGeneral;
+ switch (aOpCode)
+ {
+ case EMTPOpCodeGetObjectInfo:
+ case EMTPOpCodeGetObject:
+ case EMTPOpCodeGetPartialObject:
+ case EMTPOpCodeGetThumb:
+ case EMTPOpCodeDeleteObject:
+ case EMTPOpCodeMoveObject:
+ case EMTPOpCodeCopyObject:
+ case EMTPOpCodeGetObjectPropsSupported:
+ case EMTPOpCodeGetObjectPropList:
+ case EMTPOpCodeGetObjectReferences:
+ if (aResponseCode == EMTPRespCodeSessionNotOpen)
+ {
+ result = KErrNone;
+ }
+ break;
+ case EMTPOpCodeSendObjectInfo:
+ case EMTPOpCodeSendObject:
+ case EMTPOpCodeSetObjectPropValue:
+ case EMTPOpCodeSetObjectPropList:
+ case EMTPOpCodeSendObjectPropList:
+ case EMTPOpCodeSetObjectReferences:
+ if (aResponseCode == 0)
+ {
+ result = KErrNone;
+ }
+ break;
+ case EMTPOpCodeGetObjectPropDesc:
+ if (aResponseCode == EMTPRespCodeInvalidObjectFormatCode)
+ {
+ result = KErrNone;
+ }
+ break;
+ case EMTPOpCodeGetDeviceInfo:
+ if (aResponseCode == EMTPRespCodeInvalidTransactionID)
+ {
+ result = KErrNone;
+ }
+ break;
+ default:
+ result = KErrNone;
+ break;
+ }
+ PRINTF1( "<CMediaMtpDataProviderTester::ProcessRequestIllegalIdL_checkresults result = %d", result );
+ return result;
+ }