// ----------------------------------------------------------------------------
// Append an item into the media array
// ----------------------------------------------------------------------------
//
void MPXDbUtil::AppendMediaL(
CMPXMediaArray& aArray,
const TDesC& aTitle,
TMPXGeneralType aType,
TMPXGeneralCategory aCat,
TMPXPodcastType aPodcastType,
TMPXPodcastCategory aPodcastCat,
TMPXItemId aId,
TInt aNonPermissibleActions)
{
MPX_FUNC("MPXDbUtil::AppendMediaL");
RArray<TInt> supportedIds;
CleanupClosePushL (supportedIds);
supportedIds.AppendL (KMPXMediaIdGeneral);
supportedIds.AppendL (KMPXMediaIdPodcast);
CMPXMedia* entry = CMPXMedia::NewL(supportedIds.Array());
CleanupStack::PushL (entry);
entry->SetTextValueL (KMPXMediaGeneralTitle, aTitle);
entry->SetTObjectValueL(KMPXMediaPodcastType, aPodcastType);
entry->SetTObjectValueL(KMPXMediaPodcastCategoryGroup, aPodcastCat);
entry->SetTObjectValueL(KMPXMediaGeneralId, aId);
entry->SetTObjectValueL(KMPXMediaGeneralType, aType);
entry->SetTObjectValueL(KMPXMediaGeneralCategory, aCat);
// temp fix: Beryl BEGIN
if ( aNonPermissibleActions != 0 )
{
// set non-permissible actions
entry->SetTObjectValueL(KMPXMediaGeneralNonPermissibleActions,
static_cast<TMPXGeneralNonPermissibleActions>(aNonPermissibleActions));
}
// temp fix: Beryl END
aArray.AppendL (entry);
CleanupStack::Pop (entry);
CleanupStack::PopAndDestroy (&supportedIds);
}
// ---------------------------------------------------------------------------
// Retrieve a media object based on file path
// ---------------------------------------------------------------------------
//
CMPXMedia* CMPXCollectionHelperImp::GetL( const TDesC& aFile,
const TArray<TMPXAttribute>& aAttrs,
TMPXGeneralCategory aItemCat )
{
MPX_FUNC("CMPXCollectionHelperImp::GetL");
MPX_DEBUG2("aFile %S", &aFile);
#ifdef ABSTRACTAUDIOALBUM_INCLUDED
if (aItemCat != EMPXSong && aItemCat != EMPXPlaylist && aItemCat != EMPXAbstractAlbum)
#else
if (aItemCat != EMPXSong && aItemCat != EMPXPlaylist)
#endif
{
User::Leave(KErrArgument);
}
// Playlists synced through MTP contains .pla extension and there
// is no pla playlist plugin. We can no longer reply on harvester
// utility's IsPlaylistL to determine if this is a playlist.
// For now, the default collection to get this playlist is
// EMPXCollectionPluginMusic for playlists. This will be revised
// later when there is a generic way of resolving collections aside
// from using file extension or UID. Same for virtual playlists.
//
// Find the collection Id from harvester for songs or playlists
// scanned from the file system
TInt col(iMusicCollectionId.iUid);
if (aItemCat == EMPXSong || iHvsUtility->IsPlaylistL(aFile))
{
col = iHvsUtility->FindCollectionIdL( aFile );
}
// Search criteria
//
CMPXMedia* search = CMPXMedia::NewL();
CleanupStack::PushL( search );
search->SetTObjectValueL( KMPXMediaGeneralType, EMPXItem );
search->SetTObjectValueL( KMPXMediaGeneralCategory, aItemCat );
search->SetTObjectValueL<TUid>( KMPXMediaGeneralCollectionId, TUid::Uid(col) );
search->SetTextValueL( KMPXMediaGeneralUri, aFile );
// Search in synch mode
//
CMPXMedia* result = iCollectionUtil->Collection().FindAllL( *search, aAttrs );
CleanupStack::PopAndDestroy( search );
CleanupStack::PushL(result);
const CMPXMediaArray* ary(NULL);
if( result->IsSupported( KMPXMediaArrayContents ) )
{
ary = result->Value<CMPXMediaArray>(KMPXMediaArrayContents);
if( !ary )
{
User::Leave(KErrNoMemory);
}
}
CMPXMedia* foundMedia(NULL);
if ( ary && ary->Count() )
{
foundMedia = CMPXMedia::NewL(*ary->AtL(0));
CleanupStack::PushL(foundMedia);
foundMedia->SetTObjectValueL<TUid>( KMPXMediaGeneralCollectionId, TUid::Uid(col) );
CleanupStack::Pop(foundMedia);
}
else
{
User::Leave(KErrNotFound);
}
CleanupStack::PopAndDestroy(result);
return foundMedia;
}
// ---------------------------------------------------------------------------
// Remove a file from the collection
// ---------------------------------------------------------------------------
//
void CMPXCollectionHelperImp::RemoveL( const TDesC& aFile,
TMPXGeneralCategory aItemCat )
{
MPX_FUNC("CMPXCollectionHelperImp::RemoveL");
MPX_DEBUG3("aFile %S, category %d", &aFile, aItemCat);
if (aItemCat != EMPXSong && aItemCat != EMPXPlaylist)
{
User::Leave(KErrArgument);
}
//
// ask harvester to remove the file if any of the following is true:
// 1) removing a song
// 2) removing a playlist scanned through file system.
//
// There are 3 types of playlists. The ones created from the device
// are virtual playlists which have file extension .vir. There are
// no physical playlist files associated with them; hence not
// registered with harvester. For virtual playlists, IsPlaylistL
// will return EFalse because there is not a playlist plugin that
// deals with .vir playlist files.
//
// The ones synced from PC through MTP have file extension .pla.
// There are 0-byte .pla files associated with them but they
// are not registered with harvester either. IsPlaylistL will also
// return EFalse because there is not a playlist plugin that deals
// with .pla.
//
// The 3rd type of playlists is .m3u on the file system. They are
// added to the collection through file scan and registered with
// harvester. IsPlaylistL will return ETrue.
//
// For now virtual playlists and synced playlists are assumed to
// be in the music collection for now until there is a generic way
// resolving collections aside from using file extension or UID.
//
TInt collection(iMusicCollectionId.iUid);
if (aItemCat == EMPXSong || iHvsUtility->IsPlaylistL(aFile))
{
// Remove from the harvester
collection = iHvsUtility->RemoveFileL( aFile );
}
// Remove from the collection
// Construct a CMPXMedia object with URI, collection id, type and category
//
RArray<TInt> contID;
CleanupClosePushL( contID );
contID.AppendL( KMPXMediaIdGeneral );
CMPXMedia* media = CMPXMedia::NewL( contID.Array() );
CleanupStack::PushL( media );
media->SetTextValueL( KMPXMediaGeneralUri, aFile );
media->SetTObjectValueL<TUid>( KMPXMediaGeneralCollectionId, TUid::Uid( collection ) );
media->SetTObjectValueL( KMPXMediaGeneralType, EMPXItem );
media->SetTObjectValueL( KMPXMediaGeneralCategory, aItemCat );
// Remove the item via CMPXCommand
//
CMPXCommand* cmd = CMPXCommand::NewL();
CleanupStack::PushL( cmd );
cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId,
collection );
cmd->SetTObjectValueL( KMPXCommandGeneralId,
KMPXCommandIdCollectionRemoveMedia );
cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue );
cmd->SetCObjectValueL( KMPXCommandCollectionRemoveMedia, media );
cmd->SetTObjectValueL( KMPXCommandCollectionRemoveMediaDeleteRecord,
ETrue );
iCollectionUtil->Collection().CommandL( *cmd );
CleanupStack::PopAndDestroy( cmd );
CleanupStack::PopAndDestroy( media );
CleanupStack::PopAndDestroy( &contID );
}
// ----------------------------------------------------------------------------------------------------------
// Navigates to the given path
// ----------------------------------------------------------------------------------------------------------
//
void CTestCollectionPlugin::OpenL(const CMPXCollectionPath& aPath,
const TArray<TMPXAttribute>& aAttrs,
CMPXFilter* aFilter)
{
LOG1(_L("CTestCollectionPlugin::OpenL"));
LogPath( aPath );
TMPXOpenMode openMode = aPath.OpenNextMode();
TInt idIndex = aPath.Levels() - 1;
LOG2(_L("TMPXOpendMode=%d"), openMode);
LOG2(_L("aFilter=%x"), aFilter);
RArray<TInt> supportedIds;
CleanupClosePushL(supportedIds);
supportedIds.AppendL(KMPXMediaIdContainer);
supportedIds.AppendL(KMPXMediaIdGeneral);
CMPXMedia* entries = CMPXMedia::NewL(supportedIds.Array());
CleanupStack::PopAndDestroy(&supportedIds);
CleanupStack::PushL(entries);
entries->SetTObjectValueL<TMPXItemId>(TMPXAttribute(KMPXMediaIdGeneral,EMPXMediaGeneralId), aPath.Id(idIndex));
if(aPath.Levels() == 1)
{
// Plugin's root level
RArray<TInt> ids;
CleanupClosePushL( ids );
ids.Append( 11 );
ids.Append( 12 );
ids.Append( 13 );
ids.Append( 990 ); // for Playback Framework Test
RArray<TMPXAttribute> attrs;
CleanupClosePushL( attrs );
attrs.Append( KMPXMediaGeneralId );
attrs.Append( KMPXMediaGeneralUri );
attrs.Append( KMPXMediaGeneralTitle );
CMPXMediaArray* array=CMPXMediaArray::NewL();
CleanupStack::PushL( array );
const TArray<TMPXAttribute>& tempRef = aAttrs.Count() == 0? attrs.Array() : aAttrs;
AddMediaL(*array, ids, tempRef);
FilterMediaArray(*array, aFilter);
entries->SetCObjectValueL (TMPXAttribute(KMPXMediaIdContainer,EMPXMediaArrayContents),array);
entries->SetTObjectValueL (TMPXAttribute(KMPXMediaIdContainer,EMPXMediaArrayCount),array->Count());
iObs->HandleOpen (entries, KErrNone);
CleanupStack::PopAndDestroy(3, &ids); // attrs, array, ids
}
else if(aPath.Levels() == 2)
{
// Opening plugin's root menu
TInt topLevId = aPath.Id(1);
RArray<TInt> ids;
CleanupClosePushL( ids );
RArray<TMPXAttribute> attrs;
CleanupClosePushL( attrs );
CMPXMediaArray* array=CMPXMediaArray::NewL();
CleanupStack::PushL( array );
attrs.Append( KMPXMediaGeneralId );
attrs.Append( KMPXMediaGeneralUri );
attrs.Append( KMPXMediaGeneralTitle );
if(topLevId == 11)
{
ids.Append( 211 );
ids.Append( 212 );
ids.Append( 213 );
}
else if(topLevId == 12)
{
ids.Append( 221 );
}
else if(topLevId == 13)
{
ids.Append( 231 );
ids.Append( 232 );
}
else if(topLevId == 990)
{
ids.Append( 9901 );
ids.Append( 9902 );
ids.Append( 9903 );
ids.Append( 9904 );
ids.Append( 9905 );
ids.Append( 9906 );
ids.Append( 9907 );
}
const TArray<TMPXAttribute>& tempRef = aAttrs.Count() == 0? attrs.Array() : aAttrs;
AddMediaL(*array, ids, tempRef);
FilterMediaArray(*array, aFilter);
entries->SetCObjectValueL (TMPXAttribute(KMPXMediaIdContainer,EMPXMediaArrayContents),array);
entries->SetTObjectValueL (TMPXAttribute(KMPXMediaIdContainer,EMPXMediaArrayCount),array->Count());
iObs->HandleOpen (entries, KErrNone);
CleanupStack::PopAndDestroy(3, &ids); // attrs, array, ids
}
else if(aPath.Levels() == 3)
{
// Opening plugin's 2nd
TInt secLevId = aPath.Id(2);
RArray<TInt> ids;
CleanupClosePushL( ids );
RArray<TMPXAttribute> attrs;
CleanupClosePushL( attrs );
CMPXMediaArray* array=CMPXMediaArray::NewL();
CleanupStack::PushL( array );
attrs.Append( KMPXMediaGeneralId );
attrs.Append( KMPXMediaGeneralUri );
attrs.Append( KMPXMediaGeneralTitle );
switch( secLevId )
{
case 211:
ids.Append( 3111 );
break;
case 212:
ids.Append( 3121 );
break;
case 213:
ids.Append( 3131 );
break;
case 221:
// Empty
break;
case 231:
ids.Append( 3311 );
break;
case 232:
ids.Append( 3321 );
break;
};
const TArray<TMPXAttribute>& tempRef = aAttrs.Count() == 0? attrs.Array() : aAttrs;
AddMediaL(*array, ids, tempRef);
FilterMediaArray(*array, aFilter);
entries->SetCObjectValueL (TMPXAttribute(KMPXMediaIdContainer,EMPXMediaArrayContents),array);
entries->SetTObjectValueL (TMPXAttribute(KMPXMediaIdContainer,EMPXMediaArrayCount),array->Count());
iObs->HandleOpen (entries, KErrNone);
CleanupStack::PopAndDestroy(3, &ids); // attrs, array, ids
}
else
{
User::Leave( KErrNotFound );
}
CleanupStack::PopAndDestroy( entries );
}
void T_CGlxCache::T_CGlxCache_MediaUpdatedLL( )
{
// Create helper class
T_CacheTestHelpers cacheTestHelper(iCGlxCache);
// New media
CMPXMedia* newMedia3 = CMPXMedia::NewL();
CleanupStack::PushL(newMedia3);
newMedia3->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, TMPXItemId(KMediaId3));
EUNIT_PRINT(_L("Add new media"));
iCGlxCache->MediaUpdatedL(*newMedia3);
EUNIT_PRINT(_L("Check new media added"));
EUNIT_ASSERT_DESC(cacheTestHelper.ItemPool().Count() == 3, "Cache doesn't contain three items");
TInt cachedNewMedia3Index = cacheTestHelper.ItemPool().FindInOrder(TGlxMediaId(KMediaId3), T_CacheTestHelpers::MediaItemOrderByKey);
EUNIT_ASSERT_DESC(cachedNewMedia3Index != KErrNotFound, "New media not added to cache");
CleanupStack::PopAndDestroy(newMedia3);
// Multiple new media
CMPXMedia* newMultipleMedia = CMPXMedia::NewL();
CleanupStack::PushL(newMultipleMedia);
CMPXMediaArray* newMediaArray = CMPXMediaArray::NewL();
CleanupStack::PushL(newMediaArray);
CMPXMedia* newMedia4 = CMPXMedia::NewL();
CleanupStack::PushL(newMedia4);
newMedia4->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, TMPXItemId(KMediaId4));
newMediaArray->AppendL(newMedia4);
CleanupStack::Pop(newMedia4);
CMPXMedia* newMedia5 = CMPXMedia::NewL();
CleanupStack::PushL(newMedia5);
newMedia5->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, TMPXItemId(KMediaId5));
newMediaArray->AppendL(newMedia5);
CleanupStack::Pop(newMedia5);
newMultipleMedia->SetCObjectValueL(KMPXMediaArrayContents, newMediaArray);
newMultipleMedia->SetTObjectValueL(KMPXMediaArrayCount, newMediaArray->Count());
EUNIT_PRINT(_L("Add multiple new media"));
iCGlxCache->MediaUpdatedL(*newMultipleMedia);
CleanupStack::PopAndDestroy(newMediaArray);
CleanupStack::PopAndDestroy(newMultipleMedia);
EUNIT_PRINT(_L("Check multiple new media added"));
EUNIT_ASSERT_DESC(cacheTestHelper.ItemPool().Count() == 5, "Cache doesn't contain five items");
TInt cachedNewMedia4Index = cacheTestHelper.ItemPool().FindInOrder(TGlxMediaId(KMediaId4), T_CacheTestHelpers::MediaItemOrderByKey);
TInt cachedNewMedia5Index = cacheTestHelper.ItemPool().FindInOrder(TGlxMediaId(KMediaId5), T_CacheTestHelpers::MediaItemOrderByKey);
EUNIT_ASSERT_DESC((cachedNewMedia4Index != KErrNotFound) && (cachedNewMedia5Index != KErrNotFound), "Multiple new media not added to cache");
}
