FCL/sf/mw/mmappfw: comparison mmappcomponents/mmmtpdataprovider/src/cmmmtpdpmetadatavideoaccess.cpp

equal deleted inserted replaced

-:a05c44bc3c61
+:d881023c13eb
 /*
 * 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:  Meta data Video access
 *
 */
 #include <ContentListingFactory.h>
 #include <MCLFContentListingEngine.h>
 #include <driveinfo.h>
 #include <pathinfo.h>
 #include "cmmmtpdpmetadatavideoaccess.h"
 #include "mmmtpdplogger.h"
 #include "mmmtpdputility.h"
 #include "tmmmtpdppanic.h"
 #include "mmmtpvideodbdefs.h"
+#include "tobjectdescription.h"
-static const TInt KMtpMaxStringLength = 255;
-static const TInt KMtpMaxDescriptionLength = 0x200;
 const TInt KStorageRootMaxLength = 10;
 #ifdef _DEBUG
 static const TInt KMtpMaxStringDescLength = KMtpMaxStringLength - 1;
 #endif
 const TInt KMaxQueryLength = 512;
 const TInt KMtpCompactInterval = 50;  // Compact every ....
 CMmMtpDpMetadataVideoAccess* CMmMtpDpMetadataVideoAccess::NewL( RFs& aRfs )
 {
-CMmMtpDpMetadataVideoAccess* me = new(ELeave) CMmMtpDpMetadataVideoAccess( aRfs );
+CMmMtpDpMetadataVideoAccess* me = new( ELeave ) CMmMtpDpMetadataVideoAccess( aRfs );
-CleanupStack::PushL(me);
+CleanupStack::PushL( me );
 me->ConstructL();
-CleanupStack::Pop(me);
+CleanupStack::Pop( me );
 return me;
 }
-CMmMtpDpMetadataVideoAccess::CMmMtpDpMetadataVideoAccess( RFs& aRfs ) : iRfs(aRfs),
+CMmMtpDpMetadataVideoAccess::CMmMtpDpMetadataVideoAccess( RFs& aRfs ) :
-iDbState(ENoRecord),
+iRfs( aRfs ),
-iDbOpened(EFalse)
+iDbState( ENoRecord ),
-{
+iDbOpened( EFalse )
+{
-}
+// Do nothing
+}
-// ---------------------------------------------------------------------------
-// CMmMtpDpMetadataMpxAccess::ConstructL
+// ---------------------------------------------------------------------------
+// CMmMtpDpMetadataVideoAccess::ConstructL
 // Second-phase
 // ---------------------------------------------------------------------------
 //
 void CMmMtpDpMetadataVideoAccess::ConstructL()
 {
 iQueryText = HBufC::NewL( KMaxQueryLength );
 User::LeaveIfError( iDbsSession.Connect() );
-TInt err = DriveInfo::GetDefaultDrive( DriveInfo::EDefaultPhoneMemory,
+TInt err = DriveInfo::GetDefaultDrive( DriveInfo::EDefaultPhoneMemory, iStoreNum );
-iStoreNum );
 err = OpenDatabase();
 if ( KErrNone != err )
 {
 PRINT1( _L( "CMmMtpDpMetadataVideoAccess::ConstructL OpenDatabase err = %d" ), err );
 }
 }
 // ---------------------------------------------------------------------------
-// CMmMtpDpMetadataMpxAccess::OpenDatabase
+// CMmMtpDpMetadataVideoAccess::OpenDatabase
 // Open data base
 // ---------------------------------------------------------------------------
 //
 TInt CMmMtpDpMetadataVideoAccess::OpenDatabase()
 {
 PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::OpenDatabase" ) );
 return err;
 }
 // ---------------------------------------------------------------------------
-// CMmMtpDpMetadataMpxAccess::OpenDatabaseL
+// CMmMtpDpMetadataVideoAccess::OpenDatabaseL
 // Open data base
 // ---------------------------------------------------------------------------
 //
 void CMmMtpDpMetadataVideoAccess::OpenDatabaseL()
 {
 User::Leave( KErrGeneral );
 PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::OpenDatabaseL" ) );
 }
 // ---------------------------------------------------------------------------
-// CMmMtpDpMetadataMpxAccess::~CMmMtpDpMetadataVideoAccess
+// CMmMtpDpMetadataVideoAccess::~CMmMtpDpMetadataVideoAccess
 // Destructor
 // ---------------------------------------------------------------------------
 //
 CMmMtpDpMetadataVideoAccess::~CMmMtpDpMetadataVideoAccess()
 {
 iDbsSession.Close();
 delete iFileStore;
 }
 // ---------------------------------------------------------------------------
-// CMmMtpDpMetadataMpxAccess::CreateDatabaseTablesL
+// CMmMtpDpMetadataVideoAccess::CreateDatabaseTablesL
 // Case where a new memory card is used and the player has not been opened
 // ---------------------------------------------------------------------------
 //
 void CMmMtpDpMetadataVideoAccess::CreateDatabaseTablesL()
 {
 formatBuf.Append( KMtpVideoParentalRating );
 formatBuf.Append( KMtpVideoParentalRatingType );
 formatBuf.Append( KMtpVideoCommaSign );
-formatBuf.Append( KMtpVideoUseCount );
-formatBuf.Append( KMtpVideoUseCountType );
-formatBuf.Append( KMtpVideoCommaSign );
 formatBuf.Append( KMtpVideoDRM );
 formatBuf.Append( KMtpVideoDRMType );
 formatBuf.Append( KMtpVideoCommaSign );
 formatBuf.Append( KMtpVideoDeleted );
 User::LeaveIfError( iDatabase.Compact() );
 }
 }
 // ---------------------------------------------------------------------------
-// CMmMtpDpMetadataMpxAccess::CleanupDbIfNecessaryL
+// CMmMtpDpMetadataVideoAccess::CleanupDbIfNecessaryL
 // Cleanup Database
 // ---------------------------------------------------------------------------
 //
 void CMmMtpDpMetadataVideoAccess::CleanupDbIfNecessaryL()
 {
 iRecordSet.Close();
 PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::CleanupDbIfNecessaryL" ) );
 }
 // ---------------------------------------------------------------------------
-// CMmMtpDpMetadataMpxAccess::IdentifyDeletedFilesL
+// CMmMtpDpMetadataVideoAccess::IdentifyDeletedFilesL
 // Identify deleted files
 // ---------------------------------------------------------------------------
 //
 void CMmMtpDpMetadataVideoAccess::IdentifyDeletedFilesL()
 {
 PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::IdentifyDeletedFilesL" ) );
 ExecuteQueryL( KAllColumns, KMtpVideoTable, KMtpVideoLocation, KNullDesC, ETrue );
 PRINT1( _L( "MM MTP <> CleanupDbIfNecessaryL Database total count = %d" ), iRecordSet.CountL() );
-for ( iRecordSet.FirstL(); iRecordSet.AtRow(); iRecordSet.NextL( ))
+for ( iRecordSet.FirstL(); iRecordSet.AtRow(); iRecordSet.NextL() )
 {
 HBufC* data = ReadLongTextL( KMtpVideoLocation );
 CleanupStack::PushL( data );
 if ( !FileExists( *data ) )
 PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::IdentifyDeletedFilesL" ) );
 }
 // ---------------------------------------------------------------------------
-// CMmMtpDpMetadataMpxAccess::ReadLongTextL
+// CMmMtpDpMetadataVideoAccess::ReadLongTextL
 // Read from Data base
 // ---------------------------------------------------------------------------
 //
 HBufC* CMmMtpDpMetadataVideoAccess::ReadLongTextL( const TDesC& aColumn )
 {
 PRINT2( _L( "MM MTP <> ReadLongTextL Metadata value for %S is \"%S\"" ), &aColumn, buf );
 return buf;
 }
 // ---------------------------------------------------------------------------
-// CMmMtpDpMetadataMpxAccess::WriteLongTextL
+// CMmMtpDpMetadataVideoAccess::WriteLongTextL
 // Utility to write to the database
 // ---------------------------------------------------------------------------
 //
-void CMmMtpDpMetadataVideoAccess::WriteLongTextL( const TDesC& aColumn, const TDesC& aValue )
+void CMmMtpDpMetadataVideoAccess::WriteLongTextL( const TDesC& aColumn,
+const TDesC& aValue )
 {
 PRINT2( _L( "MM MTP <> WriteLongTextL Metadata value for %S is \"%S\"" ), &aColumn, &aValue );
 TDbColNo num = iColSet->ColNo( aColumn );
 RDbColWriteStream strm;
 strm.OpenLC( iRecordSet, num );
 strm.Close();
 CleanupStack::PopAndDestroy( &strm );
 }
 // ---------------------------------------------------------------------------
-// CMmMtpDpMetadataMpxAccess::ExecuteQueryL
+// CMmMtpDpMetadataVideoAccess::ExecuteQueryL
 // Executes a query on the database and sets the cursor at the start of the recordset
 // ---------------------------------------------------------------------------
 //
-void CMmMtpDpMetadataVideoAccess::ExecuteQueryL( const TDesC& aSelectThese, const TDesC& aFromTable,
+void CMmMtpDpMetadataVideoAccess::ExecuteQueryL( const TDesC& aSelectThese,
-const TDesC& aColumnToMatch, const TDesC& aMatchCriteria,
+const TDesC& aFromTable,
-const TBool aIfNot, const TBool aNeedQuotes )
+const TDesC& aColumnToMatch,
+const TDesC& aMatchCriteria,
+const TBool aIfNot,
+const TBool aNeedQuotes )
 {
 PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::ExecuteQueryL" ) );
 delete iColSet;
 iColSet = NULL;
 PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::ExecuteQueryL" ) );
 }
 // ---------------------------------------------------------------------------
-// CMmMtpDpMetadataMpxAccess::OpenSessionL
+// CMmMtpDpMetadataVideoAccess::OpenSessionL
 // Called when the MTP session is initialised
 // ---------------------------------------------------------------------------
 //
 void CMmMtpDpMetadataVideoAccess::OpenSessionL()
 {
+// Do nothing
 }
 // ---------------------------------------------------------------------------
-// CMmMtpDpMetadataMpxAccess::CloseSessionL
+// CMmMtpDpMetadataVideoAccess::CloseSessionL
 // Called when the MTP session is closed
 // ---------------------------------------------------------------------------
 //
 void CMmMtpDpMetadataVideoAccess::CloseSessionL()
 {
 PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::CloseSessionL" ) )
 }
 // ---------------------------------------------------------------------------
-// CMmMtpDpMetadataMpxAccess::AddVideoL
+// CMmMtpDpMetadataVideoAccess::AddVideoL
 // Adds video info to the database
 // ---------------------------------------------------------------------------
 //
 void CMmMtpDpMetadataVideoAccess::AddVideoL( const TDesC& aFullFileName )
 {
 // Defaults
 num = iColSet->ColNo( KMtpVideoLocation );
 iRecordSet.SetColL( num, aFullFileName );
 num = iColSet->ColNo( KMtpVideoName );
-iRecordSet.SetColL( num, aFullFileName );     // Default name is the filename.
+TParsePtrC parser( aFullFileName );
+iRecordSet.SetColL( num, parser.Name() ); // Default name is the filename.
 num = iColSet->ColNo( KMtpVideoArtist );
 iRecordSet.SetColL( num, KNullDesC );
 num = iColSet->ColNo( KMtpVideoTrack );
 iRecordSet.SetColL( num, 0 );
 num = iColSet->ColNo( KMtpVideoHeight );
 iRecordSet.SetColL( num, 0 );
-num = iColSet->ColNo(KMtpVideoDuration);
+num = iColSet->ColNo( KMtpVideoDuration );
-iRecordSet.SetColL(num, 0);
+iRecordSet.SetColL( num, 0 );
 num = iColSet->ColNo( KMtpVideoSampleRate );
 iRecordSet.SetColL( num, 0 );
 num = iColSet->ColNo( KMtpVideoNumberOfChannels );
 iRecordSet.SetColL( num, 0 );
 num = iColSet->ColNo( KMtpVideoVideoBitrate );
 iRecordSet.SetColL( num, 0 );
-num = iColSet->ColNo(KMtpVideoFramesPer1000Sec);
+num = iColSet->ColNo( KMtpVideoFramesPer1000Sec );
-iRecordSet.SetColL(num, 0);
+iRecordSet.SetColL( num, 0 );
 num = iColSet->ColNo( KMtpVideoKeyFrameDistance );
 iRecordSet.SetColL( num, 0 );
 num = iColSet->ColNo( KMtpVideoScanType );
 num = iColSet->ColNo( KMtpVideoEncodingProfile );
 iRecordSet.SetColL( num, KNullDesC );
 num = iColSet->ColNo( KMtpVideoParentalRating );
 iRecordSet.SetColL( num, KNullDesC );
-num = iColSet->ColNo( KMtpVideoUseCount );
-iRecordSet.SetColL( num, 0 );
 num = iColSet->ColNo( KMtpVideoDRM );
 iRecordSet.SetColL( num, 0 );
 }
 else
 CompactDbIfNecessaryL();
 PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::AddVideoL" ) );
 }
 // ---------------------------------------------------------------------------
-// CMmMtpDpMetadataMpxAccess::GetObjectMetadataValueL
+// CMmMtpDpMetadataVideoAccess::GetObjectMetadataValueL
 //  Gets a piece of metadata from the collection
 // ---------------------------------------------------------------------------
 //
 void CMmMtpDpMetadataVideoAccess::GetObjectMetadataValueL( const TUint16 aPropCode,
 MMTPType& aNewData,
 const CMTPObjectMetaData& aObjectMetaData )
 {
 PRINT1( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::GetObjectMetadataValue aPropCode = 0x%x" ), aPropCode );
 //open database if not opened
 if ( !IsDatabaseOpened() )
 HBufC* data = NULL;
 TDbColNo num;
 TUint32 uInt32 = 0;
 TUint16 uInt16 = 0;
-switch (aPropCode)
+switch ( aPropCode )
 {
 case EMTPObjectPropCodeName:
 {
 PRINT( _L( "MM MTP <> EMTPObjectPropCodeName-MD" ) );
 data = ReadLongTextL( KMtpVideoName );
 case EMTPObjectPropCodeDescription:
 {
 PRINT( _L( "MM MTP <> EMTPObjectPropCodeDescription-MD" ) );
 data = ReadLongTextL( KMtpVideoComment );
-if ( data->Length() != 0 )
+TInt len = data->Length();
-( ( CMTPTypeString& ) aNewData ).SetL( *data ) ;
+PRINT1( _L( "MM MTP <> CMmMtpDpMetadataMpxAccess::GetObjectMetadataValue len = %d" ),len );
-else
+if ( len != 0 )
-( ( TMTPTypeUint32 & ) aNewData ).Set( 0 );  // return zero if description is empty
+{
+for ( TInt i = 0; i < len; i++ )
+( ( CMTPTypeArray& ) aNewData ).AppendUintL( ( *data )[i] );
+}
 delete data;
 data = NULL;
 }
 break;
 {
 PRINT( _L( "MM MTP <> EMTPObjectPropCodeNumberOfChannels-MD" ) );
 num = iColSet->ColNo( KMtpVideoNumberOfChannels );
 uInt16 = iRecordSet.ColUint16( num );
 if ( EMTPTypeUINT16 == aNewData.Type() )
 {
 ( ( TMTPTypeUint16 & ) aNewData ).Set( uInt16 );
 }
 else
 {
 User::Leave( KErrArgument );
 }
 }
 break;
 case EMTPObjectPropCodeAudioWAVECodec:
 {
 {
 PRINT( _L( "MM MTP <> EMTPObjectPropCodeScanType-MD" ) );
 num = iColSet->ColNo( KMtpVideoScanType );
 uInt16 = iRecordSet.ColUint16( num );
 if ( EMTPTypeUINT16 == aNewData.Type() )
 {
 ( ( TMTPTypeUint16 & ) aNewData ).Set( uInt16 );
 }
 else
 {
 User::Leave( KErrArgument );
 }
 }
 break;
 case EMTPObjectPropCodeEncodingProfile:
 {
 case EMTPObjectPropCodeParentalRating:
 {
 PRINT( _L( "MM MTP <> EMTPObjectPropCodeParentalRating-MD" ) );
 data = ReadLongTextL( KMtpVideoParentalRating );
-}
-break;
-case EMTPObjectPropCodeUseCount:
-{
-PRINT( _L( "MM MTP <> EMTPObjectPropCodeUseCount-MD" ) );
-num = iColSet->ColNo( KMtpVideoUseCount );
-uInt32 = iRecordSet.ColUint32( num );
-if ( EMTPTypeUINT32 == aNewData.Type() )
-{
-( ( TMTPTypeUint32 & ) aNewData ).Set( uInt32 );
-}
-else
-{
-User::Leave( KErrArgument );
-}
 }
 break;
 case EMTPObjectPropCodeDRMStatus:
 {
 PRINT( _L( "MM MTP <> EMTPObjectPropCodeDRMStatus-MD" ) );
 num = iColSet->ColNo( KMtpVideoDRM );
 uInt16 = iRecordSet.ColUint16( num );
 if ( EMTPTypeUINT16 == aNewData.Type() )
 {
 ( ( TMTPTypeUint16 & ) aNewData ).Set( uInt16 );
 }
 else
 {
 User::Leave( KErrArgument );
 }
 }
 break;
 default:
 {
 }
 break;
 }
 // Pack the info to aNewData
-if (data)
+if ( data )
 {
 #ifdef _DEBUG
 if ( data->Length() > KMtpMaxStringDescLength )   // Have to concatenate for MTP
 {
 PRINT1( _L( "MM MTP <> Descriptor will be concatenated from length %d to KMtpMaxStringLength" ), data->Length() );
 PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::GetObjectMetadataValue" ) );
 }
 // ---------------------------------------------------------------------------
-// CMmMtpDpMetadataMpxAccess::SetObjectMetadataValueL
+// CMmMtpDpMetadataVideoAccess::SetObjectMetadataValueL
 // Sets a piece of metadata in the collection
 // ---------------------------------------------------------------------------
 //
 void CMmMtpDpMetadataVideoAccess::SetObjectMetadataValueL( const TUint16 aPropCode,
 const MMTPType& aNewData,
 if ( !IsDatabaseOpened() )
 OpenDatabaseL();
 // Get file path
 TPtrC suid( aObjectMetaData.DesC( CMTPObjectMetaData::ESuid ) );
-TParsePtrC parse( suid );
 SetRecordL( suid, ERecordWrite );
-TRAPD( err, SetMetadataL( aPropCode, aNewData ) );
+SetMetadataL( aPropCode, aNewData );
-if ( err < KErrNone ) // EPOC error condition
-{
-PRINT1( _L( "MM MTP <> Metadata write failed, with error %d" ), err );
-SetRecordL( suid, EFailedWrite );
-}
-if ( err != KErrNone )
-User::Leave( err );
 PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::SetObjectMetadataValueL" ) );
 }
 // ---------------------------------------------------------------------------
-// CMmMtpDpMetadataMpxAccess::SetMetadataL
+// CMmMtpDpMetadataVideoAccess::SetMetadataL
 // Set meta data.
 // ---------------------------------------------------------------------------
 //
 void CMmMtpDpMetadataVideoAccess::SetMetadataL( const TUint16 aObjPropCode,
 const MMTPType& aNewData )
 case EMTPObjectPropCodeComposer:
 case EMTPObjectPropCodeOriginalReleaseDate:
 case EMTPObjectPropCodeEncodingProfile:
 case EMTPObjectPropCodeParentalRating:
 {
-if( EMTPTypeString != aNewData.Type())
+if ( EMTPTypeString != aNewData.Type() )
 {
 User::Leave( KErrArgument );
 }
 TPtrC string( ( ( CMTPTypeString& ) aNewData ).StringChars() );
 WriteLongTextL( colName, string );
 case EMTPObjectPropCodeDescription:
 {
 PRINT( _L( "MM MTP <> EMTPObjectPropCodeDescription-MD" ) );
 #ifdef __MUSIC_ID_SUPPORT
-//WriteMusicIdsL(*longString);
+// WriteMusicIdsL(*longString);
 #else
 desData = CMTPTypeArray::NewLC( EMTPTypeAUINT16 ); // + desData
 MMTPType::CopyL( aNewData, *desData );
 TUint length = desData->NumElements();
-PRINT1( _L( "MM MTP <> CMmMtpDpMetadataMpxAccess::SetMetadataValueL length = %d" ), length );
+PRINT1( _L( "MM MTP <> CMmMtpDpMetadataMpxAccess::SetMetadataValueL length = %d" ),
+length );
 if ( length != 0 )
 {
-TBuf<KMtpMaxDescriptionLength> text;
+length = ( length < KMTPMaxDescriptionLen ) ? length : KMTPMaxDescriptionLen;
-text.Zero();
+HBufC* text = HBufC::NewLC( length );    // + text
+TPtr ptr = text->Des();
 for ( TUint i = 0; i < length; i++ )
-{
+ptr.Append( desData->ElementUint( i ) );
-text.Append( desData->ElementUint( i ) );
-}
 PRINT1( _L( "MM MTP <> CMmMtpDpMetadataMpxAccess::SetMetadataValueL text = %S" ),
-&text );
+text );
-WriteLongTextL( KMtpVideoComment, text );
+WriteLongTextL( KMtpVideoComment, *text );
+CleanupStack::PopAndDestroy( text );    // - text
 }
 else
 {
 WriteLongTextL( KMtpVideoComment, KEmptyText );
 }
 case EMTPObjectPropCodeAudioBitRate:
 case EMTPObjectPropCodeVideoFourCCCodec:
 case EMTPObjectPropCodeVideoBitRate:
 case EMTPObjectPropCodeFramesPerThousandSeconds:
 case EMTPObjectPropCodeKeyFrameDistance:
-case EMTPObjectPropCodeUseCount:
 {
 if ( EMTPTypeUINT32 != aNewData.Type() )
 {
 User::Leave( KErrArgument );
 }
 PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::SetMetadataL" ) );
 }
 // ---------------------------------------------------------------------------
-// CMmMtpDpMetadataMpxAccess::RenameRecordL
+// CMmMtpDpMetadataVideoAccess::RenameRecordL
 // Renames the file part of a record in the collection database.
 // ---------------------------------------------------------------------------
 //
-void CMmMtpDpMetadataVideoAccess::RenameRecordL(const TDesC& aOldFileName, const TDesC& aNewFileName)
+void CMmMtpDpMetadataVideoAccess::RenameRecordL( const TDesC& aOldFileName,
+const TDesC& aNewFileName )
 {
 PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::RenameRecordL()" ) );
 //open database if not opened
 if ( !IsDatabaseOpened() )
 PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::RenameRecordL()" ) );
 }
 // ---------------------------------------------------------------------------
-// CMmMtpDpMetadataMpxAccess::DeleteRecordL
+// CMmMtpDpMetadataVideoAccess::DeleteRecordL
 // Deletes metadata information associated with the object
 // ---------------------------------------------------------------------------
 //
 void CMmMtpDpMetadataVideoAccess::DeleteRecordL( const TDesC& aFullFileName )
 {
 }
 PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::DeleteRecordL" ) );
 }
 // ---------------------------------------------------------------------------
-// CMmMtpDpMetadataMpxAccess::DeleteAllRecordsL
+// CMmMtpDpMetadataVideoAccess::DeleteAllRecordsL
 // Empties the database - used by the FormatStore command
 // ---------------------------------------------------------------------------
 //
 void CMmMtpDpMetadataVideoAccess::DeleteAllRecordsL()
 {
 PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::DeleteAllRecordsL()" ) );
 //open database if not opened
-if (!IsDatabaseOpened())
+if ( !IsDatabaseOpened() )
 OpenDatabaseL();
 SetRecordL( KNullDesC, ENoRecord );   // Commit any other changes to the DB
 PRINT( _L( "MM MTP <> Deleting music files" ) );
 iDatabase.Compact();
 PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::DeleteAllRecordsL()" ) );
 }
 // ---------------------------------------------------------------------------
-// CMmMtpDpMetadataMpxAccess::SetRecordL
+// CMmMtpDpMetadataVideoAccess::SetRecordL
 // Set Record
 // ---------------------------------------------------------------------------
 //
-void CMmMtpDpMetadataVideoAccess::SetRecordL( const TDesC& aFullFileName, TMtpDbState aState )
+void CMmMtpDpMetadataVideoAccess::SetRecordL( const TDesC& aFullFileName,
+TMtpDbState aState )
 {
 PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::SetRecordL()" ) );
 if ( ( aState == iDbState )
 && ( 0 == aFullFileName.Compare( iCurrentFileName ) ) )    // Already have it
 {
-if (iDbState == ERecordRead)
+if ( iDbState == ERecordRead )
 iRecordSet.GetL();
 PRINT1( _L( "MM MTP <> Cached recordset, filename is '%S'" ), &iCurrentFileName );
 return;
 }
 case ERecordWrite:              // intentionally fallthrough
 // We wrote some stuff to the db, now needs comitting
 PRINT( _L( "MM MTP <> SetRecordL ERecordWrite" ) );
 TRAPD( err, iRecordSet.PutL() );
-if (KErrNone != err)
+if ( KErrNone != err )
 {
 iRecordSet.Cancel();
 User::Leave( err );
 }
 //lint -fallthrough
 case ENoRecord:                 // intentionally fallthrough
 // We need to just close the open record
 PRINT( _L( "MM MTP <> SetRecordL ENoRecord" ) );
 //lint -fallthrough
 case ERecordRead:               // intentionally fallthrough
 // We need to open a row for reading
 PRINT( _L( "MM MTP <> SetRecordL ERecordRead" ) );
 //lint -fallthrough
 default:                        // intentionally fallthrough
 PRINT( _L( "MM MTP <> SetRecordL Closing recordset" ) );
 delete iColSet;
 iColSet = NULL;
 iRecordSet.Close();
 iDbState = ENoRecord;
 break;
 }
-if ( aState == ENoRecord )    // We are closing the session if this is the case
+if ( aState == ENoRecord ) // We are closing the session if this is the case
 {
 PRINT( _L( "MM MTP <> SetRecordL Record closed, no request to open" ) );
 return;
 }
 // if we have a music format, we can open the database...
 TUint16 format = MmMtpDpUtility::FormatFromFilename( iCurrentFileName );
 PRINT1( _L( "MM MTP <> SetRecordL format = 0x%x" ), format );
 if ( MmMtpDpUtility::HasMetadata( format ) )
 {
 // Get the record
 ExecuteQueryL( KAllColumns, KMtpVideoTable, KMtpVideoLocation, aFullFileName );
 PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::SetRecordL()" ) );
 }
 // ---------------------------------------------------------------------------
-// CMmMtpDpMetadataMpxAccess::SetImageObjPropL
+// CMmMtpDpMetadataVideoAccess::SetImageObjPropL
 // set image specific properties specific to videos
 // ---------------------------------------------------------------------------
 //
 void CMmMtpDpMetadataVideoAccess::SetImageObjPropL( const TDesC& aFullFileName,
 const TUint32 aWidth,
 SetRecordL( aFullFileName, ERecordWrite );
 num = iColSet->ColNo( KMtpVideoWidth );
 TRAP( err, iRecordSet.SetColL( num, aWidth ) );
 if ( err != KErrNone )
 {
 SetRecordL( aFullFileName, EFailedWrite );
 User::Leave( err );
 }
 num = iColSet->ColNo( KMtpVideoHeight );
 TRAP( err, iRecordSet.SetColL( num, aHeight ) );
 if ( err != KErrNone )
 {
 SetRecordL( aFullFileName, EFailedWrite );
 User::Leave( err );
 }
 PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::SetImageObjPropL()" ) );
 }
 // ---------------------------------------------------------------------------
-// CMmMtpDpMetadataMpxAccess::GetImageObjPropL
+// CMmMtpDpMetadataVideoAccess::GetImageObjPropL
 // Get image specific properties specific to videos
 // ---------------------------------------------------------------------------
 //
 void CMmMtpDpMetadataVideoAccess::GetImageObjPropL( const TDesC& aFullFileName,
 TUint32& aWidth,
 }
 const TDesC& CMmMtpDpMetadataVideoAccess::ColumnNameFromPropCodeL( const TUint16 aPropCode )
 {
 const TColumnNameTable KColumnTable[] =
 {
 { EMTPObjectPropCodeName,                    KMtpVideoName },
 { EMTPObjectPropCodeArtist,                  KMtpVideoArtist },
 { EMTPObjectPropCodeTrack,                   KMtpVideoTrack },
 { EMTPObjectPropCodeGenre,                   KMtpVideoGenre },
 { EMTPObjectPropCodeAlbumName,               KMtpVideoAlbumName },
 { EMTPObjectPropCodeComposer,                KMtpVideoComposer },
 { EMTPObjectPropCodeOriginalReleaseDate,     KMtpVideoOrigReleaseDate },
 { EMTPObjectPropCodeDescription,             KMtpVideoComment },
 { EMTPObjectPropCodeWidth,                   KMtpVideoWidth },
 { EMTPObjectPropCodeHeight,                  KMtpVideoHeight },
 { EMTPObjectPropCodeDuration,                KMtpVideoDuration },
 { EMTPObjectPropCodeSampleRate,              KMtpVideoSampleRate },
 { EMTPObjectPropCodeNumberOfChannels,        KMtpVideoNumberOfChannels },
 { EMTPObjectPropCodeAudioBitRate,            KMtpVideoAudioBitrate },
 { EMTPObjectPropCodeVideoFourCCCodec,        KMtpVideoVideoCodec },
 { EMTPObjectPropCodeVideoBitRate,            KMtpVideoVideoBitrate },
 { EMTPObjectPropCodeFramesPerThousandSeconds,KMtpVideoFramesPer1000Sec },
 { EMTPObjectPropCodeKeyFrameDistance,        KMtpVideoKeyFrameDistance },
 { EMTPObjectPropCodeScanType,                KMtpVideoScanType },
 { EMTPObjectPropCodeEncodingProfile,         KMtpVideoEncodingProfile },
 { EMTPObjectPropCodeParentalRating,          KMtpVideoParentalRating },
-{ EMTPObjectPropCodeUseCount,                KMtpVideoUseCount },
+{ EMTPObjectPropCodeAudioWAVECodec,          KMtpVideoAudioCodec },
-{ EMTPObjectPropCodeAudioWAVECodec,          KMtpVideoAudioCodec },
+{ EMTPObjectPropCodeDRMStatus,               KMtpVideoDRM },
-{ EMTPObjectPropCodeDRMStatus,               KMtpVideoDRM },
+};
-};
 TInt i = 0;
-TInt count = sizeof ( KColumnTable ) / sizeof ( KColumnTable[0] );
+TInt count = sizeof( KColumnTable ) / sizeof( KColumnTable[0] );
 while ( ( KColumnTable[i].iPropCode != aPropCode ) && ( i < count ) )
 {
 i++;
 }
 if ( i == count )
 {
 // Not supported by MPX, shouldn't call this function
-PRINT( _L( "MM MTP <> CMmMtpDpMetadataMpxAccess::MpxAttribFromPropL NOT SUPPORTED ATTRIBUTE" ) );
+PRINT( _L( "MM MTP <> CMmMtpDpMetadataVideoAccess::ColumnNameFromPropCodeL NOT SUPPORTED ATTRIBUTE" ) );
 User::Leave( KErrNotSupported );
 }
 return KColumnTable[i].iDbColumnName;
 }
 void CMmMtpDpMetadataVideoAccess::SetStorageRootL( const TDesC& aStorageRoot )
 {
-PRINT1( _L( "MM MTP => CMmMtpDpMetadataMpxAccess::SetStorageRoot aStoreRoot = %S" ), &aStorageRoot );
+PRINT1( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::SetStorageRoot aStoreRoot = %S" ), &aStorageRoot );
 // get the drive number
-TParse pathParser;
+TParsePtrC pathParser( aStorageRoot );
-User::LeaveIfError( pathParser.Set( aStorageRoot, NULL, NULL ) );
 TChar driveChar( pathParser.Drive()[0] );
 User::LeaveIfError( RFs::CharToDrive( driveChar, iStoreNum ) );
-PRINT1( _L( "MM MTP <= CMmMtpDpMetadataMpxAccess::SetStorageRoot drive number = %d" ), iStoreNum );
+PRINT1( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::SetStorageRoot drive number = %d" ), iStoreNum );
 }
 void CMmMtpDpMetadataVideoAccess::CleanupDatabaseL()
 {
 PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::CleanupDatabaseL" ) );

changeset 25	d881023c13eb
parent 20	b1fb57be53fe
child 50	762d760dcfdf