diff -r 000000000000 -r a2952bb97e68 mmappcomponents/mmmtpdataprovider/src/cmmmtpdpmetadatavideoaccess.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmappcomponents/mmmtpdataprovider/src/cmmmtpdpmetadatavideoaccess.cpp Thu Dec 17 08:55:47 2009 +0200 @@ -0,0 +1,1560 @@ +/* +* 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 +#include +#include +#include +#include + +// from Symbian MTP +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "cmmmtpdpmetadatavideoaccess.h" +#include "mmmtpdplogger.h" +#include "mmmtpdputility.h" +#include "tmmmtpdppanic.h" +#include "mmmtpvideodbdefs.h" + +static const TInt KMtpMaxStringLength = 255; +static const TInt KMtpMaxDescriptionLength = 0x200; +const TInt KStorageRootMaxLength = 10; + +#ifdef _DEBUG +static const TInt KMtpMaxStringDescLength = KMtpMaxStringLength - 1; +#endif + +_LIT( KEmptyText, "" ); +// Database interface +_LIT( KSelect, "SELECT " ); +_LIT( KAllColumns, "*" ); +_LIT( KFrom, " FROM " ); +_LIT( KWhere, " WHERE " ); +_LIT( KNot, " NOT " ); +_LIT( KEquals, " = " ); +_LIT( KTrue, "1" ); + +const TInt KMaxQueryLength = 512; +const TInt KMtpCompactInterval = 50; // Compact every .... + +CMmMtpDpMetadataVideoAccess* CMmMtpDpMetadataVideoAccess::NewL( RFs& aRfs ) + { + CMmMtpDpMetadataVideoAccess* me = new(ELeave) CMmMtpDpMetadataVideoAccess( aRfs ); + CleanupStack::PushL(me); + me->ConstructL(); + CleanupStack::Pop(me); + + return me; + } + +CMmMtpDpMetadataVideoAccess::CMmMtpDpMetadataVideoAccess( RFs& aRfs ) : iRfs(aRfs), + iDbState(ENoRecord), + iDbOpened(EFalse) + { + + } + +// --------------------------------------------------------------------------- +// CMmMtpDpMetadataMpxAccess::ConstructL +// Second-phase +// --------------------------------------------------------------------------- +// +void CMmMtpDpMetadataVideoAccess::ConstructL() + { + iQueryText = HBufC::NewL( KMaxQueryLength ); + + User::LeaveIfError( iDbsSession.Connect() ); + + TInt err = DriveInfo::GetDefaultDrive( DriveInfo::EDefaultPhoneMemory, + iStoreNum ); + + err = OpenDatabase(); + + if ( KErrNone != err ) + { + PRINT1( _L( "CMmMtpDpMetadataVideoAccess::ConstructL OpenDatabase err = %d" ), err ); + } + } + +// --------------------------------------------------------------------------- +// CMmMtpDpMetadataMpxAccess::OpenDatabase +// Open data base +// --------------------------------------------------------------------------- +// +TInt CMmMtpDpMetadataVideoAccess::OpenDatabase() + { + PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::OpenDatabase" ) ); + + iRfs.CreatePrivatePath( iStoreNum ); + TInt err = iRfs.SetSessionToPrivate( iStoreNum ); + + if ( err == KErrNone ) + { + TRAP( err, iFileStore = CPermanentFileStore::OpenL( iRfs, KMtpVideoDb, EFileRead | EFileWrite ) ); + + if ( err == KErrNone ) + TRAP( err, iFileStore->SetTypeL( iFileStore->Layout() ) ); + + if ( err == KErrNone ) + { + TRAP( err, iDatabase.OpenL( iFileStore, iFileStore->Root() ) ); + PRINT1( _L( "MM MTP <> OpenDatabase RDbNamedDatabase::OpenL, err = %d" ), err ); + } + + if ( err != KErrNone ) + { + iRfs.Delete( KMtpVideoDb ); // delete first before creating a new one + TRAP( err, iFileStore = CPermanentFileStore::CreateL( iRfs, KMtpVideoDb, EFileRead | EFileWrite ) ); + PRINT1( _L( "MM MTP <> OpenDatabase RDbNamedDatabase::CreateL, err = %d" ), err ); + + if ( err == KErrNone ) + { + TRAP( err, iFileStore->SetTypeL( iFileStore->Layout() ) ); + + TStreamId streamId = 0; + + if ( err == KErrNone ) + TRAP( err, streamId = iDatabase.CreateL( iFileStore ) ); + + if ( err == KErrNone ) + TRAP( err, iFileStore->SetRootL( streamId ) ); + + if ( err == KErrNone ) + TRAP( err, CreateDatabaseTablesL() ); + + if ( KErrNone != err ) + { + iDatabase.Close(); + iRfs.Delete( KMtpVideoDb ); + } + } + } + } + + TBuf storeRoot; + err = PathInfo::GetRootPath( storeRoot, iStoreNum ); + iRfs.SetSessionPath( storeRoot ); + + if ( err == KErrNone ) + { + iDbOpened = ETrue; + } + + PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::OpenDatabase" ) ); + return err; + } + +// --------------------------------------------------------------------------- +// CMmMtpDpMetadataMpxAccess::OpenDatabaseL +// Open data base +// --------------------------------------------------------------------------- +// +void CMmMtpDpMetadataVideoAccess::OpenDatabaseL() + { + PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::OpenDatabaseL" ) ); + if ( OpenDatabase() != KErrNone ) + User::Leave( KErrGeneral ); + PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::OpenDatabaseL" ) ); + } + +// --------------------------------------------------------------------------- +// CMmMtpDpMetadataMpxAccess::~CMmMtpDpMetadataVideoAccess +// Destructor +// --------------------------------------------------------------------------- +// +CMmMtpDpMetadataVideoAccess::~CMmMtpDpMetadataVideoAccess() + { + delete iQueryText; + delete iColSet; + iRecordSet.Close(); + iDatabase.Close(); + iDbsSession.Close(); + delete iFileStore; + } + +// --------------------------------------------------------------------------- +// CMmMtpDpMetadataMpxAccess::CreateDatabaseTablesL +// Case where a new memory card is used and the player has not been opened +// --------------------------------------------------------------------------- +// +void CMmMtpDpMetadataVideoAccess::CreateDatabaseTablesL() + { + PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::CreateDatabaseTablesL" ) ); + // Video table + RBuf formatBuf; + User::LeaveIfError( formatBuf.Create( 5 * KMaxQueryLength ) ); + CleanupClosePushL( formatBuf ); // + foramtBuf + + formatBuf.Append( KMtpVideoStartCreateTable ); + formatBuf.Append( KMtpVideoTable ); + formatBuf.Append( KMtpVideoOpenBracket ); + + formatBuf.Append( KMtpVideoLocation ); + formatBuf.Append( KMtpVideoLocationType ); + formatBuf.Append( KMtpVideoCommaSign ); + + formatBuf.Append( KMtpVideoName ); + formatBuf.Append( KMtpVideoNameType ); + formatBuf.Append( KMtpVideoCommaSign ); + + formatBuf.Append( KMtpVideoArtist ); + formatBuf.Append( KMtpVideoArtistType ); + formatBuf.Append( KMtpVideoCommaSign ); + + formatBuf.Append( KMtpVideoTrack ); + formatBuf.Append( KMtpVideoTrackType ); + formatBuf.Append( KMtpVideoCommaSign ); + + formatBuf.Append( KMtpVideoGenre ); + formatBuf.Append( KMtpVideoGenreType ); + formatBuf.Append( KMtpVideoCommaSign ); + + formatBuf.Append( KMtpVideoAlbumName ); + formatBuf.Append( KMtpVideoAlbumNameType ); + formatBuf.Append( KMtpVideoCommaSign ); + + formatBuf.Append( KMtpVideoComposer ); + formatBuf.Append( KMtpVideoComposerType ); + formatBuf.Append( KMtpVideoCommaSign ); + + formatBuf.Append( KMtpVideoOrigReleaseDate ); + formatBuf.Append( KMtpVideoOrigReleaseDateType ); + formatBuf.Append( KMtpVideoCommaSign ); + + formatBuf.Append( KMtpVideoComment ); + formatBuf.Append( KMtpVideoCommentType ); + formatBuf.Append( KMtpVideoCommaSign ); + + formatBuf.Append( KMtpVideoWidth ); + formatBuf.Append( KMtpVideoWidthType ); + formatBuf.Append( KMtpVideoCommaSign ); + + formatBuf.Append( KMtpVideoHeight ); + formatBuf.Append( KMtpVideoHeightType ); + formatBuf.Append( KMtpVideoCommaSign ); + + formatBuf.Append( KMtpVideoDuration ); + formatBuf.Append( KMtpVideoDurationType ); + formatBuf.Append( KMtpVideoCommaSign ); + + formatBuf.Append( KMtpVideoSampleRate ); + formatBuf.Append( KMtpVideoSampleRateType ); + formatBuf.Append( KMtpVideoCommaSign ); + + formatBuf.Append( KMtpVideoNumberOfChannels ); + formatBuf.Append( KMtpVideoNumberOfChannelsType ); + formatBuf.Append( KMtpVideoCommaSign ); + + formatBuf.Append( KMtpVideoAudioCodec ); + formatBuf.Append( KMtpVideoAudioCodecType ); + formatBuf.Append( KMtpVideoCommaSign ); + + formatBuf.Append( KMtpVideoAudioBitrate ); + formatBuf.Append( KMtpVideoAudioBitrateType ); + formatBuf.Append( KMtpVideoCommaSign ); + + formatBuf.Append( KMtpVideoVideoCodec ); + formatBuf.Append( KMtpVideoVideoCodecType ); + formatBuf.Append( KMtpVideoCommaSign ); + + formatBuf.Append( KMtpVideoVideoBitrate ); + formatBuf.Append( KMtpVideoVideoBitrateType ); + formatBuf.Append( KMtpVideoCommaSign ); + + formatBuf.Append( KMtpVideoFramesPer1000Sec ); + formatBuf.Append( KMtpVideoFramesPer1000SecType ); + formatBuf.Append( KMtpVideoCommaSign ); + + formatBuf.Append( KMtpVideoKeyFrameDistance ); + formatBuf.Append( KMtpVideoKeyFrameDistanceType ); + formatBuf.Append( KMtpVideoCommaSign ); + + formatBuf.Append( KMtpVideoScanType ); + formatBuf.Append( KMtpVideoScanTypeType ); + formatBuf.Append( KMtpVideoCommaSign ); + + formatBuf.Append( KMtpVideoEncodingProfile ); + formatBuf.Append( KMtpVideoEncodingProfileType ); + formatBuf.Append( KMtpVideoCommaSign ); + + 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 ); + formatBuf.Append( KMtpVideoDeletedType ); + formatBuf.Append( KMtpVideoCloseBracket ); + + // Execute the SQL statement. + User::LeaveIfError( iDatabase.Execute( formatBuf ) ); + PRINT( _L( "MM MTP <> Video Table Created" ) ); + + CleanupStack::PopAndDestroy( &formatBuf ); // - foramtBuf + PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::CreateDatabaseTablesL" ) ); + } + +// For performance, better to regularly compact the MC database. +void CMmMtpDpMetadataVideoAccess::CompactDbIfNecessaryL() + { + iRecordCount++; + + if ( iRecordCount > KMtpCompactInterval ) + { + iRecordCount = 0; + + PRINT( _L( "MM MTP <> Compacting database file..." ) ); + + if ( IsDatabaseOpened() ) + User::LeaveIfError( iDatabase.Compact() ); + } + } + +// --------------------------------------------------------------------------- +// CMmMtpDpMetadataMpxAccess::CleanupDbIfNecessaryL +// Cleanup Database +// --------------------------------------------------------------------------- +// +void CMmMtpDpMetadataVideoAccess::CleanupDbIfNecessaryL() + { + PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::CleanupDbIfNecessaryL" ) ); + + ExecuteQueryL( KAllColumns, KMtpVideoTable, KMtpVideoDeleted, KTrue, EFalse, EFalse ); + PRINT1( _L( "MM MTP <> CleanupDbIfNecessaryL Database deleted count = %d" ), iRecordSet.CountL() ); + + for ( iRecordSet.FirstL(); iRecordSet.AtRow(); iRecordSet.NextL() ) + { + HBufC* data = ReadLongTextL( KMtpVideoLocation ); + CleanupStack::PushL( data ); + + PRINT1( _L( "MM MTP <> CleanupDbIfNecessaryL removing %S from database" ), data ); + iRecordSet.DeleteL(); + CleanupStack::PopAndDestroy( data ); + } + + delete iColSet; + iColSet = NULL; + iRecordSet.Close(); + PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::CleanupDbIfNecessaryL" ) ); + } + +// --------------------------------------------------------------------------- +// CMmMtpDpMetadataMpxAccess::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( )) + { + HBufC* data = ReadLongTextL( KMtpVideoLocation ); + CleanupStack::PushL( data ); + + if ( !FileExists( *data ) ) + { + iRecordSet.UpdateL(); + PRINT1( _L( "MM MTP <> IdentifyDeletedFilesL marking %S as deleted" ), data ); + + TDbColNo num = iColSet->ColNo( KMtpVideoDeleted ); + + iRecordSet.SetColL( num, 1 ); + iRecordSet.PutL(); + } + + CleanupStack::PopAndDestroy( data ); + } + + delete iColSet; + iColSet = NULL; + iRecordSet.Close(); + + PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::IdentifyDeletedFilesL" ) ); + } + +// --------------------------------------------------------------------------- +// CMmMtpDpMetadataMpxAccess::ReadLongTextL +// Read from Data base +// --------------------------------------------------------------------------- +// +HBufC* CMmMtpDpMetadataVideoAccess::ReadLongTextL( const TDesC& aColumn ) + { + TDbColNo num = iColSet->ColNo( aColumn ); + + // The row must have previously been read into the rowset + // using RDbRowSet::GetL(). + iRecordSet.GetL(); + + TInt len = iRecordSet.ColLength( num ); + + HBufC* buf = HBufC::NewLC( len ); // + buf + TPtr value( buf->Des() ); + + if ( len > 0 ) + { + RDbColReadStream strm; + strm.OpenLC( iRecordSet, num ); + strm.ReadL( value, len ); + strm.Close(); + CleanupStack::PopAndDestroy( &strm ); + } + else + { + value.SetLength( 0 ); + } + + CleanupStack::Pop( buf ); // - buf + PRINT2( _L( "MM MTP <> ReadLongTextL Metadata value for %S is \"%S\"" ), &aColumn, buf ); + return buf; + } + +// --------------------------------------------------------------------------- +// CMmMtpDpMetadataMpxAccess::WriteLongTextL +// Utility to write to the database +// --------------------------------------------------------------------------- +// +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.WriteL( aValue ); + strm.Close(); + CleanupStack::PopAndDestroy( &strm ); + } + +// --------------------------------------------------------------------------- +// CMmMtpDpMetadataMpxAccess::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, + const TDesC& aColumnToMatch, const TDesC& aMatchCriteria, + const TBool aIfNot, const TBool aNeedQuotes ) + { + PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::ExecuteQueryL" ) ); + + delete iColSet; + iColSet = NULL; + iRecordSet.Close(); + //__ASSERT_DEBUG(!iColSet, _MTP_PANIC(KMtpPrtPncCat, ENullPointer)); // Must have iColSet == NULL + + // Make sure any quotes in the aMatchCriteria are doubled... + HBufC* matchText = HBufC::NewLC( 2 * aMatchCriteria.Length() ); + TPtr pMatchText( matchText->Des() ); + TInt srcLen = aMatchCriteria.Length(); + TPtrC ch; + + for ( TInt i = 0; i < srcLen; ++i ) + { + ch.Set( &aMatchCriteria[i], 1 ); + pMatchText.Append( ch ); + + if ( ch.CompareF( KMtpVideoSingleQuote ) == 0 ) + { + pMatchText.Append( ch ); + } + } + + TPtr query( iQueryText->Des() ); + query.Zero(); + query.Append( KSelect ); + query.Append( aSelectThese ); + query.Append( KFrom ); + query.Append( aFromTable ); + + if ( aColumnToMatch.Length() != 0 ) + { + query.Append( KWhere ); + + if ( aIfNot ) + query.Append( KNot ); + + query.Append( aColumnToMatch ); + query.Append( KEquals ); + + if ( aNeedQuotes ) + query.Append( KMtpVideoSingleQuote ); + + query.Append( *matchText ); + + if ( aNeedQuotes ) + query.Append( KMtpVideoSingleQuote ); + } + + TDbQuery dbQuery( query ); + PRINT1( _L( "MM MTP <> ExecuteQueryL Query is \"%S\"" ), &query ); + + // Execute the query + User::LeaveIfError( iRecordSet.Prepare( iDatabase, dbQuery ) ); + User::LeaveIfError( iRecordSet.EvaluateAll() ); + iRecordSet.FirstL(); + iColSet = iRecordSet.ColSetL(); + CleanupStack::PopAndDestroy( matchText ); + + PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::ExecuteQueryL" ) ); + } + +// --------------------------------------------------------------------------- +// CMmMtpDpMetadataMpxAccess::OpenSessionL +// Called when the MTP session is initialised +// --------------------------------------------------------------------------- +// +void CMmMtpDpMetadataVideoAccess::OpenSessionL() + { + + } + +// --------------------------------------------------------------------------- +// CMmMtpDpMetadataMpxAccess::CloseSessionL +// Called when the MTP session is closed +// --------------------------------------------------------------------------- +// +void CMmMtpDpMetadataVideoAccess::CloseSessionL() + { + PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::CloseSessionL" ) ); + + //open database if not opened + if ( !IsDatabaseOpened() ) + return; + + // Make sure the db is commited + SetRecordL( KNullDesC, ENoRecord ); + + CleanupDbIfNecessaryL(); + + PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::CloseSessionL" ) ) + } + +// --------------------------------------------------------------------------- +// CMmMtpDpMetadataMpxAccess::AddVideoL +// Adds video info to the database +// --------------------------------------------------------------------------- +// +void CMmMtpDpMetadataVideoAccess::AddVideoL( const TDesC& aFullFileName ) + { + PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::AddVideoL" ) ); + + //open database if not opened + if ( !IsDatabaseOpened() ) + OpenDatabaseL(); + + // Put any outstanding changes to the DB + SetRecordL( KNullDesC, ENoRecord ); + TDbColNo num = 0; + + // Does a record already exist for this playlist? + ExecuteQueryL( KAllColumns, KMtpVideoTable, KMtpVideoLocation, aFullFileName ); + + if ( iRecordSet.CountL() == 0 ) // No record... + { + PRINT1( _L( "MM MTP <> AddVideoL file %S is adding to collection" ), &aFullFileName ); + + // Create the record + iRecordSet.InsertL(); + + // Defaults + num = iColSet->ColNo( KMtpVideoLocation ); + iRecordSet.SetColL( num, aFullFileName ); + + num = iColSet->ColNo( KMtpVideoName ); + iRecordSet.SetColL( num, aFullFileName ); // Default name is the filename. + + num = iColSet->ColNo( KMtpVideoArtist ); + iRecordSet.SetColL( num, KNullDesC ); + + num = iColSet->ColNo( KMtpVideoTrack ); + iRecordSet.SetColL( num, 0 ); + + num = iColSet->ColNo( KMtpVideoGenre ); + iRecordSet.SetColL( num, KNullDesC ); + + num = iColSet->ColNo( KMtpVideoAlbumName ); + iRecordSet.SetColL( num, KNullDesC ); + + num = iColSet->ColNo( KMtpVideoComposer ); + iRecordSet.SetColL( num, KNullDesC ); + + num = iColSet->ColNo( KMtpVideoOrigReleaseDate ); + iRecordSet.SetColL( num, KNullDesC ); + + num = iColSet->ColNo( KMtpVideoComment ); + iRecordSet.SetColL( num, KNullDesC ); + + num = iColSet->ColNo( KMtpVideoWidth ); + iRecordSet.SetColL( num, 0 ); + + num = iColSet->ColNo( KMtpVideoHeight ); + iRecordSet.SetColL( num, 0 ); + + num = iColSet->ColNo(KMtpVideoDuration); + iRecordSet.SetColL(num, 0); + + num = iColSet->ColNo( KMtpVideoSampleRate ); + iRecordSet.SetColL( num, 0 ); + + num = iColSet->ColNo( KMtpVideoNumberOfChannels ); + iRecordSet.SetColL( num, 0 ); + + num = iColSet->ColNo( KMtpVideoAudioCodec ); + iRecordSet.SetColL( num, 0 ); + + num = iColSet->ColNo( KMtpVideoAudioBitrate ); + iRecordSet.SetColL( num, 0 ); + + num = iColSet->ColNo( KMtpVideoVideoCodec ); + iRecordSet.SetColL( num, 0 ); + + num = iColSet->ColNo( KMtpVideoVideoBitrate ); + iRecordSet.SetColL( num, 0 ); + + num = iColSet->ColNo(KMtpVideoFramesPer1000Sec); + iRecordSet.SetColL(num, 0); + + num = iColSet->ColNo( KMtpVideoKeyFrameDistance ); + iRecordSet.SetColL( num, 0 ); + + num = iColSet->ColNo( KMtpVideoScanType ); + iRecordSet.SetColL( num, 0 ); + + 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 + { + PRINT1( _L( "MM MTP <> AddVideoL file %S is found in the collection" ), &aFullFileName ); + + iRecordSet.FirstL(); + iRecordSet.UpdateL(); + } + + // reset deleted bit + num = iColSet->ColNo( KMtpVideoDeleted ); + iRecordSet.SetColL( num, 0 ); + + // Commit the record + TRAPD( err, iRecordSet.PutL() ); + + if ( KErrNone != err ) + { + PRINT1( _L( "MM MTP <> AddVideoL Failed to add record to database with code %d" ), err ); + iRecordSet.Cancel(); + User::Leave( err ); + } + + delete iColSet; + iColSet = NULL; + iRecordSet.Close(); + CompactDbIfNecessaryL(); + PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::AddVideoL" ) ); + } + +// --------------------------------------------------------------------------- +// CMmMtpDpMetadataMpxAccess::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() ) + OpenDatabaseL(); + + // File Path + HBufC* suid = aObjectMetaData.DesC( CMTPObjectMetaData::ESuid ).AllocLC(); // + suid + SetRecordL( *suid, ERecordRead ); + CleanupStack::PopAndDestroy( suid ); // - suid + + HBufC* data = NULL; + TDbColNo num; + TUint32 uInt32 = 0; + TUint16 uInt16 = 0; + + switch (aPropCode) + { + case EMTPObjectPropCodeName: + { + PRINT( _L( "MM MTP <> EMTPObjectPropCodeName-MD" ) ); + data = ReadLongTextL( KMtpVideoName ); + } + break; + + case EMTPObjectPropCodeArtist: + { + PRINT( _L( "MM MTP <> EMTPObjectPropCodeArtist-MD" ) ); + data = ReadLongTextL( KMtpVideoArtist ); + } + break; + + case EMTPObjectPropCodeTrack: + { + PRINT( _L( "MM MTP <> EMTPObjectPropCodeTrack-MD" ) ); + num = iColSet->ColNo( KMtpVideoTrack ); + uInt16 = iRecordSet.ColUint16( num ); + if ( EMTPTypeUINT16 == aNewData.Type() ) + { + ( ( TMTPTypeUint16 & ) aNewData ).Set( uInt16 ); + } + else + { + User::Leave( KErrArgument ); + } + } + break; + + case EMTPObjectPropCodeGenre: + { + PRINT( _L( "MM MTP <> EMTPObjectPropCodeGenre-MD" ) ); + data = ReadLongTextL( KMtpVideoGenre ); + } + break; + + case EMTPObjectPropCodeAlbumName: + { + PRINT( _L( "MM MTP <> EMTPObjectPropCodeAlbumName-MD" ) ); + data = ReadLongTextL( KMtpVideoAlbumName ); + } + break; + + case EMTPObjectPropCodeComposer: + { + PRINT( _L( "MM MTP <> EMTPObjectPropCodeComposer-MD" ) ); + data = ReadLongTextL( KMtpVideoComposer ); + } + break; + + case EMTPObjectPropCodeOriginalReleaseDate: + { + PRINT( _L( "MM MTP <> EMTPObjectPropCodeOriginalReleaseDate-MD" ) ); + data = ReadLongTextL( KMtpVideoOrigReleaseDate ); + } + break; + + case EMTPObjectPropCodeDescription: + { + PRINT( _L( "MM MTP <> EMTPObjectPropCodeDescription-MD" ) ); + data = ReadLongTextL( KMtpVideoComment ); + + if ( data->Length() != 0 ) + ( ( CMTPTypeString& ) aNewData ).SetL( *data ) ; + else + ( ( TMTPTypeUint32 & ) aNewData ).Set( 0 ); // return zero if description is empty + + delete data; + data = NULL; + } + break; + + case EMTPObjectPropCodeWidth: + { + PRINT( _L( "MM MTP <> EMTPObjectPropCodeWidth-MD" ) ); + num = iColSet->ColNo( KMtpVideoWidth ); + uInt32 = iRecordSet.ColUint32( num ); + if ( EMTPTypeUINT32 == aNewData.Type() ) + { + ( ( TMTPTypeUint32 & ) aNewData ).Set( uInt32 ); + } + else + { + User::Leave( KErrArgument ); + } + } + break; + + case EMTPObjectPropCodeHeight: + { + PRINT( _L( "MM MTP <> EMTPObjectPropCodeHeight-MD" ) ); + num = iColSet->ColNo( KMtpVideoHeight ); + uInt32 = iRecordSet.ColUint32( num ); + if ( EMTPTypeUINT32 == aNewData.Type() ) + { + ( ( TMTPTypeUint32 & ) aNewData ).Set( uInt32 ); + } + else + { + User::Leave( KErrArgument ); + } + } + break; + + case EMTPObjectPropCodeDuration: + { + PRINT( _L( "MM MTP <> EMTPObjectPropCodeDuration-MD" ) ); + num = iColSet->ColNo( KMtpVideoDuration ); + uInt32 = iRecordSet.ColUint32( num ); + if ( EMTPTypeUINT32 == aNewData.Type() ) + { + ( ( TMTPTypeUint32 & ) aNewData ).Set( uInt32 ); + } + else + { + User::Leave( KErrArgument ); + } + } + break; + + case EMTPObjectPropCodeSampleRate: + { + PRINT( _L( "MM MTP <> EMTPObjectPropCodeSampleRate-MD" ) ); + num = iColSet->ColNo( KMtpVideoSampleRate ); + uInt32 = iRecordSet.ColUint32( num ); + if ( EMTPTypeUINT32 == aNewData.Type() ) + { + ( ( TMTPTypeUint32 & ) aNewData ).Set( uInt32 ); + } + else + { + User::Leave( KErrArgument ); + } + } + break; + + case EMTPObjectPropCodeNumberOfChannels: + { + 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 <> EMTPObjectPropCodeAudioWAVECodec-MD" ) ); + num = iColSet->ColNo( KMtpVideoAudioCodec ); + uInt32 = iRecordSet.ColUint32( num ); + if ( EMTPTypeUINT32 == aNewData.Type() ) + { + ( ( TMTPTypeUint32 & ) aNewData ).Set( uInt32 ); + } + else + { + User::Leave( KErrArgument ); + } + } + break; + + case EMTPObjectPropCodeAudioBitRate: + { + PRINT( _L( "MM MTP <> EMTPObjectPropCodeAudioBitRate-MD" ) ); + num = iColSet->ColNo( KMtpVideoAudioBitrate ); + uInt32 = iRecordSet.ColUint32( num ); + if ( EMTPTypeUINT32 == aNewData.Type() ) + { + ( ( TMTPTypeUint32 & ) aNewData ).Set( uInt32 ); + } + else + { + User::Leave( KErrArgument ); + } + } + break; + + case EMTPObjectPropCodeVideoFourCCCodec: + { + PRINT( _L( "MM MTP <> EMTPObjectPropCodeVideoFourCCCodec-MD" ) ); + num = iColSet->ColNo( KMtpVideoVideoCodec ); + uInt32 = iRecordSet.ColUint32( num ); + if ( EMTPTypeUINT32 == aNewData.Type() ) + { + ( ( TMTPTypeUint32 & ) aNewData ).Set( uInt32 ); + } + else + { + User::Leave( KErrArgument ); + } + } + break; + + case EMTPObjectPropCodeVideoBitRate: + { + PRINT( _L( "MM MTP <> EMTPObjectPropCodeVideoBitRate-MD" ) ); + num = iColSet->ColNo( KMtpVideoVideoBitrate ); + uInt32 = iRecordSet.ColUint32( num ); + if ( EMTPTypeUINT32 == aNewData.Type() ) + { + ( ( TMTPTypeUint32 & ) aNewData ).Set( uInt32 ); + } + else + { + User::Leave( KErrArgument ); + } + } + break; + + case EMTPObjectPropCodeFramesPerThousandSeconds: + { + PRINT( _L( "MM MTP <> EMTPObjectPropCodeFramesPerThousandSeconds-MD" ) ); + num = iColSet->ColNo( KMtpVideoFramesPer1000Sec ); + uInt32 = iRecordSet.ColUint32( num ); + if ( EMTPTypeUINT32 == aNewData.Type() ) + { + ( ( TMTPTypeUint32 & ) aNewData ).Set( uInt32 ); + } + else + { + User::Leave( KErrArgument ); + } + } + break; + + case EMTPObjectPropCodeKeyFrameDistance: + { + PRINT( _L( "MM MTP <> EMTPObjectPropCodeKeyFrameDistance-MD" ) ); + num = iColSet->ColNo( KMtpVideoKeyFrameDistance ); + uInt32 = iRecordSet.ColUint32( num ); + if ( EMTPTypeUINT32 == aNewData.Type() ) + { + ( ( TMTPTypeUint32 & ) aNewData ).Set( uInt32 ); + } + else + { + User::Leave( KErrArgument ); + } + } + break; + + case EMTPObjectPropCodeScanType: + { + 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: + { + PRINT( _L( "MM MTP <> EMTPObjectPropCodeEncodingProfile-MD" ) ); + data = ReadLongTextL( KMtpVideoEncodingProfile ); + } + break; + + 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: + { + User::Leave( KErrNotSupported ); + } + break; + } + + // Pack the info to aNewData + 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() ); + } +#endif // _DEBUG + + if ( EMTPTypeString == aNewData.Type() ) + { + ( ( CMTPTypeString& ) aNewData ).SetL( *data ); + } + else + { + User::Leave( KErrArgument ); + } + delete data; + data = NULL; + } + + PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::GetObjectMetadataValue" ) ); + } + +// --------------------------------------------------------------------------- +// CMmMtpDpMetadataMpxAccess::SetObjectMetadataValueL +// Sets a piece of metadata in the collection +// --------------------------------------------------------------------------- +// +void CMmMtpDpMetadataVideoAccess::SetObjectMetadataValueL( const TUint16 aPropCode, + const MMTPType& aNewData, + const CMTPObjectMetaData& aObjectMetaData ) + { + PRINT1( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::SetObjectMetadataValueL aPropCode = 0x%x" ), aPropCode ); + + if ( !IsDatabaseOpened() ) + OpenDatabaseL(); + + // Get file path + TPtrC suid( aObjectMetaData.DesC( CMTPObjectMetaData::ESuid ) ); + TParsePtrC parse( suid ); + SetRecordL( suid, ERecordWrite ); + TRAPD( err, 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 +// Set meta data. +// --------------------------------------------------------------------------- +// +void CMmMtpDpMetadataVideoAccess::SetMetadataL( const TUint16 aObjPropCode, + const MMTPType& aNewData ) + { + PRINT1( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::SetMetadataL property Code = 0x%x" ), aObjPropCode ); + + TBuf data; + TDbColNo num; + TMTPTypeUint16 uint16Data; + TMTPTypeUint32 uint32Data; + CMTPTypeArray* desData = NULL; + + TPtrC colName( ColumnNameFromPropCodeL( aObjPropCode ) ); + switch ( aObjPropCode ) + { + case EMTPObjectPropCodeName: + case EMTPObjectPropCodeArtist: + case EMTPObjectPropCodeGenre: + case EMTPObjectPropCodeAlbumName: + case EMTPObjectPropCodeComposer: + case EMTPObjectPropCodeOriginalReleaseDate: + case EMTPObjectPropCodeEncodingProfile: + case EMTPObjectPropCodeParentalRating: + { + if( EMTPTypeString != aNewData.Type()) + { + User::Leave( KErrArgument ); + } + TPtrC string( ( ( CMTPTypeString& ) aNewData ).StringChars() ); + WriteLongTextL( colName, string ); + PRINT2( _L( "MM MTP <> CMmMtpDpMetadataVideoAccess::SetMetadataL string = %S, length = %d" ), &string, string.Length() ); + } + break; + + case EMTPObjectPropCodeDescription: + { + PRINT( _L( "MM MTP <> EMTPObjectPropCodeDescription-MD" ) ); +#ifdef __MUSIC_ID_SUPPORT + //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 ); + if ( length != 0 ) + { + TBuf text; + text.Zero(); + for ( TUint i = 0; i < length; i++ ) + { + text.Append( desData->ElementUint( i ) ); + } + PRINT1( _L( "MM MTP <> CMmMtpDpMetadataMpxAccess::SetMetadataValueL text = %S" ), + &text ); + WriteLongTextL( KMtpVideoComment, text ); + } + else + { + WriteLongTextL( KMtpVideoComment, KEmptyText ); + } + CleanupStack::PopAndDestroy( desData ); // - desData +#endif //__MUSIC_ID_SUPPORT + } + break; + + case EMTPObjectPropCodeWidth: + case EMTPObjectPropCodeHeight: + case EMTPObjectPropCodeDuration: + case EMTPObjectPropCodeSampleRate: + case EMTPObjectPropCodeAudioWAVECodec: + case EMTPObjectPropCodeAudioBitRate: + case EMTPObjectPropCodeVideoFourCCCodec: + case EMTPObjectPropCodeVideoBitRate: + case EMTPObjectPropCodeFramesPerThousandSeconds: + case EMTPObjectPropCodeKeyFrameDistance: + case EMTPObjectPropCodeUseCount: + { + if ( EMTPTypeUINT32 != aNewData.Type() ) + { + User::Leave( KErrArgument ); + } + num = iColSet->ColNo( colName ); + iRecordSet.SetColL( num, ( ( TMTPTypeUint32& ) aNewData ).Value() ); + } + break; + + case EMTPObjectPropCodeTrack: + case EMTPObjectPropCodeNumberOfChannels: + case EMTPObjectPropCodeScanType: + case EMTPObjectPropCodeDRMStatus: + { + if ( EMTPTypeUINT16 != aNewData.Type() ) + { + User::Leave( KErrArgument ); + } + num = iColSet->ColNo( colName ); + iRecordSet.SetColL( num, ( ( TMTPTypeUint16& ) aNewData ).Value() ); + } + break; + + default: + { + User::Leave( KErrNotSupported ); + } + break; + } + + PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::SetMetadataL" ) ); + } + +// --------------------------------------------------------------------------- +// CMmMtpDpMetadataMpxAccess::RenameRecordL +// Renames the file part of a record in the collection database. +// --------------------------------------------------------------------------- +// +void CMmMtpDpMetadataVideoAccess::RenameRecordL(const TDesC& aOldFileName, const TDesC& aNewFileName) + { + PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::RenameRecordL()" ) ); + + //open database if not opened + if ( !IsDatabaseOpened() ) + OpenDatabaseL(); + + SetRecordL( aOldFileName, ERecordWrite ); // Open the record to write + TDbColNo num = iColSet->ColNo( KMtpVideoLocation ); + iRecordSet.SetColL( num, aNewFileName ); + + PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::RenameRecordL()" ) ); + } + +// --------------------------------------------------------------------------- +// CMmMtpDpMetadataMpxAccess::DeleteRecordL +// Deletes metadata information associated with the object +// --------------------------------------------------------------------------- +// +void CMmMtpDpMetadataVideoAccess::DeleteRecordL( const TDesC& aFullFileName ) + { + PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::DeleteRecordL" ) ); + + //open database if not opened + if ( !IsDatabaseOpened() ) + OpenDatabaseL(); + + SetRecordL( KNullDesC, ENoRecord ); // Commit any other changes to the DB + + TUint format = MmMtpDpUtility::FormatFromFilename( aFullFileName ); + + if ( MmMtpDpUtility::HasMetadata( format ) ) + { + ExecuteQueryL( KMtpVideoLocation, + KMtpVideoTable, + KMtpVideoLocation, + aFullFileName ); + + for ( iRecordSet.FirstL(); iRecordSet.AtRow(); iRecordSet.NextL() ) + { + iRecordSet.DeleteL(); + PRINT( _L( "MM MTP <> CMmMtpDpMetadataVideoAccess::DeleteRecordL Record deleted" ) ); + } + + delete iColSet; + iColSet = NULL; + iRecordSet.Close(); + } + PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::DeleteRecordL" ) ); + } + +// --------------------------------------------------------------------------- +// CMmMtpDpMetadataMpxAccess::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()) + OpenDatabaseL(); + + SetRecordL( KNullDesC, ENoRecord ); // Commit any other changes to the DB + + PRINT( _L( "MM MTP <> Deleting music files" ) ); + ExecuteQueryL( KAllColumns, KMtpVideoTable ); + + for ( iRecordSet.FirstL(); iRecordSet.AtRow(); iRecordSet.NextL() ) + { + iRecordSet.DeleteL(); + } + + delete iColSet; + iColSet = NULL; + iRecordSet.Close(); + + iDatabase.Compact(); + PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::DeleteAllRecordsL()" ) ); + } + +// --------------------------------------------------------------------------- +// CMmMtpDpMetadataMpxAccess::SetRecordL +// Set Record +// --------------------------------------------------------------------------- +// +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) + iRecordSet.GetL(); + + PRINT1( _L( "MM MTP <> Cached recordset, filename is '%S'" ), &iCurrentFileName ); + return; + } + + iCurrentFileName.Copy( aFullFileName ); + PRINT1( _L( "MM MTP <> CMmMtpDpMetadataVideoAccess::iCurrentFileName set to '%S'" ), &iCurrentFileName ); + + // We arrive here, if a new view is required. First, need to deal with the old one. + switch ( iDbState ) + { + case EFailedWrite: + // We wrote to the DB, but the op failed + PRINT( _L( "MM MTP <> SetRecordL EFailedWrite" ) ); + iRecordSet.Cancel(); + + 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) + { + 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 + { + 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 ); + + if ( iRecordSet.CountL() == 0 ) // No match... + { + iRecordSet.Close(); + PRINT( _L( "MM MTP <> Recordset is empty! Bailing out..." ) ); + delete iColSet; + iColSet = NULL; + iRecordSet.Close(); + iDbState = ENoRecord; + User::Leave( KErrNotFound ); // Have an object on the disk, but no metadata + } + + // Check that we only have one record, not many... + if ( iRecordSet.CountL() > 1 ) + { + //LOGTEXT2("METADATA DATABASE ERROR: %d entries for the same file name!!", iRecordSet.CountL()); + User::Leave( KErrCorrupt ); + } + + if ( aState == ERecordWrite ) + { + iRecordSet.UpdateL(); // Lock the row + PRINT( _L( "MM MTP <> Row locked" ) ); + } + else if ( aState == ERecordRead ) + { + iRecordSet.GetL(); + } + + // Update the internal state + iDbState = aState; + } + else + User::Leave( KErrNotFound ); + + PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::SetRecordL()" ) ); + } + +// --------------------------------------------------------------------------- +// CMmMtpDpMetadataMpxAccess::SetImageObjPropL +// set image specific properties specific to videos +// --------------------------------------------------------------------------- +// +void CMmMtpDpMetadataVideoAccess::SetImageObjPropL( const TDesC& aFullFileName, + const TUint32 aWidth, + const TUint32 aHeight ) + { + PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::SetImageObjPropL()" ) ); + + if ( !IsDatabaseOpened() ) + OpenDatabaseL(); + + TDbColNo num = 0; + TInt err = KErrNone; + + 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 +// Get image specific properties specific to videos +// --------------------------------------------------------------------------- +// +void CMmMtpDpMetadataVideoAccess::GetImageObjPropL( const TDesC& aFullFileName, + TUint32& aWidth, + TUint32& aHeight ) + { + PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::GetImageObjPropL()" ) ); + + if ( !IsDatabaseOpened() ) + OpenDatabaseL(); + + TDbColNo num = 0; + + SetRecordL( aFullFileName, ERecordRead ); + + num = iColSet->ColNo( KMtpVideoWidth ); + aWidth = iRecordSet.ColUint32( num ); + + num = iColSet->ColNo( KMtpVideoHeight ); + aHeight = iRecordSet.ColUint32( num ); + + PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::GetImageObjPropL()" ) ); + } + +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 }, + { EMTPObjectPropCodeDRMStatus, KMtpVideoDRM }, + }; + + TInt i = 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" ) ); + User::Leave( KErrNotSupported ); + } + return KColumnTable[i].iDbColumnName; + } + +void CMmMtpDpMetadataVideoAccess::SetStorageRootL( const TDesC& aStorageRoot ) + { + PRINT1( _L( "MM MTP => CMmMtpDpMetadataMpxAccess::SetStorageRoot aStoreRoot = %S" ), &aStorageRoot ); + + // get the drive number + TParse pathParser; + 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 ); + } + +void CMmMtpDpMetadataVideoAccess::CleanupDatabaseL() + { + PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::CleanupDatabaseL" ) ); + + //open database if not opened + if ( !IsDatabaseOpened() ) + { + return; + } + + // Make sure the db is commited + SetRecordL( KNullDesC, ENoRecord ); + + IdentifyDeletedFilesL(); + + CleanupDbIfNecessaryL(); + + PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::CleanupDatabaseL" ) ) + } + +TBool CMmMtpDpMetadataVideoAccess::FileExists( const TDesC& aFullFileName ) + { + return BaflUtils::FileExists( iRfs, aFullFileName ); + } + +// end of file