diff -r 171e07ac910f -r c8156a91d13c 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 Mar 31 21:26:33 2010 +0300 @@ -0,0 +1,463 @@ +/* +* 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 the License "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) + { + MPX_FUNC("CMPXDbAbstractAlbum::NewL"); + + CMPXDbAbstractAlbum* self = CMPXDbAbstractAlbum::NewLC(aDbManager, aCategory); + CleanupStack::Pop(self); + return self; + } + +// ---------------------------------------------------------------------------- +// Two-phased constructor. +// ---------------------------------------------------------------------------- +// +CMPXDbAbstractAlbum* CMPXDbAbstractAlbum::NewLC( + CMPXDbManager& aDbManager, + TMPXGeneralCategory aCategory) + { + MPX_FUNC("CMPXDbAbstractAlbum::NewLC"); + + CMPXDbAbstractAlbum* self = new (ELeave) CMPXDbAbstractAlbum(aDbManager, aCategory); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + +// ---------------------------------------------------------------------------- +// Destructor +// ---------------------------------------------------------------------------- +// +CMPXDbAbstractAlbum::~CMPXDbAbstractAlbum() + { + MPX_FUNC("CMPXDbAbstractAlbum::~CMPXDbAbstractAlbum"); +#ifdef RD_MPX_TNM_INTEGRATION + 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& aName, + const TDesC& aAlbumArtist, + const TDesC& aGenre, + TInt aDriveId, + TBool& aNewRecord, + TBool aCaseSensitive) + { + MPX_FUNC("CMPXDbAbstractAlbum::AddItemL"); + + TUint32 rowId(MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), EMPXAbstractAlbum, + aName, aCaseSensitive)); + + if ( aNewRecord ) + { + HBufC* name = MPXDbCommonUtil::ProcessSingleQuotesLC(aName); + HBufC* albumartist = MPXDbCommonUtil::ProcessSingleQuotesLC(aAlbumArtist); + HBufC* genre = MPXDbCommonUtil::ProcessSingleQuotesLC(aGenre); + + iDbManager.ExecuteQueryL(aDriveId, KQueryAbstractAlbumInsert, rowId, name, albumartist, genre, 0, MPXDbCommonUtil::GetVolIdMatchDriveIdL(iDbManager.Fs(), aDriveId)); + CleanupStack::PopAndDestroy(3, name); + } + else + { + // increment the number of songs for the category + HBufC* query = PreProcessStringLC(KQueryCategoryIncrementSongCount); + iDbManager.ExecuteQueryL(aDriveId, *query, rowId); + CleanupStack::PopAndDestroy(query); + } + + return rowId; + } + + + +// ---------------------------------------------------------------------------- +// 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); + // if just one song uses this category. Use <= just in case + //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) && !aMtpInUse) + { + HBufC* uri = DeleteAbstractAlbumL(aId, aDriveId); + MPX_DEBUG1("CMPXDbAbstractAlbum::DeleteAbstractAlbumL,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 uri; + } + } + + +// ---------------------------------------------------------------------------- +// CMPXDbAbstractAlbum::DeleteAbstractAlbumL +// ---------------------------------------------------------------------------- +// +HBufC* CMPXDbAbstractAlbum::DeleteAbstractAlbumL( + TUint32 aAbstractAlbumId, TInt aDriveId) + { + MPX_FUNC("CMPXDbAbstractAlbum::DeleteAbstractAlbumL"); + + //before delete category, get the abstract album path + HBufC* uri = GetNameL(aAbstractAlbumId); + // delete the category + if (uri) + { + CleanupStack::PushL(uri); + + if (aDriveId) + DeleteCategoryL(aAbstractAlbumId, aDriveId); + else + { + TInt drive = MPXDbCommonUtil::GetDriveIdMatchVolIdL(iDbManager.Fs(), + ExecuteIntQueryL(KCriterionCategoryVolumeId, aAbstractAlbumId)); + DeleteCategoryL(aAbstractAlbumId, drive); + } +//delete abstract album .alb from TN table +#ifdef RD_MPX_TNM_INTEGRATION + // remove from thumbnail database table + CThumbnailObjectSource* source = CThumbnailObjectSource::NewLC( + *uri, KImageFileType ); + iTNManager->DeleteThumbnails( *source ); + CleanupStack::PopAndDestroy( source ); +#endif //RD_MPX_TNM_INTEGRATION + + + //delete abstract album .alb file from file system + RFs rFs; + User::LeaveIfError( rFs.Connect() ); + CleanupClosePushL( rFs ); + + TInt err = BaflUtils::DeleteFile(rFs, *uri); + if(KErrNone != err) + { + MPX_DEBUG2("CMPXDbAbstractAlbum::DeleteAbstractAlbumL,File not deleted from file system with err=%d", err); + } + + CleanupStack::PopAndDestroy( &rFs ); + } + + CleanupStack::Pop(uri); + return uri; + } + + +// ---------------------------------------------------------------------------- +// 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::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) + { + aMedia.SetTObjectValueL(KMPXMediaGeneralId, + aRecord.ColumnInt64(EAbstractAlbumUniqueId)); + } + if (attributeId & EMPXMediaGeneralTitle) + { + TPtrC title(MPXDbCommonUtil::GetColumnTextL(aRecord, EAbstractAlbumName)); + aMedia.SetTextValueL(KMPXMediaGeneralTitle, title); + MPX_DEBUG2(" AbstractAlbumName[%S]", &title); + } + if (attributeId & EMPXMediaGeneralCount) + { + TInt songCount = GetSongsCountL(KDbManagerAllDrives, + aRecord.ColumnInt64(EAbstractAlbumUniqueId)); + aMedia.SetTObjectValueL(KMPXMediaGeneralCount, songCount ); + } + if (attributeId & EMPXMediaGeneralDrive) + { + TUint32 volId(aRecord.ColumnInt64(EAbstractAlbumVolumeId)); + TInt driveId = MPXDbCommonUtil::GetDriveIdMatchVolIdL(iDbManager.Fs(), volId); + + // LTAN-7GH6BZ, crash if eject memory card when adding song to existing AbstractAlbum + // due to special timing issue, it is possible drive number is -1 and create a + // panic when use for TDriveUnit + 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); + + aMedia.SetTextValueL(KMPXMediaGeneralDrive, driveUnit.Name()); + + } + } // end if contentId == KMPXMediaIdGeneral + else if ( contentId == KMPXMediaIdMusic) + { + if (attributeId & EMPXMediaMusicAlbumArtist) + { + TPtrC albumartist(MPXDbCommonUtil::GetColumnTextL(aRecord, EAbstractAlbumArtist)); + aMedia.SetTextValueL(KMPXMediaMusicAlbumArtist, albumartist); + + + + MPX_DEBUG2(" albumartist[%S]", &albumartist); + } + if (attributeId & EMPXMediaMusicGenre) + { + TPtrC genre(MPXDbCommonUtil::GetColumnTextL(aRecord, EAbstractAlbumGenre)); + aMedia.SetTextValueL(KMPXMediaMusicGenre, genre); + MPX_DEBUG2(" Genre[%S]", &genre); + } + } + + } // end for + aMedia.SetTObjectValueL(KMPXMediaGeneralType, EMPXItem); + aMedia.SetTObjectValueL(KMPXMediaGeneralCategory, EMPXAbstractAlbum); + } + + +// ---------------------------------------------------------------------------- +// CMPXDbAbstractAlbum::GenerateAlbumFieldsValuesL +// ---------------------------------------------------------------------------- +// +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); + } + if (aMedia.IsSupported(KMPXMediaMusicGenre)) + { + TPtrC truncatedGenre(aMedia.ValueText(KMPXMediaMusicGenre).Left(KMCMaxTextLen)); + MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCMusicGenre, truncatedGenre); + } + } + + +// ---------------------------------------------------------------------------- +// 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) : + CMPXDbCategory(aDbManager, aCategory) + { + MPX_FUNC("CMPXDbAbstractAlbum::CMPXDbAbstractAlbum"); + } + +// ---------------------------------------------------------------------------- +// Second phase constructor. +// ---------------------------------------------------------------------------- +// +void CMPXDbAbstractAlbum::ConstructL() + { + MPX_FUNC("CMPXDbAbstractAlbum::ConstructL"); + + BaseConstructL(); +#ifdef RD_MPX_TNM_INTEGRATION + // Create Thumbnail Manager instance. This object is the observer. + iTNManager = CThumbnailManager::NewL( *this ); +#endif //RD_MPX_TNM_INTEGRATION + } + + + +// --------------------------------------------------------------------------- +// 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*/ ) + { + } +// End of File