FCL/sf/app/musicplayer: comparison mpserviceplugins/mpxsqlitedbhgplugin/src/mpxdbmusic.cpp

equal deleted inserted replaced

-:ecf06a08d4d9
+:3ec52facab4d
 CMPXDbMusic::CMPXDbMusic(
 CMPXDbManager& aDbManager,
 MMPXDbMusicObserver& aObserver) :
 CMPXDbTable(aDbManager),
 iObserver(aObserver)
+#ifdef ABSTRACTAUDIOALBUM_INCLUDED
+,iArtNeedUpdated(ETrue)
+#endif
 {
 MPX_FUNC("CMPXDbMusic::CMPXDbMusic");
 }
 // ----------------------------------------------------------------------------
 // Delete the existing record first and start from scratch
 DeleteSongL(songId, aDrive, ETrue);
 }
 // add the song
 DoAddSongL(songId, aMedia, aDrive, aMessageArray);
 return songId;
 }
 // ----------------------------------------------------------------------------
 // CMPXDbMusic::DoAddSongL
 // retrieve the existing record
 TInt oldSongId(0);
 oldSongId = (aMedia.ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId)).iId2;
 if ( oldSongId <= 0 )
 {
 oldSongId = aSongId;
 }
 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryMusicGetSong, oldSongId));
 CleanupClosePushL(recordset);
 if (recordset.Next() != KSqlAtRow)
 TDriveUnit driveUnit(MPXDbCommonUtil::GetDriveIdMatchVolIdL(iDbManager.Fs(),
 recordset.ColumnInt64(EMusicVolumeId)));
 visible = DoUpdateSongL(aSongId, aMedia, driveUnit, aItemChangedMessages,
 recordset);
-// Update Album table
+#ifdef ABSTRACTAUDIOALBUM_INCLUDED
-		if (aMedia.IsSupported(KMPXMediaMusicAlbumArtFileName) || aMedia.IsSupported(KMPXMediaMusicArtist))
+if(iArtNeedUpdated)
-			{
+{
-			TUint32 albumId = recordset.ColumnInt64(EMusicAlbum);
+#endif // ABSTRACTAUDIOALBUM_INCLUDED
-			iObserver.UpdateCategoryItemL(EMPXAlbum, albumId, aMedia, driveUnit, aItemChangedMessages);
+	        // Update Album table
-			}
+	        if (aMedia.IsSupported(KMPXMediaMusicAlbumArtFileName) || aMedia.IsSupported(KMPXMediaMusicArtist))
+	            {
-// Update Artist table
+	            TUint32 albumId = recordset.ColumnInt64(EMusicAlbum);
-if ( aMedia.IsSupported(KMPXMediaMusicAlbumArtFileName) )
+	            iObserver.UpdateCategoryItemL(EMPXAlbum, albumId, aMedia, driveUnit, aItemChangedMessages);
-{
+	            }
-TUint32 artistId = recordset.ColumnInt64(EMusicArtist);
-iObserver.UpdateCategoryItemL(EMPXArtist, artistId, aMedia, driveUnit, aItemChangedMessages);
+	        // Update Artist table
-}
+	        if ( aMedia.IsSupported(KMPXMediaMusicAlbumArtFileName) )
+	            {
+	            TUint32 artistId = recordset.ColumnInt64(EMusicArtist);
+	            iObserver.UpdateCategoryItemL(EMPXArtist, artistId, aMedia, driveUnit, aItemChangedMessages);
+	            }
+#ifdef ABSTRACTAUDIOALBUM_INCLUDED
+}
+iArtNeedUpdated = ETrue;  //reset flag
+#endif // ABSTRACTAUDIOALBUM_INCLUDED
 CleanupStack::PopAndDestroy(&recordset);
 }
 return visible;
 }
 TInt oldSongId(0);
 oldSongId = (aMedia.ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId)).iId2;
 if ( oldSongId <= 0 )
 {
 oldSongId = aSongId;
 }
 // process the media parameter and construct the fields and values array
 CMPXDbActiveTask::TChangeVisibility visible(GenerateMusicFieldsValuesL(oldSongId, aMedia, aItemChangedMessages,
 &aRecordset, *fields, *values, aDrive));
 // ----------------------------------------------------------------------------
 // CMPXDbMusic::GetAllSongsLimitedL
 // ----------------------------------------------------------------------------
 //
 void CMPXDbMusic::GetAllSongsLimitedL(const TArray<TMPXAttribute>& aAttrs,
 CMPXMediaArray& aMediaArray, TInt aLimit)
 {
 MPX_FUNC("CMPXDbMusic::GetAllSongsLimitedL");
 // Gets a subset of the data from all songs ordered by title
 HBufC* query = HBufC::NewLC( KQueryMusicGetSongsLimited().Length() + KMCIntegerLen );
 query->Des().Format( KQueryMusicGetSongsLimited, aLimit );
 ExecuteMediaQueryL(aAttrs, aMediaArray, *query);
 CleanupStack::PopAndDestroy( query );
 // ----------------------------------------------------------------------------
 //
 void CMPXDbMusic::GetSongsInBlockL(
 const TArray<TMPXAttribute>& aAttrs,
 CMPXMediaArray& aMediaArray,
 TPtrC aTitle,
 TUint aNumOfSongs,
 TBool aAsc)
 {
 MPX_FUNC("CMPXDbMusic::GetSongsInBlockL");
 if (aAsc)
 // ----------------------------------------------------------------------------
 // CMPXDbMusic::GetAllSongsForAbstractAlbumL
 // ----------------------------------------------------------------------------
 //
 void CMPXDbMusic::GetAllSongsForAbstractAlbumL(
-TInt aDrive,
+TUint aAbstractAlbumId,
-TInt aAbstractAlbumId,
 const TArray<TMPXAttribute>& aAttrs,
 CMPXMediaArray& aMediaArray)
 {
-MPX_FUNC("CMPXDbMusic::GetAllSongsL");
+MPX_FUNC("CMPXDbMusic::GetAllSongsForAbstractAlbumL");
-ExecuteMediaQueryL(aDrive, aAttrs, aMediaArray, KQueryMusicGetSongsForAbstractAlbum(), aAbstractAlbumId);
+ExecuteMediaQueryL(aAttrs, aMediaArray, KQueryMusicGetSongsForAbstractAlbum(), aAbstractAlbumId);
 }
 #endif // ABSTRACTAUDIOALBUM_INCLUDED
 // ----------------------------------------------------------------------------
 // CMPXDbMusic::AllSongsDurationL
 // ----------------------------------------------------------------------------
 //
 TUint CMPXDbMusic::GetDriveTrackCountL(TInt aDrive)
 {
 TUint count(0);
 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(aDrive,KQueryMusicCount));
 CleanupClosePushL(recordset);
 if (recordset.Next() != KSqlAtRow)
 {
 User::Leave(KErrCorrupt);
 }
 count = TUint(recordset.ColumnInt64(KMPXTableDefaultIndex));
 CleanupStack::PopAndDestroy(&recordset);
 return count;
 }
 // ----------------------------------------------------------------------------
 // CMPXDbMusic::GetMusicUriArrayL
 //
 void CMPXDbMusic::GetMusicUriArrayL(TInt aDrive, TInt aFromID, TInt aRecords,
 CDesCArray& aUriArr, TInt& aLastID)
 {
 MPX_FUNC("CMPXDbMusic::GetMusicUriArrayL");
 HBufC* query = NULL;
 if(aFromID == 0)
 {
 query = HBufC::NewLC(KQueryMusicGetMusicUris().Length() + KMCIntegerLen);
 query->Des().Format(KQueryMusicGetMusicUris, aRecords);
 query = HBufC::NewLC(KQueryMusicGetMusicUrisFrom().Length() + 2*KMCIntegerLen);
 query->Des().Format(KQueryMusicGetMusicUrisFrom, aFromID, aRecords);
 }
 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(aDrive,*query));
 CleanupStack::PopAndDestroy(query);
 CleanupClosePushL(recordset);
 TInt lastID = 0;
 TInt err(KErrNone);
 while((err = recordset.Next()) == KSqlAtRow)
 {
 HBufC* fullPath = MPXDbCommonUtil::CreateFullPathL(aDrive,
 // ----------------------------------------------------------------------------
 //
 TUint32 CMPXDbMusic::ArtistForAlbumL(const TUint32 aId)
 {
 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryMusicGetArtistForAlbum, aId));
 CleanupClosePushL(recordset);
 if (recordset.Next() != KSqlAtRow)
 {
 User::Leave(KErrNotFound);
 }
 TUint32 artistId = recordset.ColumnInt64(KMPXTableDefaultIndex);
 CleanupStack::PopAndDestroy(&recordset);
 return artistId;
-}
-// ----------------------------------------------------------------------------
-// CMPXDbMusic::RefreshStartL
-// ----------------------------------------------------------------------------
-//
-void CMPXDbMusic::RefreshStartL()
-{
-iRefresh = ETrue;
-MPX_FUNC("CMPXDbMusic::RefreshStartL");
-}
-// ----------------------------------------------------------------------------
-// CMPXDbMusic::RefreshEndL
-// ----------------------------------------------------------------------------
-//
-void CMPXDbMusic::RefreshEndL()
-{
-MPX_FUNC("CMPXDbMusic::RefreshEndL");
-iRefresh = EFalse;
 }
 // ----------------------------------------------------------------------------
 // CMPXDbMusic::SongExistsL
 // ----------------------------------------------------------------------------
 if (!aMedia.IsSupported(KMPXMediaGeneralId))
 {
 MPX_DEBUG1("    !aMedia.IsSupported(KMPXMediaGeneralId)");
 TUint32 songId(aMusicTable.ColumnInt64(EMusicUniqueId));
 TInt columnCount(aMusicTable.ColumnCount());
+#ifdef ABSTRACTAUDIOALBUM_INCLUDED
+if(columnCount == 40 && aMusicTable.ColumnIndex(_L("PlUId"))==38)
+{
+TUint32 pListUId(aMusicTable.ColumnInt64(38));
+aMedia.SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, TMPXItemId(pListUId, songId));
+}
+#else
 if(columnCount == 37 && aMusicTable.ColumnIndex(_L("PlUId"))==35)
 {
 TUint32 pListUId(aMusicTable.ColumnInt64(35));
 aMedia.SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, TMPXItemId(pListUId, songId));
-	}
+}
+#endif
 else
-	{
+{
-	aMedia.SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, songId);
+aMedia.SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, songId);
-	}
+}
 MPX_DEBUG2("    SongId[%d]", songId);
 }
 // FIX ME temporary always fetch URI
 if (aAttrId & EMPXMediaGeneralUri)
 {
 MPX_DEBUG2("    FullPath[%S]", uri);
 CleanupStack::PopAndDestroy(uri);
 }
 if (aAttrId & EMPXMediaGeneralDrive)
 {
 MPX_DEBUG1("    EMPXMediaGeneralDrive");
 TDriveUnit driveUnit;
 if (aMedia.IsSupported(KMPXMediaGeneralUri))
 {
 MPX_DEBUG1("        aMedia.IsSupported(KMPXMediaGeneralUri)");
 driveUnit = aMedia.ValueText(KMPXMediaGeneralUri);
 MPX_DEBUG2("        driveUnit=%d", (TInt)driveUnit);
 }
 else
 {
 MPX_DEBUG1("        !aMedia.IsSupported(KMPXMediaGeneralUri)");
 driveUnit = MPXDbCommonUtil::GetDriveIdMatchVolIdL(iDbManager.Fs(),
 aMusicTable.ColumnInt64(EMusicVolumeId));
 MPX_DEBUG2("        driveUnit=%d", (TInt)driveUnit);
 }
 TPtrC driveName(driveUnit.Name());
 aMedia.SetTextValueL(KMPXMediaGeneralDrive, driveName);
 MPX_DEBUG2("    Drive[%S]", &driveName);
 }
 if (aAttrId & EMPXMediaGeneralSize)
 {
 MPX_DEBUG1("    EMPXMediaGeneralSize");
 // to-do: store this in the DB
 }
 if (aAttrId & EMPXMediaGeneralDuration)
 {
 MPX_DEBUG1("    EMPXMediaGeneralDuration");
 TInt32 duration(aMusicTable.ColumnInt(EMusicDuration));
 aMedia.SetTObjectValueL<TInt>(KMPXMediaGeneralDuration, duration);
 MPX_DEBUG2("    Duration[%d]", duration);
 }
 if ((aAttrId & EMPXMediaGeneralTitle) && !aMedia.IsSupported(KMPXMediaGeneralTitle))
 TPtrC title(MPXDbCommonUtil::GetColumnTextL(aMusicTable, EMusicTitle));
 aMedia.SetTextValueL(KMPXMediaGeneralTitle, title);
 MPX_DEBUG2("    Title[%S]", &title);
 }
 if ( aAttrId & EMPXMediaGeneralDate)
-		{
+{
-		MPX_DEBUG1("    EMPXMediaGeneralDate");
+MPX_DEBUG1("    EMPXMediaGeneralDate");
-		const TDesC& dateStr(MPXDbCommonUtil::GetColumnTextL (aMusicTable,
+const TDesC& dateStr(MPXDbCommonUtil::GetColumnTextL (aMusicTable,
-				EMusicTimeAdded));
+EMusicTimeAdded));
-		if ( dateStr.Compare (KNullDesC)!= 0)
+if ( dateStr.Compare (KNullDesC)!= 0)
-			{
+{
-			TTime dateTime(MPXDbCommonUtil::DesToTTimeL (dateStr));
+TTime dateTime(MPXDbCommonUtil::DesToTTimeL (dateStr));
-			aMedia.SetTObjectValueL<TInt64> (KMPXMediaGeneralDate,
+aMedia.SetTObjectValueL<TInt64> (KMPXMediaGeneralDate,
-					dateTime.Int64 ());
+dateTime.Int64 ());
-			}
+}
-		MPX_DEBUG2("    Date[%S]", &dateStr);
+MPX_DEBUG2("    Date[%S]", &dateStr);
-		}
+}
 if (aAttrId & EMPXMediaGeneralComment)
 {
 MPX_DEBUG1("    EMPXMediaGeneralComment");
 TPtrC comment(MPXDbCommonUtil::GetColumnTextL(aMusicTable, EMusicComment));
 aMedia.SetTextValueL(KMPXMediaGeneralComment, comment);
 MPX_DEBUG2("    Comment[%S]", &comment);
 }
 if (aAttrId & EMPXMediaGeneralMimeType)
 {
 MPX_DEBUG1("    EMPXMediaGeneralMimeType");
 TPtrC mimeType(MPXDbCommonUtil::GetColumnTextL(aMusicTable, EMusicMimeType));
 aMedia.SetTextValueL(KMPXMediaGeneralMimeType, mimeType);
 MPX_DEBUG2("    MimeType[%S]", &mimeType);
 }
 if (aAttrId & EMPXMediaGeneralSynchronized)
 {
 MPX_DEBUG1("    EMPXMediaGeneralSynchronized");
 TInt sync(aMusicTable.ColumnInt(EMusicSync));
 aMedia.SetTObjectValueL<TBool>(KMPXMediaGeneralSynchronized, sync);
 MPX_DEBUG2("    Synchronized[%d]", sync);
 }
 if (aAttrId & EMPXMediaGeneralDeleted)
 {
 MPX_DEBUG1("    EMPXMediaGeneralDeleted");
 TInt del(aMusicTable.ColumnInt(EMusicDeleted));
 aMedia.SetTObjectValueL<TBool>(KMPXMediaGeneralDeleted, del);
 MPX_DEBUG2("    Deleted[%d]", del);
 }
 if (aAttrId & EMPXMediaGeneralModified)
 MPX_DEBUG1("    EMPXMediaGeneralCount");
 aMedia.SetTObjectValueL<TInt>(KMPXMediaGeneralCount, 1);
 }
 if (aAttrId & EMPXMediaGeneralCollectionId)
 {
 MPX_DEBUG1("    EMPXMediaGeneralCollectionId");
 aMedia.SetTObjectValueL<TUid>(KMPXMediaGeneralCollectionId,
 TUid::Uid(KDBPluginUid));
 }
 if(aAttrId & EMPXMediaGeneralCopyright)
 {
 MPX_DEBUG1("    EMPXMediaGeneralCopyright");
 TPtrC copyright(MPXDbCommonUtil::GetColumnTextL(aMusicTable, EMusicCopyright));
 aMedia.SetTextValueL(KMPXMediaGeneralCopyright, copyright);
 MPX_DEBUG2("    Copyright[%S]", &copyright);
 }
 if (aAttrId & EMPXMediaGeneralFlags)
 {
 MPX_DEBUG1("    EMPXMediaGeneralFlags");
 TUint32 dbFlags(aMusicTable.ColumnInt64(EMusicDbFlag));
 MPX_DEBUG2("        dbFlags=%b", dbFlags);
 TDriveUnit driveUnit;
 if (aMedia.IsSupported(KMPXMediaGeneralUri))
 {
 driveUnit = parse.Drive();
 }
 else
 {
 driveUnit = MPXDbCommonUtil::GetDriveIdMatchVolIdL(iDbManager.Fs(),
 aMusicTable.ColumnInt64(EMusicVolumeId));
 }
 MPX_DEBUG2("        driveUnit=%d", (TInt)driveUnit);
 }
 else
 {
 MPX_DEBUG1("        !aMedia.IsSupported(KMPXMediaGeneralUri)");
 driveUnit = MPXDbCommonUtil::GetDriveIdMatchVolIdL(iDbManager.Fs(),
 aMusicTable.ColumnInt64(EMusicVolumeId));
 MPX_DEBUG2("        driveUnit=%d", (TInt)driveUnit);
 }
 TInt driveId = driveUnit & KMPXMediaGeneralFlagsDriveInfo;  // 5 bits
 aMedia.SetTObjectValueL<TUint>(KMPXMediaGeneralFlags, dbFlags | driveId);
 MPX_DEBUG2("    GeneralFlags[%b]", dbFlags | driveId);
 MPX_DEBUG2("    DriveId[%u]", driveId);
 }
 if (aAttrId & EMPXMediaGeneralPlayCount)
 {
 MPX_DEBUG1("    EMPXMediaGeneralPlayCount");
 TUint32 playcount(aMusicTable.ColumnInt(EMusicPlayCount));
 aMedia.SetTObjectValueL<TInt>(KMPXMediaGeneralPlayCount, playcount);
 MPX_DEBUG2("    PlayCount[%d]", playcount);
 }
 MPX_DEBUG1("<--CMPXDbMusic::UpdateMediaGeneralL");
 }
 // ----------------------------------------------------------------------------
 // CMPXDbMusic::UpdateMediaMusicL
 TPtrC album(MPXDbCommonUtil::GetColumnTextL(aMusicTable, EMusicAlbumName));
 aMedia.SetTextValueL(KMPXMediaMusicAlbum, album);
 MPX_DEBUG2("    Album[%S]", &album);
 }
 if ( aAttrId & EMPXMediaMusicYear)
-		{
+{
-		const TDesC& dateStr(MPXDbCommonUtil::GetColumnTextL (aMusicTable,
+const TDesC& dateStr(MPXDbCommonUtil::GetColumnTextL (aMusicTable,
-				EMusicReleaseDate));
+EMusicReleaseDate));
-		if ( dateStr.Compare (KNullDesC)!= 0)
+if ( dateStr.Compare (KNullDesC)!= 0)
-			{
+{
-			TTime dateTime(MPXDbCommonUtil::DesToTTimeL (dateStr));
+TTime dateTime(MPXDbCommonUtil::DesToTTimeL (dateStr));
-			aMedia.SetTObjectValueL<TInt64> (KMPXMediaMusicYear,
+aMedia.SetTObjectValueL<TInt64> (KMPXMediaMusicYear,
-					dateTime.Int64 ());
+dateTime.Int64 ());
-			MPX_DEBUG2("    Year[%d]", dateTime.Int64());
+MPX_DEBUG2("    Year[%d]", dateTime.Int64());
-			}
+}
-		MPX_DEBUG2("    ReleaseDate[%S]", &dateStr);
+MPX_DEBUG2("    ReleaseDate[%S]", &dateStr);
-		}
+}
 if (aAttrId & EMPXMediaMusicAlbumTrack)
 {
 TInt32 track(aMusicTable.ColumnInt(EMusicAlbumTrack));
 HBufC* hbuf = HBufC::NewLC(KMCIntegerLen);
 if (track != KMaxTInt)
 MPX_DEBUG2("    Music Original Album Art FullPath[%S]", fullPath);
 CleanupStack::PopAndDestroy(fullPath);
 }
 }
 #ifdef ABSTRACTAUDIOALBUM_INCLUDED
 if (aAttrId & EMPXMediaMusicAlbumArtist)
 {
 TPtrC albumartist(MPXDbCommonUtil::GetColumnTextL(aMusicTable, EMusicAlbumArtist));
 aMedia.SetTextValueL(KMPXMediaMusicAlbumArtist, albumartist);
 MPX_DEBUG2("    Music AlbumArtist[%S]", &albumartist);
 }
 #endif // ABSTRACTAUDIOALBUM_INCLUDED
+if (aAttrId & EMPXMediaMusicAlbumId)
+{
+TUint32 albumId(aMusicTable.ColumnInt64(EMusicAlbum));
+aMedia.SetTObjectValueL<TMPXItemId>(KMPXMediaMusicAlbumId, albumId);
+MPX_DEBUG2("    AlbumId[%d]", albumId);
+}
 }
 // ----------------------------------------------------------------------------
 // CMPXDbMusic::UpdateMediaAudioL
 // ----------------------------------------------------------------------------
 if (aItemChangedMessages)
 {
 songChangedMessage = CMPXMedia::NewL();
 CleanupStack::PushL(songChangedMessage);
 MPXDbCommonUtil::FillItemChangedMessageL(*songChangedMessage, aSongId,
 aMusicTable ? EMPXItemModified : EMPXItemInserted, EMPXSong, KDBPluginUid);
 }
 // NOTE: Attributes being processed here should be listed in IsSupported()
 TInt attrCount(attributes.Count());
 for (TInt i = 0; i < attrCount; ++i)
 TUint32 curFlag(0);
 if (aMusicTable)
 {
 curFlag = aMusicTable->ColumnInt64(EMusicDbFlag);
 }
 TUint32 oldFlag(curFlag);
 if (flag & KMPXMediaGeneralFlagsSetOrUnsetBit)
 {
 // Set bits
 curFlag |= flag;
 visibleChange = CMPXDbActiveTask::ESingleVisible;
 if (aItemChangedMessages)
 {
 iObserver.HandlePlayCountModifiedL(*aItemChangedMessages);
 }
 addSongChangedMessage = EFalse;
 }
 MPX_DEBUG2("    PlayCount[%d]", curCount);
 }
 if (attributeId & EMPXMediaGeneralLastPlaybackTime)
 {
 visibleChange = CMPXDbActiveTask::ESingleVisible;
 if (aItemChangedMessages)
 {
 iObserver.HandlePlaybackTimeModifiedL(*aItemChangedMessages);
 }
 addSongChangedMessage = EFalse;
 }
 MPX_DEBUG2("    PlaybackTime[%S]", time);
 CleanupStack::PopAndDestroy(time);
 }
 #endif // ABSTRACTAUDIOALBUM_INCLUDED
 const TDesC& albumArtFilename = aMedia.ValueText(KMPXMediaMusicAlbumArtFileName).Left(KMCMaxTextLen);
 #ifdef ABSTRACTAUDIOALBUM_INCLUDED
 TParsePtrC parse(albumArtFilename);
 TPtrC ext(parse.Ext());
+//set flag to false, so .alb will not overwrite art field in album, artist table
+// when song with embedded art
+if ((ext.CompareF(KAbstractAlbumExt)== 0) && containEmbeddedArt)
+{
+iArtNeedUpdated = EFalse;
+}
 if ( ((ext.CompareF(KAbstractAlbumExt)== 0) && !containEmbeddedArt) || (ext.CompareF(KAbstractAlbumExt)!= 0))
 {
 #endif // ABSTRACTAUDIOALBUM_INCLUDED
 if (!aMusicTable || (albumArtFilename != MPXDbCommonUtil::GetColumnTextL(*aMusicTable, EMusicArt)))
 {
 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCMusicDRM, drmType);
 }
 MPX_DEBUG2("    DRM type[%d]", drmType);
 }
 if (attributeId & KMPXMediaDrmRightsStatus.iAttributeId)
 {
 if (aMusicTable)
 {
 TMPXMediaDrmRightsStatus status =
 aMedia.ValueTObjectL<TMPXMediaDrmRightsStatus>(KMPXMediaDrmRightsStatus);
 //.Set the db flag
 TUint32 curFlag(aMusicTable->ColumnInt64(EMusicDbFlag));
 TUint32 oldFlag(curFlag);
 if ((status != EMPXDrmRightsFull) && (status != EMPXDrmRightsRestricted))
 {
 // No rights
 curFlag |= KMPXMediaGeneralFlagsIsDrmLicenceInvalid;
 }
 else
 {
 // Rights valid
 curFlag &= (KMPXMediaGeneralFlagsIsDrmLicenceInvalid ^ 0xFFFFFFFF);
 }
 // The field is written ONLY if the flag value is changing
 if (((curFlag ^ oldFlag) & 0x7FFFFFFF) != 0)
 {
 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCMusicDbFlag, curFlag);
 visibleChange = CMPXDbActiveTask::EAllVisible;
 }
 MPX_DEBUG2("    Rights Status[%d]", curFlag);
 }
 }
 break;
 }
 case KMPXMediaIdMTP:
 {
 default:
 break;
 } // end switch
 } // end for
-// get the current artist/album/genre/composer
+// get the current artist/album/genre/composer/abstractalbum
 // this is required because the recordset may be reused by the code below
 TUint32 artistId(0);
 TUint32 albumId(0);
 TUint32 genreId(0);
 TUint32 composerId(0);
 visibleChange = CMPXDbActiveTask::EAllVisible;
 artistIdForAlbum = id;
 }
 // update the album field
-	if (UpdateCategoryFieldL(EMPXAlbum, aMedia, KMPXMediaMusicAlbum, albumId,
+if (UpdateCategoryFieldL(EMPXAlbum, aMedia, KMPXMediaMusicAlbum, albumId,
-		aDrive, aItemChangedMessages, id, artistIdForAlbum))
+aDrive, aItemChangedMessages, id, artistIdForAlbum))
 {
 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCMusicAlbum, id);
 metaDataModified = (aMusicTable != NULL);
 visibleChange = CMPXDbActiveTask::EAllVisible;
 //
 // added to handle error EALU-73WDJN. If the album name of the last song
 // in the album for the artist is changed to an existing album name from
 // artist view, a change message needs to be sent in order for UI to
 // correctly refresh.
 //
 // Fix for EDXU-7BBALS, remove check for HasOtherSongsInArtistAlbumL
 // Always send a Album Inserted message when Album change to get Artist updated
 if (aItemChangedMessages)
 {
 // send album added m essage instead of album deleted or modified
 // to avoid collection paths of other clients being modified
 MPXDbCommonUtil::AddItemChangedMessageL(*aItemChangedMessages, albumId,
 EMPXItemInserted, EMPXAlbum, KDBPluginUid);
 }
 }
 // update the genre field
 {
 aItemChangedMessages->AppendL(*songChangedMessage);
 }
 CleanupStack::PopAndDestroy(songChangedMessage);
 }
 return visibleChange;
 }
 // ----------------------------------------------------------------------------
 // CMPXDbMusic::DRMTypeL
 {
 // full URI from criteria
 const TDesC& uri = aCriteria.ValueText(KMPXMediaGeneralUri);
 TUint32 itemId = MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), EMPXCollection,
 uri, EFalse);
 MPXDbCommonUtil::AddSqlCriterionL(*sqlCriteria, KCriterionMusicUniqueId, itemId);
 }
 else if (criterion == KMPXMediaGeneralDrive)
 {
 if (!volumeAdded)
 {
 // validate the drive letter, TDriveUnit panics if given drive isn't between
 // 'A' to 'Z'
-TDriveUnit driveUnit(aCriteria.ValueText(KMPXMediaGeneralDrive));
+const TDesC& drive = aCriteria.ValueText(KMPXMediaGeneralDrive);
+TInt driveInt = 0;
+if( drive == KNullDesC || RFs::CharToDrive( drive[0], driveInt )!= KErrNone )
+{
+User::Leave(KErrArgument);
+}
+TDriveUnit driveUnit(drive);
 MPXDbCommonUtil::AddSqlCriterionL(*sqlCriteria, KCriterionMusicVolume,
 MPXDbCommonUtil::GetVolIdMatchDriveIdL(iDbManager.Fs(), driveUnit));
 volumeAdded = ETrue;
 }
 }
 if (!aOldId || aMedia.IsSupported(aAttribute))
 {
 TInt changeMsgCount( 0 );
 if( aItemChangedMessages )
 {
 changeMsgCount = aItemChangedMessages->Count();
 }
 if (aMedia.IsSupported(aAttribute))
 {
 TPtrC name(aMedia.ValueText(aAttribute).Left(KMCMaxTextLen));
 // construct the new ID for the category record
+#ifdef ABSTRACTAUDIOALBUM_INCLUDED
+// genre and abstractalbum are not case sensitive
+TBool caseSensitive = ETrue;
+if ((aCategory == EMPXGenre) || (aCategory == EMPXAbstractAlbum))
+caseSensitive = EFalse;
+aItemId = MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), aCategory,
+name, caseSensitive);
+#else
 // only genre is not case sensitive
 aItemId = MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), aCategory,
 name, (aCategory != EMPXGenre));
+#endif
 if (!aOldId || (aOldId != aItemId))
 {
 // only add if the ID changed,
 // otherwise the song was updated but the artist name was not
 #ifdef ABSTRACTAUDIOALBUM_INCLUDED
 if(aCategory == EMPXAbstractAlbum)
 {
 if (aMedia.ValueTObjectL<TMPXGeneralCategory>(KMPXMediaGeneralCategory) == EMPXSong )
 {
-iObserver.AddCategoryItemL(aCategory, name, aDriveId,
+iObserver.AddCategoryItemL(aCategory, KNullDesC, aDriveId,
-aItemChangedMessages, itemAdded, KNullDesC, KNullDesC);
+aItemChangedMessages, itemAdded, name, KNullDesC);
 }
 else
 {
-TPtrC albumartist(aMedia.ValueText(KMPXMediaMusicAlbumArtist).Left(KMCMaxTextLen));
+TPtrC albumartist(KNullDesC);
-//get AlbumArt, Genre for AbstractAlbum
+TPtrC abstractAlbumName(KNullDesC);
-MPX_DEBUG2("    Music albumartist[%S]", &albumartist);
+if (aMedia.IsSupported(KMPXMediaMusicAlbumArtist) )
-TPtrC genre(aMedia.ValueText(KMPXMediaMusicGenre).Left(KMCMaxTextLen));
+{
-MPX_DEBUG2("    Music Genre[%S]", &genre);
+albumartist.Set(aMedia.ValueText(KMPXMediaMusicAlbumArtist).Left(KMCMaxTextLen));
+//get AlbumArt AbstractAlbum
-// ignore the return value
+MPX_DEBUG2("     albumartist[%S]", &albumartist);
-iObserver.AddCategoryItemL(aCategory, name, aDriveId,
+}
-aItemChangedMessages, itemAdded, albumartist, genre);
+if (aMedia.IsSupported(KMPXMediaGeneralTitle) )
+{
+abstractAlbumName.Set(aMedia.ValueText(KMPXMediaGeneralTitle).Left(KMCMaxTextLen));
+MPX_DEBUG2("     abstractAlbumName[%S]", &abstractAlbumName);
+}
+// ignore the return value
+iObserver.AddCategoryItemL(aCategory, abstractAlbumName, aDriveId,
+aItemChangedMessages, itemAdded, name, albumartist);
 }
 }
 else
 #endif // ABSTRACTAUDIOALBUM_INCLUDED
 {
 updated = ETrue;
 }
 }
 else
 {
+#ifdef ABSTRACTAUDIOALBUM_INCLUDED
+// genre and abstractalbum are not case sensitive
+aItemId = MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), aCategory, KNullDesC,
+(aCategory != EMPXGenre)&&(aCategory != EMPXAbstractAlbum));
+#else
 // only genre is not case sensitive
 aItemId = MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), aCategory, KNullDesC,
 (aCategory != EMPXGenre));
+#endif
 if (!aOldId || (aOldId != aItemId))
 {
 #ifdef ABSTRACTAUDIOALBUM_INCLUDED
 if(aCategory == EMPXAbstractAlbum)
 {
-//get AlbumArt, Genre for AbstractAlbum
+//get AlbumArt for AbstractAlbum
 TPtrC albumartist(aMedia.ValueText(KMPXMediaMusicAlbumArtist).Left(KMCMaxTextLen));
 MPX_DEBUG2("    Music albumartist[%S]", &albumartist);
-TPtrC genre(aMedia.ValueText(KMPXMediaMusicGenre).Left(KMCMaxTextLen));
+TPtrC abstractAlbumName(aMedia.ValueText(KMPXMediaGeneralTitle).Left(KMCMaxTextLen));
-MPX_DEBUG2("    Music Genre[%S]", &genre);
+MPX_DEBUG2("    Music abstractAlbumName[%S]", &abstractAlbumName);
 // ignore the return value
-iObserver.AddCategoryItemL(aCategory, KNullDesC, aDriveId,
+iObserver.AddCategoryItemL(aCategory, abstractAlbumName, aDriveId,
-aItemChangedMessages, itemAdded, albumartist, genre);
+aItemChangedMessages, itemAdded, KNullDesC, albumartist);
 }
 else
 #endif // ABSTRACTAUDIOALBUM_INCLUDED
 {
 // ignore the return value
 iObserver.AddCategoryItemL(aCategory, KNullDesC, aDriveId,
 aItemChangedMessages, itemAdded);
 }
 updated = ETrue;
 }
 }
-#ifdef ABSTRACTAUDIOALBUM_INCLUDED
-//no need to delete old item for abstractalbum
+if (aOldId && (aOldId != aItemId))
-if (aOldId && (aOldId != aItemId) && (aCategory != EMPXAbstractAlbum))
+{
-#else
+iObserver.DeleteSongForCategoryL(aCategory, aOldId, aDriveId,
-if (aOldId && (aOldId != aItemId))
-#endif // ABSTRACTAUDIOALBUM_INCLUDED
-{
-iObserver.DeleteSongForCategoryL(aCategory, aOldId, aDriveId,
 aItemChangedMessages, itemNotRemoved);
 updated = ETrue;
 }
 // Special case where the item(s) has been renamed.
 // In this case, a new category is created +1 change msg
 //               a old category is removed +1 change msg
 // We merge these 2 change messages into one using the deprecated ID
 //
 TInt oldId = KErrNotFound;
 TInt newId = KErrNotFound;
 for( TInt i=0; i<newChangeMsgCount; ++i )
 {
 CMPXMessage& msg = *(*aItemChangedMessages)[i];
 TMPXItemId id = msg.ValueTObjectL<TMPXItemId>(KMPXMessageMediaGeneralId);
 TMPXChangeEventType changeType = msg.ValueTObjectL<TMPXChangeEventType>(KMPXMessageChangeEventType);
 // Look for the added and deleted category IDs
 //
 if( id == aOldId && changeType == EMPXItemDeleted )
 {
 oldId = i;
 else if( id == aItemId && changeType == EMPXItemInserted )
 {
 newId = i;
 }
 }
 if( oldId != KErrNotFound &&
 newId != KErrNotFound )
 {
 aItemChangedMessages->Remove(oldId);  // category removed
 aItemChangedMessages->Remove(newId);  // category added
 MPXDbCommonUtil::AddItemChangedMessageL(*aItemChangedMessages, aItemId, EMPXItemModified,
 const CMPXMedia& aMedia,
 const TMPXAttribute& aAttribute,
 TUint32 aOldId,
 TInt aDriveId,
 CMPXMessageArray* aItemChangedMessages,
 TUint32& aItemId,
 TUint32 aArtistId)
 {
 TBool updated(EFalse);
 TBool itemNotRemoved( EFalse );
 TBool itemAdded( EFalse );
 if (!aOldId || aMedia.IsSupported(aAttribute))
 {
 TInt changeMsgCount( 0 );
 if( aItemChangedMessages )
 {
 changeMsgCount = aItemChangedMessages->Count();
 }
 if (aMedia.IsSupported(aAttribute))
 {
 TPtrC name(aMedia.ValueText(aAttribute).Left(KMCMaxTextLen));
 // construct the new ID for the category record
 name, (aCategory != EMPXGenre));
 if (!aOldId || (aOldId != aItemId))
 {
 // only add if the ID changed,
 // otherwise the song was updated but the artist name was not
+TPtrC art(KNullDesC);
+if (aMedia.IsSupported(KMPXMediaMusicAlbumArtFileName))
+{
+art.Set(aMedia.ValueText(KMPXMediaMusicAlbumArtFileName).Left(KMCMaxTextLen));
+}
+iObserver.AddCategoryItemL(aCategory, name, aArtistId, art, aDriveId, aItemChangedMessages, itemAdded);
+updated = ETrue;
+}
+}
+else
+{
+// only genre is not case sensitive
+aItemId = MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), aCategory, KNullDesC,
+(aCategory != EMPXGenre));
+if (!aOldId || (aOldId != aItemId))
+{
 				TPtrC art(KNullDesC);
 				if (aMedia.IsSupported(KMPXMediaMusicAlbumArtFileName))
 					{
 					art.Set(aMedia.ValueText(KMPXMediaMusicAlbumArtFileName).Left(KMCMaxTextLen));
 					}
-				iObserver.AddCategoryItemL(aCategory, name, aArtistId, art, aDriveId, aItemChangedMessages, itemAdded);
+				iObserver.AddCategoryItemL(aCategory, KNullDesC, aArtistId, art, aDriveId,
-updated = ETrue;
-}
-}
-else
-{
-// only genre is not case sensitive
-aItemId = MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), aCategory, KNullDesC,
-(aCategory != EMPXGenre));
-if (!aOldId || (aOldId != aItemId))
-{
-				TPtrC art(KNullDesC);
-				if (aMedia.IsSupported(KMPXMediaMusicAlbumArtFileName))
-					{
-					art.Set(aMedia.ValueText(KMPXMediaMusicAlbumArtFileName).Left(KMCMaxTextLen));
-					}
-				iObserver.AddCategoryItemL(aCategory, KNullDesC, aArtistId, art, aDriveId,
 aItemChangedMessages, itemAdded);
 updated = ETrue;
 }
 }
 if (aOldId && (aOldId != aItemId))
 {
 iObserver.DeleteSongForCategoryL(aCategory, aOldId, aDriveId,
 aItemChangedMessages, itemNotRemoved);
 updated = ETrue;
 }
 // Special case where the item(s) has been renamed.
 // In this case, a new category is created +1 change msg
 //               a old category is removed +1 change msg
 // We merge these 2 change messages into one using the deprecated ID
 //
 TInt oldId = KErrNotFound;
 TInt newId = KErrNotFound;
 for( TInt i=0; i<newChangeMsgCount; ++i )
 {
 CMPXMessage& msg = *(*aItemChangedMessages)[i];
 TMPXItemId id = msg.ValueTObjectL<TMPXItemId>(KMPXMessageMediaGeneralId);
 TMPXChangeEventType changeType = msg.ValueTObjectL<TMPXChangeEventType>(KMPXMessageChangeEventType);
 // Look for the added and deleted category IDs
 //
 if( id == aOldId && changeType == EMPXItemDeleted )
 {
 oldId = i;
 else if( id == aItemId && changeType == EMPXItemInserted )
 {
 newId = i;
 }
 }
 if( oldId != KErrNotFound &&
 newId != KErrNotFound )
 {
 aItemChangedMessages->Remove(oldId);  // category removed
 aItemChangedMessages->Remove(newId);  // category added
 MPXDbCommonUtil::AddItemChangedMessageL(*aItemChangedMessages, aItemId, EMPXItemModified,
 EMPXMediaGeneralType |
 EMPXMediaGeneralCategory |
 EMPXMediaGeneralTitle |
 EMPXMediaGeneralUri |
 EMPXMediaGeneralFlags);
 TBool extraRequired(EFalse);
 TInt count(aAttrs.Count());
 for (TInt i = 0; i < count; ++i)
 {
 TUint attributeId(aAttrs[i].AttributeId()|defaultFields);
 // ----------------------------------------------------------------------------------------------------------
 //
 TBool CMPXDbMusic::IsSupported(
 const CMPXMedia& aMedia)
 {
 MPX_FUNC("CMPXDbMusic::IsSupported");
 // this checklist should match the attributes processed in DoFillInDatabaseInfoL
 return aMedia.IsSupported(KMPXMediaGeneralTitle) ||
 aMedia.IsSupported(KMPXMediaGeneralUri) ||
 aMedia.IsSupported(KMPXMediaGeneralComment) ||

changeset 25	3ec52facab4d
parent 22	ecf06a08d4d9
child 29	8192e5b5c935