680 void CMPXDbMusic::GetAllSongsLimitedL(const TArray<TMPXAttribute>& aAttrs, |
683 void CMPXDbMusic::GetAllSongsLimitedL(const TArray<TMPXAttribute>& aAttrs, |
681 CMPXMediaArray& aMediaArray, TInt aLimit) |
684 CMPXMediaArray& aMediaArray, TInt aLimit) |
682 { |
685 { |
683 MPX_FUNC("CMPXDbMusic::GetAllSongsLimitedL"); |
686 MPX_FUNC("CMPXDbMusic::GetAllSongsLimitedL"); |
684 |
687 |
685 // Gets a subset of the data from all songs ordered by title |
688 // Reset and create a cache for the query results. |
686 HBufC* query = HBufC::NewLC( KQueryMusicGetSongsLimited().Length() + KMCIntegerLen ); |
689 if (iAllSongsQueryResult.Count()) |
687 query->Des().Format( KQueryMusicGetSongsLimited, aLimit ); |
690 { |
688 ExecuteMediaQueryL(aAttrs, aMediaArray, *query); |
691 iAllSongsQueryResult.ResetAndDestroy(); |
689 CleanupStack::PopAndDestroy( query ); |
692 } |
|
693 |
|
694 ExecuteQueryAllSongsL(aAttrs); |
|
695 |
|
696 TInt limit = aLimit > iAllSongsQueryResult.Count() ? |
|
697 iAllSongsQueryResult.Count() : aLimit; |
|
698 |
|
699 for ( TInt i=0; i < limit; i++ ) |
|
700 { |
|
701 CMPXMedia* m = iAllSongsQueryResult[i]; |
|
702 aMediaArray.AppendL(*m); |
|
703 } |
|
704 } |
|
705 |
|
706 // ---------------------------------------------------------------------------- |
|
707 // CMPXDbMusic::ExecuteQueryAllSongsL |
|
708 // ---------------------------------------------------------------------------- |
|
709 // |
|
710 void CMPXDbMusic::ExecuteQueryAllSongsL(const TArray<TMPXAttribute>& aAttrs) |
|
711 { |
|
712 // Run query and add result media objects to the cache array. |
|
713 MPX_FUNC("CMPXDbMusic::ExecuteQueryAllSongsL"); |
|
714 |
|
715 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryMusicGetAllSongs)); |
|
716 CleanupClosePushL(recordset); |
|
717 |
|
718 TInt err(KErrNone); |
|
719 while ((err = recordset.Next()) == KSqlAtRow) |
|
720 { |
|
721 CMPXMedia* media = CMPXMedia::NewL(); |
|
722 CleanupStack::PushL(media); |
|
723 UpdateMediaL(recordset, aAttrs, *media); |
|
724 iAllSongsQueryResult.AppendL(media); |
|
725 CleanupStack::Pop(media); |
|
726 } |
|
727 |
|
728 CleanupStack::PopAndDestroy(&recordset); |
|
729 if (err!= KSqlAtEnd) |
|
730 { |
|
731 User::Leave(KErrCorrupt); |
|
732 } |
690 } |
733 } |
691 |
734 |
692 // ---------------------------------------------------------------------------- |
735 // ---------------------------------------------------------------------------- |
693 // CMPXDbMusic::GetSongsInBlockL |
736 // CMPXDbMusic::GetSongsInBlockL |
694 // ---------------------------------------------------------------------------- |
737 // ---------------------------------------------------------------------------- |
721 void CMPXDbMusic::GetSongsAtOffsetL( CMPXMediaArray& aMediaArray, |
764 void CMPXDbMusic::GetSongsAtOffsetL( CMPXMediaArray& aMediaArray, |
722 const TArray<TMPXAttribute>& aAttrs, |
765 const TArray<TMPXAttribute>& aAttrs, |
723 TInt aOffset, |
766 TInt aOffset, |
724 TInt aCount ) |
767 TInt aCount ) |
725 { |
768 { |
726 MPX_DEBUG1("CMPXDbMusic::GetSongsAtOffsetL <--"); |
769 MPX_DEBUG3("CMPXDbMusic::GetSongsAtOffsetL offset[%d], count[%d]", aOffset, aCount); |
727 |
770 |
728 ExecuteMediaQueryL(aAttrs, aMediaArray, KQueryMusicGetSongsAtOffset, |
771 if ( !iAllSongsQueryResult.Count() ) |
729 aCount, aOffset, EOffSetQuery ); |
772 { |
730 |
773 // If there's no cache, create a cache for the query results. |
731 MPX_DEBUG1("CMPXDbMusic::GetSongsAtOffsetL() -->"); |
774 ExecuteQueryAllSongsL(aAttrs); |
|
775 } |
|
776 |
|
777 TInt limit = aOffset + aCount > iAllSongsQueryResult.Count() ? |
|
778 iAllSongsQueryResult.Count() : aOffset + aCount; |
|
779 for ( TInt i = aOffset; i < limit; i++ ) |
|
780 { |
|
781 CMPXMedia* m = iAllSongsQueryResult[i]; |
|
782 aMediaArray.AppendL(*m); |
|
783 } |
|
784 |
|
785 MPX_DEBUG1("CMPXDbMusic::GetSongsAtOffsetL() -->"); |
732 } |
786 } |
733 |
787 |
734 // ---------------------------------------------------------------------------- |
788 // ---------------------------------------------------------------------------- |
735 // CMPXDbMusic::GetSongsForArtistL |
789 // CMPXDbMusic::GetSongsForArtistL |
736 // ---------------------------------------------------------------------------- |
790 // ---------------------------------------------------------------------------- |
2079 #endif // ABSTRACTAUDIOALBUM_INCLUDED |
2133 #endif // ABSTRACTAUDIOALBUM_INCLUDED |
2080 } |
2134 } |
2081 |
2135 |
2082 // update the artist field |
2136 // update the artist field |
2083 TUint32 id(0); |
2137 TUint32 id(0); |
2084 TUint32 artistIdForAlbum(artistId); |
|
2085 if (UpdateCategoryFieldL(EMPXArtist, aMedia, KMPXMediaMusicArtist, artistId, |
2138 if (UpdateCategoryFieldL(EMPXArtist, aMedia, KMPXMediaMusicArtist, artistId, |
2086 aDrive, aItemChangedMessages, id, 0)) |
2139 aDrive, aItemChangedMessages, id)) |
2087 { |
2140 { |
2088 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCMusicArtist, id); |
2141 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCMusicArtist, id); |
2089 metaDataModified = (aMusicTable != NULL); |
2142 metaDataModified = (aMusicTable != NULL); |
2090 visibleChange = CMPXDbActiveTask::EAllVisible; |
2143 visibleChange = CMPXDbActiveTask::EAllVisible; |
2091 artistIdForAlbum = id; |
|
2092 } |
2144 } |
2093 |
2145 |
2094 // update the album field |
2146 // update the album field |
2095 if (UpdateCategoryFieldL(EMPXAlbum, aMedia, KMPXMediaMusicAlbum, albumId, |
2147 if (UpdateCategoryFieldL(EMPXAlbum, aMedia, KMPXMediaMusicAlbum, albumId, |
2096 aDrive, aItemChangedMessages, id, artistIdForAlbum)) |
2148 aDrive, aItemChangedMessages, id)) |
2097 { |
2149 { |
2098 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCMusicAlbum, id); |
2150 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCMusicAlbum, id); |
2099 metaDataModified = (aMusicTable != NULL); |
2151 metaDataModified = (aMusicTable != NULL); |
2100 visibleChange = CMPXDbActiveTask::EAllVisible; |
2152 visibleChange = CMPXDbActiveTask::EAllVisible; |
2101 |
2153 |
2486 aItemChangedMessages, itemAdded, name, albumartist); |
2538 aItemChangedMessages, itemAdded, name, albumartist); |
2487 } |
2539 } |
2488 } |
2540 } |
2489 else |
2541 else |
2490 #endif // ABSTRACTAUDIOALBUM_INCLUDED |
2542 #endif // ABSTRACTAUDIOALBUM_INCLUDED |
|
2543 if (aCategory == EMPXArtist || aCategory == EMPXAlbum) |
|
2544 { |
|
2545 TPtrC art(KNullDesC); |
|
2546 TPtrC artistname(KNullDesC); |
|
2547 |
|
2548 if (aMedia.IsSupported(KMPXMediaMusicAlbumArtFileName)) |
|
2549 { |
|
2550 art.Set(aMedia.ValueText(KMPXMediaMusicAlbumArtFileName).Left(KMCMaxTextLen)); |
|
2551 } |
|
2552 if (aCategory == EMPXAlbum) |
|
2553 { |
|
2554 if (aMedia.IsSupported(KMPXMediaMusicArtist)) |
|
2555 { |
|
2556 artistname.Set(aMedia.ValueText(KMPXMediaMusicArtist).Left(KMCMaxTextLen)); |
|
2557 } |
|
2558 } |
|
2559 iObserver.AddCategoryItemL(aCategory, name, artistname, art, aDriveId, aItemChangedMessages, itemAdded); |
|
2560 } |
|
2561 else |
2491 { |
2562 { |
2492 // ignore the return value |
2563 // ignore the return value |
2493 iObserver.AddCategoryItemL(aCategory, name, aDriveId, |
2564 iObserver.AddCategoryItemL(aCategory, name, aDriveId, |
2494 aItemChangedMessages, itemAdded); |
2565 aItemChangedMessages, itemAdded); |
2495 } |
2566 } |
2521 iObserver.AddCategoryItemL(aCategory, abstractAlbumName, aDriveId, |
2592 iObserver.AddCategoryItemL(aCategory, abstractAlbumName, aDriveId, |
2522 aItemChangedMessages, itemAdded, KNullDesC, albumartist); |
2593 aItemChangedMessages, itemAdded, KNullDesC, albumartist); |
2523 } |
2594 } |
2524 else |
2595 else |
2525 #endif // ABSTRACTAUDIOALBUM_INCLUDED |
2596 #endif // ABSTRACTAUDIOALBUM_INCLUDED |
2526 { |
2597 if (aCategory == EMPXArtist || aCategory == EMPXAlbum) |
2527 // ignore the return value |
2598 { |
|
2599 TPtrC art(KNullDesC); |
|
2600 TPtrC artistname(KNullDesC); |
|
2601 if (aMedia.IsSupported(KMPXMediaMusicAlbumArtFileName)) |
|
2602 { |
|
2603 art.Set(aMedia.ValueText(KMPXMediaMusicAlbumArtFileName).Left(KMCMaxTextLen)); |
|
2604 } |
|
2605 if (aCategory == EMPXAlbum) |
|
2606 { |
|
2607 if (aMedia.IsSupported(KMPXMediaMusicArtist)) |
|
2608 { |
|
2609 artistname.Set(aMedia.ValueText(KMPXMediaMusicArtist).Left(KMCMaxTextLen)); |
|
2610 } |
|
2611 } |
|
2612 iObserver.AddCategoryItemL(aCategory, KNullDesC, artistname, art, aDriveId, |
|
2613 aItemChangedMessages, itemAdded); |
|
2614 } |
|
2615 else |
|
2616 { |
|
2617 // ignore the return value |
2528 iObserver.AddCategoryItemL(aCategory, KNullDesC, aDriveId, |
2618 iObserver.AddCategoryItemL(aCategory, KNullDesC, aDriveId, |
2529 aItemChangedMessages, itemAdded); |
2619 aItemChangedMessages, itemAdded); |
2530 } |
2620 } |
2531 updated = ETrue; |
2621 updated = ETrue; |
2532 } |
2622 } |
2593 } |
2683 } |
2594 |
2684 |
2595 return updated; |
2685 return updated; |
2596 } |
2686 } |
2597 |
2687 |
2598 TBool CMPXDbMusic::UpdateCategoryFieldL( |
2688 |
2599 TMPXGeneralCategory aCategory, |
|
2600 const CMPXMedia& aMedia, |
|
2601 const TMPXAttribute& aAttribute, |
|
2602 TUint32 aOldId, |
|
2603 TInt aDriveId, |
|
2604 CMPXMessageArray* aItemChangedMessages, |
|
2605 TUint32& aItemId, |
|
2606 TUint32 aArtistId) |
|
2607 { |
|
2608 TBool updated(EFalse); |
|
2609 TBool itemNotRemoved( EFalse ); |
|
2610 TBool itemAdded( EFalse ); |
|
2611 |
|
2612 // update category table and add category Id to the music table |
|
2613 if (!aOldId || aMedia.IsSupported(aAttribute)) |
|
2614 { |
|
2615 TInt changeMsgCount( 0 ); |
|
2616 if( aItemChangedMessages ) |
|
2617 { |
|
2618 changeMsgCount = aItemChangedMessages->Count(); |
|
2619 } |
|
2620 |
|
2621 if (aMedia.IsSupported(aAttribute)) |
|
2622 { |
|
2623 TPtrC name(aMedia.ValueText(aAttribute).Left(KMCMaxTextLen)); |
|
2624 |
|
2625 // construct the new ID for the category record |
|
2626 // only genre is not case sensitive |
|
2627 aItemId = MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), aCategory, |
|
2628 name, (aCategory != EMPXGenre)); |
|
2629 if (!aOldId || (aOldId != aItemId)) |
|
2630 { |
|
2631 // only add if the ID changed, |
|
2632 // otherwise the song was updated but the artist name was not |
|
2633 TPtrC art(KNullDesC); |
|
2634 if (aMedia.IsSupported(KMPXMediaMusicAlbumArtFileName)) |
|
2635 { |
|
2636 art.Set(aMedia.ValueText(KMPXMediaMusicAlbumArtFileName).Left(KMCMaxTextLen)); |
|
2637 } |
|
2638 |
|
2639 iObserver.AddCategoryItemL(aCategory, name, aArtistId, art, aDriveId, aItemChangedMessages, itemAdded); |
|
2640 updated = ETrue; |
|
2641 } |
|
2642 } |
|
2643 else |
|
2644 { |
|
2645 // only genre is not case sensitive |
|
2646 aItemId = MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), aCategory, KNullDesC, |
|
2647 (aCategory != EMPXGenre)); |
|
2648 if (!aOldId || (aOldId != aItemId)) |
|
2649 { |
|
2650 TPtrC art(KNullDesC); |
|
2651 if (aMedia.IsSupported(KMPXMediaMusicAlbumArtFileName)) |
|
2652 { |
|
2653 art.Set(aMedia.ValueText(KMPXMediaMusicAlbumArtFileName).Left(KMCMaxTextLen)); |
|
2654 } |
|
2655 |
|
2656 iObserver.AddCategoryItemL(aCategory, KNullDesC, aArtistId, art, aDriveId, |
|
2657 aItemChangedMessages, itemAdded); |
|
2658 updated = ETrue; |
|
2659 } |
|
2660 } |
|
2661 |
|
2662 if (aOldId && (aOldId != aItemId)) |
|
2663 { |
|
2664 iObserver.DeleteSongForCategoryL(aCategory, aOldId, aDriveId, |
|
2665 aItemChangedMessages, itemNotRemoved); |
|
2666 updated = ETrue; |
|
2667 } |
|
2668 |
|
2669 // Special case where the item(s) has been renamed. |
|
2670 // In this case, a new category is created +1 change msg |
|
2671 // a old category is removed +1 change msg |
|
2672 // We merge these 2 change messages into one using the deprecated ID |
|
2673 // |
|
2674 if( aItemChangedMessages ) |
|
2675 { |
|
2676 TInt newChangeMsgCount( aItemChangedMessages->Count() ); |
|
2677 if( newChangeMsgCount - changeMsgCount > 0 ) |
|
2678 { |
|
2679 TInt oldId = KErrNotFound; |
|
2680 TInt newId = KErrNotFound; |
|
2681 for( TInt i=0; i<newChangeMsgCount; ++i ) |
|
2682 { |
|
2683 CMPXMessage& msg = *(*aItemChangedMessages)[i]; |
|
2684 |
|
2685 TMPXItemId id = msg.ValueTObjectL<TMPXItemId>(KMPXMessageMediaGeneralId); |
|
2686 TMPXChangeEventType changeType = msg.ValueTObjectL<TMPXChangeEventType>(KMPXMessageChangeEventType); |
|
2687 |
|
2688 // Look for the added and deleted category IDs |
|
2689 // |
|
2690 if( id == aOldId && changeType == EMPXItemDeleted ) |
|
2691 { |
|
2692 oldId = i; |
|
2693 } |
|
2694 else if( id == aItemId && changeType == EMPXItemInserted ) |
|
2695 { |
|
2696 newId = i; |
|
2697 } |
|
2698 } |
|
2699 |
|
2700 if( oldId != KErrNotFound && |
|
2701 newId != KErrNotFound ) |
|
2702 { |
|
2703 aItemChangedMessages->Remove(oldId); // category removed |
|
2704 aItemChangedMessages->Remove(newId); // category added |
|
2705 MPXDbCommonUtil::AddItemChangedMessageL(*aItemChangedMessages, aItemId, EMPXItemModified, |
|
2706 aCategory, KDBPluginUid, aOldId ); |
|
2707 } |
|
2708 else if ( oldId !=KErrNotFound && itemAdded ) // old item removed, new item already exist |
|
2709 { |
|
2710 MPXDbCommonUtil::AddItemChangedMessageL(*aItemChangedMessages, aItemId, EMPXItemModified, |
|
2711 aCategory, KDBPluginUid, aOldId ); |
|
2712 } |
|
2713 else if ( newId !=KErrNotFound && itemNotRemoved ) // new item added, old item still exist |
|
2714 { |
|
2715 MPXDbCommonUtil::AddItemChangedMessageL(*aItemChangedMessages, aOldId, EMPXItemModified, |
|
2716 aCategory, KDBPluginUid, aItemId ); |
|
2717 } |
|
2718 } |
|
2719 } |
|
2720 } |
|
2721 |
|
2722 return updated; |
|
2723 } |
|
2724 // ---------------------------------------------------------------------------- |
2689 // ---------------------------------------------------------------------------- |
2725 // CMPXDbMusic::ExtraFieldsRequired |
2690 // CMPXDbMusic::ExtraFieldsRequired |
2726 // ---------------------------------------------------------------------------- |
2691 // ---------------------------------------------------------------------------- |
2727 // |
2692 // |
2728 TBool CMPXDbMusic::ExtraFieldsRequired( |
2693 TBool CMPXDbMusic::ExtraFieldsRequired( |