diff -r 14979e23cb5e -r 3de6c4cf6b67 mpxplugins/serviceplugins/collectionplugins/mpxsqlitedbhgplugin/src/mpxdbabstractalbum.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mpxplugins/serviceplugins/collectionplugins/mpxsqlitedbhgplugin/src/mpxdbabstractalbum.cpp Wed Sep 01 12:32:02 2010 +0100 @@ -0,0 +1,665 @@ +/* +* Copyright (c) 2007 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: Responsible for interation with the category tables: +* Artist, Album, Genre, Composer and AbstractAlbum +* +* +*/ + + +// INCLUDE FILES +#include +#include +#include +#include "mpxdbabstractalbum.h" +#include "mpxdbpluginqueries.h" +#include "mpxdbmanager.h" +#include "mpxdbcommonutil.h" +#include "mpxcollectiondbstd.h" +#include "mpxdbcommondef.h" +#include "mpxcollectiondbdef.h" + +#ifdef RD_MPX_TNM_INTEGRATION +_LIT( KImageFileType, "image/jpeg" ); +#endif //RD_MPX_TNM_INTEGRATION + + +// CONSTANTS + +// ============================ MEMBER FUNCTIONS ============================== + +// ---------------------------------------------------------------------------- +// Two-phased constructor. +// ---------------------------------------------------------------------------- +// +CMPXDbAbstractAlbum* CMPXDbAbstractAlbum::NewL( + CMPXDbManager& aDbManager, + TMPXGeneralCategory aCategory, RFs& aFs) + { + MPX_FUNC("CMPXDbAbstractAlbum::NewL"); + + CMPXDbAbstractAlbum* self = CMPXDbAbstractAlbum::NewLC(aDbManager, aCategory, aFs); + CleanupStack::Pop(self); + return self; + } + +// ---------------------------------------------------------------------------- +// Two-phased constructor. +// ---------------------------------------------------------------------------- +// +CMPXDbAbstractAlbum* CMPXDbAbstractAlbum::NewLC( + CMPXDbManager& aDbManager, + TMPXGeneralCategory aCategory, RFs& aFs) + { + MPX_FUNC("CMPXDbAbstractAlbum::NewLC"); + + CMPXDbAbstractAlbum* self = new (ELeave) CMPXDbAbstractAlbum(aDbManager, aCategory, aFs); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + +// ---------------------------------------------------------------------------- +// Destructor +// ---------------------------------------------------------------------------- +// +CMPXDbAbstractAlbum::~CMPXDbAbstractAlbum() + { + MPX_FUNC("CMPXDbAbstractAlbum::~CMPXDbAbstractAlbum"); +#ifdef RD_MPX_TNM_INTEGRATION + if (iTNManager) + delete iTNManager; +#endif //RD_MPX_TNM_INTEGRATION + } + +// ---------------------------------------------------------------------------- +// CMPXDbAbstractAlbum::GetDriveIdL +// ---------------------------------------------------------------------------- +// +TInt CMPXDbAbstractAlbum::GetDriveIdL( + TUint32 aAbstractAlbumId) + { + MPX_FUNC("CMPXDbAbstractAlbum::GetDriveIdL"); + return MPXDbCommonUtil::GetDriveIdMatchVolIdL(iDbManager.Fs(), + ExecuteIntQueryL(KCriterionCategoryVolumeId, aAbstractAlbumId)); + } + + +// ---------------------------------------------------------------------------- +// CMPXDbAbstractAlbum::AddItemL +// ---------------------------------------------------------------------------- +// +TUint32 CMPXDbAbstractAlbum::AddItemL( + const TDesC& aUri, + const TDesC& aName, + const TDesC& aAlbumArtist, + TInt aDriveId, + TBool& aNewRecord, + TBool aCaseSensitive) + { + MPX_FUNC("CMPXDbAbstractAlbum::AddItemL"); + + TUint32 rowId(MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), EMPXAbstractAlbum, + aUri, aCaseSensitive)); + aNewRecord = !CategoryItemExistsL(aDriveId, rowId); + + if ( aNewRecord ) + { + HBufC* uri = MPXDbCommonUtil::ProcessSingleQuotesLC(aUri); + HBufC* name = MPXDbCommonUtil::ProcessSingleQuotesLC(aName); + HBufC* albumartist = MPXDbCommonUtil::ProcessSingleQuotesLC(aAlbumArtist); + + iDbManager.ExecuteQueryL(aDriveId, KQueryAbstractAlbumInsert, rowId, uri, name, albumartist, 0, MPXDbCommonUtil::GetVolIdMatchDriveIdL(iDbManager.Fs(), aDriveId)); + CleanupStack::PopAndDestroy(3, uri); + } + else + { + MPX_DEBUG1("CMPXDbAbstractAlbum::AddItemL, increase song count for abstractalbum"); + // increment the number of songs for the category + HBufC* query = PreProcessStringLC(KQueryCategoryIncrementSongCount); + iDbManager.ExecuteQueryL(aDriveId, *query, rowId); + CleanupStack::PopAndDestroy(query); + } + + return rowId; + } + +// ---------------------------------------------------------------------------- +// CMPXDbAbstractAlbum::AddUpdatedItemL +// ---------------------------------------------------------------------------- +// +TUint32 CMPXDbAbstractAlbum::AddUpdatedItemL(TUint32 aOldId, const TDesC& newUri) + { + MPX_FUNC("CMPXDbAbstractAlbum::AddUpdatedItemL"); + iRenameTN = ETrue; + + //get the existing item based on aOldId + HBufC* query = NULL; + query = PreProcessStringLC(KQueryCategoryItem); + RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(*query, aOldId)); + CleanupStack::PopAndDestroy(query); + + CleanupClosePushL(recordset); + TBool newRecord(ETrue); + if (recordset.Next() != KSqlAtRow) + { + User::Leave(KErrNotFound); + } + //save the existing entry fields values for renaming purpose + const TDesC& name(MPXDbCommonUtil::GetColumnTextL (recordset, EAbstractAlbumName)); + const TDesC& albumartist(MPXDbCommonUtil::GetColumnTextL (recordset, EAbstractAlbumArtist)); + + TUint32 itemId = AddItemL(newUri, name, albumartist, GetDriveIdL(aOldId), newRecord, EFalse); + CleanupStack::PopAndDestroy(&recordset); + + return itemId; + } + +// ---------------------------------------------------------------------------- +// CMPXDbAbstractAlbum::DecrementSongsForCategoryL +// ---------------------------------------------------------------------------- +// +void CMPXDbAbstractAlbum::DecrementSongsForCategoryL( + const TUint32 aId, + TInt aDriveId, + CMPXMessageArray* aItemChangedMessages, + TBool& aItemExist, + TBool aMtpInUse) + { + MPX_FUNC("CMPXDbAbstractAlbum::DecrementSongsForCategoryL"); + + TInt songCount = GetSongsCountL(aDriveId, aId); + //while MTP connection, just decrease songCount in DB, do not do deletion. + if ( songCount > 0 ) + { + aItemExist = ETrue; + // decrement the number of songs for the category + HBufC* query = PreProcessStringLC(KQueryCategoryDecrementSongCount); + iDbManager.ExecuteQueryL(aDriveId, *query, aId); + CleanupStack::PopAndDestroy(query); + songCount--; + } + if (songCount == 0) + { + //get uri + HBufC* uri = GetUriL(aId); + CleanupStack::PushL(uri); + + if (!aMtpInUse) + { + DeleteAbstractAlbumEntryL(aId, aDriveId); + MPX_DEBUG1("CMPXDbAbstractAlbum::DecrementSongsForCategoryL,implicitly delete AbstractAlbum Object when it has 0 references"); + aItemExist = EFalse; + if (aItemChangedMessages) + { + // add the item changed message + MPXDbCommonUtil::AddItemChangedMessageL(*aItemChangedMessages, aId, EMPXItemDeleted, + EMPXAbstractAlbum, KDBPluginUid); + } + //delete .alb file from file system + TInt err = BaflUtils::DeleteFile(iFs, *uri); + if(KErrNone != err) + { + MPX_DEBUG2("CMPXDbAbstractAlbum::DecrementSongsForCategoryL,File not deleted from file system with err=%d", err); + } + } + if(!iRenameTN) + { + HandleTNL(*uri); + } + CleanupStack::PopAndDestroy(uri); + } + } + +// ---------------------------------------------------------------------------- +// Remove abstractalbums which have no songs associated. +// ---------------------------------------------------------------------------- +// +void CMPXDbAbstractAlbum::RemoveAbstractAlbumsWithNoSongL() + { + MPX_FUNC("CMPXDbAbstractAlbum::RemoveAbstractAlbumsWithNoSongL"); + + RArray iItemsIds; + CleanupClosePushL(iItemsIds); + + //get all abstractalbum with no songs associated. + GetAllItemsWithNoSongL(iItemsIds); + TInt count = iItemsIds.Count(); + TInt err = KErrNone; + if (count) + { + MPX_DEBUG2("CMPXDbAbstractAlbum::RemoveAbstractAlbumsWithNoSongL, abstractalbum count[%d] ", iItemsIds.Count()); + CMPXMessageArray* itemChangedMessages = CMPXMediaArray::NewL(); + CleanupStack::PushL(itemChangedMessages); + + //go through each one to delete + for (TInt i=0; i< count; i++) + { + TRAP(err, RemoveAbstractAlbumL(iItemsIds[i], *itemChangedMessages, EFalse)); + if (err != KErrNone) + { + MPX_DEBUG2("CMPXDbAbstractAlbum::RemoveAbstractAlbumsWithNoSongL, error happens when delete abstractalbum, err ", err); + } + } + CleanupStack::PopAndDestroy(itemChangedMessages); + } + CleanupStack::PopAndDestroy(&iItemsIds); + } + +// ---------------------------------------------------------------------------- +// Remove .alb entry from AbstractAlnum table, TN table if .alb files deleted +// from file manager when refresh library +// ---------------------------------------------------------------------------- +// +void CMPXDbAbstractAlbum::AbstractAlbumCleanUpL() + { + MPX_FUNC("CMPXDbAbstractAlbum::AbstractAlbumCleanUpL"); + RArray attributes; + CleanupClosePushL(attributes); + attributes.AppendL(KMPXMediaGeneralUri); + CMPXMediaArray* mediaArray = CMPXMediaArray::NewL(); + CleanupStack::PushL(mediaArray); + + GetAllCategoryItemsL(attributes.Array(), *mediaArray); + + TInt count(mediaArray->Count()); + if (count) + { + CMPXMessageArray* itemChangedMessages = CMPXMediaArray::NewL(); + CleanupStack::PushL(itemChangedMessages); + for (TInt i = 0; i < count; i++) + { + CMPXMedia* element = mediaArray->AtL(i); + const TDesC& uri = element->ValueText(KMPXMediaGeneralUri); + + //check if the file exists in file system + if (!(BaflUtils::FileExists(iFs, uri))) + { + //generate abstractalbum UID with the Uri + TUint32 abstractAlbumId(MPXDbCommonUtil::GenerateUniqueIdL(iFs, EMPXAbstractAlbum, uri, EFalse)); + RemoveAbstractAlbumL(abstractAlbumId, *itemChangedMessages, ETrue); + } + } + CleanupStack::PopAndDestroy(itemChangedMessages); + } + CleanupStack::PopAndDestroy(mediaArray); + CleanupStack::PopAndDestroy(&attributes); + } + +// ---------------------------------------------------------------------------- +// CMPXDbAbstractAlbum::RemoveAbstractAlbumL +// ---------------------------------------------------------------------------- +// +void CMPXDbAbstractAlbum::RemoveAbstractAlbumL(TUint32 aAbstractAlbumId, + CMPXMessageArray& aItemChangedMessages, TBool aFileDeleted) + { + MPX_FUNC("CMPXDbAbstractAlbum::RemoveAbstractAlbumL"); + HBufC* uri = GetUriL(aAbstractAlbumId); + CleanupStack::PushL(uri); + + DeleteAbstractAlbumEntryL(aAbstractAlbumId); + HandleTNL(*uri); + if (!aFileDeleted) + { + TInt err = BaflUtils::DeleteFile(iFs, *uri); + if(KErrNone != err) + { + MPX_DEBUG2("CMPXDbAbstractAlbum::RemoveAbstractAlbumL,File not deleted from file system with err=%d", err); + } + } + MPXDbCommonUtil::AddItemChangedMessageL(aItemChangedMessages, aAbstractAlbumId, EMPXItemDeleted, EMPXAbstractAlbum, KDBPluginUid); + CleanupStack::PopAndDestroy(uri); + } + + +// ---------------------------------------------------------------------------- +// CMPXDbAbstractAlbum::HandleTNL +// ---------------------------------------------------------------------------- +// +void CMPXDbAbstractAlbum::HandleTNL( const TDesC& aOldPath, + const TDesC& aNewPath, TInt aPriority ) + { + MPX_FUNC("CMPXDbAbstractAlbum::HandleTNL"); + if (!iTNManager) + { + CreateTNMSessionL(); + } + if (aNewPath.Compare(KNullDesC)==0 && aOldPath.Compare(KNullDesC)!=0) + { + // remove from thumbnail database table + MPX_DEBUG1("CMPXDbAbstractAlbum::HandleTNL, delete TN"); + CThumbnailObjectSource* source = CThumbnailObjectSource::NewLC( + aOldPath, KImageFileType ); + iTNManager->DeleteThumbnails( *source ); + + CleanupStack::PopAndDestroy( source ); + } + else if (aNewPath.Compare(KNullDesC)!=0) + { + //rename thumbnail + MPX_DEBUG1("CMPXDbAbstractAlbum::HandleTNL, rename Thumbnail entry in Thumbnail table"); + + iTNManager->RenameThumbnailsL( aOldPath, aNewPath, aPriority ); + //after rename, reset flag + iRenameTN = EFalse; + } + } + + +// ---------------------------------------------------------------------------- +// CMPXDbAbstractAlbum::UpdateItemL +// ---------------------------------------------------------------------------- +// +void CMPXDbAbstractAlbum::UpdateItemL( + TUint32 aId, + const CMPXMedia& aMedia, + TInt aDriveId, + CMPXMessageArray* aItemChangedMessages) + { + MPX_FUNC("CMPXDbAbstractAlbum::UpdateItemL"); + + CDesCArrayFlat* fields = new (ELeave) CDesCArrayFlat(EAbstractAlbumFieldCount); + CleanupStack::PushL(fields); + CDesCArrayFlat* values = new (ELeave) CDesCArrayFlat(EAbstractAlbumFieldCount); + CleanupStack::PushL(values); + + // process the media parameter and construct the fields and values array + GenerateAbstractAlbumFieldsValuesL(aMedia, *fields, *values); + + // construct the SET string + HBufC* setStr = MPXDbCommonUtil::StringFromArraysLC(*fields, *values, KMCEqualSign, KMCCommaSign); + + if (setStr->Length()) + { + // execute the query + iDbManager.ExecuteQueryL(aDriveId, KQueryAbstractAlbumUpdate, setStr, aId); + MPXDbCommonUtil::AddItemAlbumChangedMessageL(*aItemChangedMessages, aId, EMPXItemModified, + EMPXAbstractAlbum, KDBPluginUid, ETrue, 0 ); + } + CleanupStack::PopAndDestroy(setStr); + CleanupStack::PopAndDestroy(values); + CleanupStack::PopAndDestroy(fields); + } + + +// ---------------------------------------------------------------------------- +// CMPXDbAbstractAlbum::GetUriL +// ---------------------------------------------------------------------------- +// +HBufC* CMPXDbAbstractAlbum::GetUriL( + TUint32 aId) + { + MPX_FUNC("CMPXDbAbstractAlbum::GetUriL"); + + RSqlStatement recordset(GetCategoryRecordL(aId)); + CleanupClosePushL(recordset); + HBufC* uri = NULL; + if (recordset.Next() == KSqlAtRow) + { + uri = MPXDbCommonUtil::GetColumnTextL(recordset, EAbstractAlbumUri).AllocL(); + } + else + { + //entry is deleted due to garbage collection + MPX_DEBUG1("CMPXDbAbstractAlbum::GetUriL, no uri, entry is deleted due to garbage collection"); + TPtrC nullUri(KNullDesC); + uri = nullUri.AllocL(); + } + CleanupStack::PopAndDestroy(&recordset); + return uri; + } + + +// ---------------------------------------------------------------------------- +// CMPXDbAbstractAlbum::UpdateMediaL +// ---------------------------------------------------------------------------- +// +void CMPXDbAbstractAlbum::UpdateMediaL( + RSqlStatement& aRecord, + const TArray& aAttrs, + CMPXMedia& aMedia) + { + MPX_FUNC("CMPXDbAbstractAlbum::UpdateMediaL"); + + TInt count(aAttrs.Count()); + for (TInt i = 0; i < count; ++i) + { + TInt contentId(aAttrs[i].ContentId()); + TUint attributeId(aAttrs[i].AttributeId()); + + if (contentId == KMPXMediaIdGeneral) + { + if (attributeId & EMPXMediaGeneralId) + { + MPX_DEBUG1(" EMPXMediaGeneralId"); + aMedia.SetTObjectValueL(KMPXMediaGeneralId, + aRecord.ColumnInt64(EAbstractAlbumUniqueId)); + } + if (attributeId & EMPXMediaGeneralTitle) + { + MPX_DEBUG1(" EMPXMediaGeneralTitle"); + TPtrC title(MPXDbCommonUtil::GetColumnTextL(aRecord, EAbstractAlbumName)); + aMedia.SetTextValueL(KMPXMediaGeneralTitle, title); + MPX_DEBUG2(" AbstractAlbumName[%S]", &title); + } + if (attributeId & EMPXMediaGeneralCount) + { + MPX_DEBUG1(" EMPXMediaGeneralCount"); + TInt songCount = GetSongsCountL(KDbManagerAllDrives, + aRecord.ColumnInt64(EAbstractAlbumUniqueId)); + aMedia.SetTObjectValueL(KMPXMediaGeneralCount, songCount ); + } + if (attributeId & EMPXMediaGeneralDrive || + (attributeId & EMPXMediaGeneralUri)) + { + TUint32 volId(aRecord.ColumnInt64(EAbstractAlbumVolumeId)); + TInt driveId = MPXDbCommonUtil::GetDriveIdMatchVolIdL(iDbManager.Fs(), volId); + MPX_DEBUG3("volId = %d, driveId = %d", volId, driveId); + + // handle possibly delay from framework notification + if (driveId < 0) + { + MPX_DEBUG1("invalid driveId, leave with KErrNotReady"); + User::Leave(KErrNotReady); + } + TDriveUnit driveUnit(driveId); + if (attributeId & EMPXMediaGeneralUri) + { + TPtrC uri(MPXDbCommonUtil::GetColumnTextL(aRecord, EAbstractAlbumUri)); + aMedia.SetTextValueL(KMPXMediaGeneralUri, uri); + MPX_DEBUG2(" AbstractAlbum URI[%S]", &uri); + } + if (attributeId & EMPXMediaGeneralDrive) + { + aMedia.SetTextValueL(KMPXMediaGeneralDrive, driveUnit.Name()); + } + } + } // end if contentId == KMPXMediaIdGeneral + + else if ( contentId == KMPXMediaIdMusic) + { + if (attributeId & EMPXMediaMusicAlbumArtist) + { + MPX_DEBUG1(" EMPXMediaMusicAlbumArtist"); + TPtrC albumartist(MPXDbCommonUtil::GetColumnTextL(aRecord, EAbstractAlbumArtist)); + aMedia.SetTextValueL(KMPXMediaMusicAlbumArtist, albumartist); + MPX_DEBUG2(" albumartist[%S]", &albumartist); + } + } + + } // end for + aMedia.SetTObjectValueL(KMPXMediaGeneralType, EMPXItem); + aMedia.SetTObjectValueL(KMPXMediaGeneralCategory, EMPXAbstractAlbum); + } + +// ---------------------------------------------------------------------------- +// CMPXDbAbstractAlbum::GetAllItemsWithNoSongL +// ---------------------------------------------------------------------------- +// +void CMPXDbAbstractAlbum::GetAllItemsWithNoSongL(RArray& aItemsIds) + { + MPX_FUNC("CMPXDbAbstractAlbum::GetAllItemsWithNoSongL"); + RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryAbstractAlbumsWithNoSong)); + CleanupClosePushL(recordset); + + TInt err(KErrNone); + while ((err = recordset.Next()) == KSqlAtRow) + { + TUint32 uniqueID(recordset.ColumnInt64(EAbstractAlbumUniqueId)); + aItemsIds.AppendL(uniqueID); + } + CleanupStack::PopAndDestroy(&recordset); + if (err!= KSqlAtEnd) + { + User::Leave(KErrCorrupt); + } + } + + +// ---------------------------------------------------------------------------- +// CMPXDbAbstractAlbum::GenerateAbstractAlbumFieldsValuesL +// ---------------------------------------------------------------------------- +// +void CMPXDbAbstractAlbum::GenerateAbstractAlbumFieldsValuesL(const CMPXMedia& aMedia, CDesCArray& aFields, CDesCArray& aValues) + { + MPX_FUNC("CMPXDbAbstractAlbum::GenerateAbstractAlbumFieldsValuesL"); + //support Winlogo use case + if (aMedia.IsSupported(KMPXMediaGeneralTitle)) + { + TPtrC truncatedName(aMedia.ValueText(KMPXMediaGeneralTitle).Left(KMCMaxTextLen)); + MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCCategoryName, truncatedName); + } + //support Winlogo use case + if (aMedia.IsSupported(KMPXMediaMusicAlbumArtist)) + { + TPtrC truncatedAlbumArtist(aMedia.ValueText(KMPXMediaMusicAlbumArtist).Left(KMCMaxTextLen)); + MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCMusicAlbumArtist, truncatedAlbumArtist); + } + } + +// ---------------------------------------------------------------------------- +// CMPXDbAbstractAlbum::DeleteAbstractAlbumEntryL +// ---------------------------------------------------------------------------- +// +void CMPXDbAbstractAlbum::DeleteAbstractAlbumEntryL( + TUint32 aAbstractAlbumId, TInt aDriveId) + { + MPX_FUNC("CMPXDbAbstractAlbum::DeleteAbstractAlbumEntryL"); + + //delete entry from table + if (aDriveId) + DeleteCategoryL(aAbstractAlbumId, aDriveId); + else + { + TInt drive = MPXDbCommonUtil::GetDriveIdMatchVolIdL(iDbManager.Fs(), + ExecuteIntQueryL(KCriterionCategoryVolumeId, aAbstractAlbumId)); + DeleteCategoryL(aAbstractAlbumId, drive); + } + } + +// ---------------------------------------------------------------------------- +// CMPXDbAlbum::CreateTableL +// ---------------------------------------------------------------------------- +// +void CMPXDbAbstractAlbum::CreateTableL( + RSqlDatabase& aDatabase, + TBool /* aCorruptTable */) + { + MPX_FUNC("CMPXDbAbstractAlbum::CreateTableL"); + + // create the table + HBufC* query = PreProcessStringLC(KAbstractAlbumCreateTable); + User::LeaveIfError(aDatabase.Exec(*query)); + CleanupStack::PopAndDestroy(query); + + // do not create an index on the Name field + // as it only slows down the insert/update queries overall + } + +// ---------------------------------------------------------------------------- +// CMPXDbAlbum::CheckTableL +// ---------------------------------------------------------------------------- +// +TBool CMPXDbAbstractAlbum::CheckTableL( + RSqlDatabase& aDatabase) + { + MPX_FUNC("CMPXDbAbstractAlbum::CheckTableL"); + + HBufC* query = PreProcessStringLC(KAbstractAlbumCheckTable); + TBool check(DoCheckTable(aDatabase, *query)); + CleanupStack::PopAndDestroy(query); + + return check; + } + + +// ---------------------------------------------------------------------------- +// Constructor +// ---------------------------------------------------------------------------- +// +CMPXDbAbstractAlbum::CMPXDbAbstractAlbum( + CMPXDbManager& aDbManager, + TMPXGeneralCategory aCategory, RFs& aFs) : + CMPXDbCategory(aDbManager, aCategory), + iTNManager(NULL), + iFs(aFs) + { + MPX_FUNC("CMPXDbAbstractAlbum::CMPXDbAbstractAlbum"); + } + +// ---------------------------------------------------------------------------- +// Second phase constructor. +// ---------------------------------------------------------------------------- +// +void CMPXDbAbstractAlbum::ConstructL() + { + MPX_FUNC("CMPXDbAbstractAlbum::ConstructL"); + + BaseConstructL(); + iRenameTN = EFalse; + } + + + +// --------------------------------------------------------------------------- +// CMPXDbAbstractAlbum::ThumbnailReady +// Callback but not used here +// --------------------------------------------------------------------------- +void CMPXDbAbstractAlbum::ThumbnailPreviewReady( + MThumbnailData& /*aThumbnail*/, TThumbnailRequestId /*aId*/ ) + { + } + + +// --------------------------------------------------------------------------- +// CMPXDbAbstractAlbum::ThumbnailReady +// Callback but not used here +// --------------------------------------------------------------------------- +void CMPXDbAbstractAlbum::ThumbnailReady( TInt /*aError*/, + MThumbnailData& /*aThumbnail*/, TThumbnailRequestId /*aId*/ ) + { + } + +// --------------------------------------------------------------------------- +// CMPXDbAbstractAlbum::CreateTNMSessionL +// Create thumbnail session +// --------------------------------------------------------------------------- +void CMPXDbAbstractAlbum::CreateTNMSessionL() + { + if(!iTNManager) + { + iTNManager = CThumbnailManager::NewL( *this ); + } + } +// End of File