/*
* Copyright (c) 2006 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: provides playlist handling services for UPnP framework
*
*/
// INCLUDES
// System
#include <escapeutils.h> // for unicode conversion
// upnp stack api
#include <upnpitem.h> // s60 upnp stack
#include <upnpelement.h> // s60 upnp stack
// MPX framework api
#include <mpxcollectionutility.h>
#include <mpxcollectionframeworkdefs.h> // main attribute keys
#include <mpxmediageneraldefs.h> // commonly used attribute keys
#include <mpxmediacontainerdefs.h> // container-specific attribute keys
#include <mpxmediamusicdefs.h> // music-specific attribute keys
#include <mpxcollectionplugin.hrh> // collection plugin types
#include <mpxmedia.h>
#include <mpxmediaarray.h>
// upnpframework / avcontroller helper api
#include "upnpitemutility.h" // for FindElementByName & ResourceFromItemL
#include "upnpconstantdefs.h" // for element names
// upnpframework / internal api's
#include "upnpcdsreselementutility.h" // for UriFromItemL
// music adapter internal
#include "upnpmpxhelper.h" // for some mpx operations
#include "upnpplaylistservices.h" // ourselves
// upnpframework / settings engine api
#include "upnpsettingsengine.h" // CUPnPSettingsEngine
// debug
_LIT16( KComponentLogfile, "musicadapter.txt" );
#include "upnplog.h"
// constant definitions
const TUid KHomeConnectUid = { 0x10208A0A };
const TUid KMpxLocalCollectionUid = { 0x101FFC3A };
// ======== MEMBER FUNCTIONS ========
// --------------------------------------------------------------------------
// CUPnPPlaylistServices::NewL
// 1st phase constructor.
// --------------------------------------------------------------------------
//
EXPORT_C CUPnPPlaylistServices* CUPnPPlaylistServices::NewL()
{
__LOG( "CUPnPPlaylistServices::NewL" );
CUPnPPlaylistServices* self = new(ELeave) CUPnPPlaylistServices();
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
// --------------------------------------------------------------------------
// CUPnPPlaylistServices::CUPnPPlaylistServices
// Default constructor.
// --------------------------------------------------------------------------
//
CUPnPPlaylistServices::CUPnPPlaylistServices()
{
}
// --------------------------------------------------------------------------
// CUPnPPlaylistServices::CUPnPPlaylistServices
// 2nd phase constructor
// --------------------------------------------------------------------------
//
void CUPnPPlaylistServices::ConstructL()
{
__LOG( "CUPnPPlaylistServices::ConstructL" );
iStatus = KErrNone;
iCollectionUtility = MMPXCollectionUtility::NewL(
(MMPXCollectionObserver*)0, KMcModePlaylist );
// Initialize/Merge music collection databases
RArray<TUid> uid;
CleanupClosePushL( uid );
uid.AppendL( TUid::Uid( EMPXCollectionPluginMusic ) );
TUid collection = iCollectionUtility->CollectionIDL( uid.Array() );
TRAP( iStatus, iCollectionUtility->Collection().CommandL(
EMcCmdCollectionInit, collection.iUid ) );
CleanupStack::PopAndDestroy( &uid );
iMpxHelper = CUPnPMpxHelper::NewL( KHomeConnectUid );
__LOG1( "CUPnPPlaylistServices::ConstructL end iStatus %d",
iStatus );
}
// --------------------------------------------------------------------------
// CUPnPPlaylistServices::~CUPnPPlaylistServices
// Destructor.
// --------------------------------------------------------------------------
//
EXPORT_C CUPnPPlaylistServices::~CUPnPPlaylistServices()
{
__LOG( "CUPnPPlaylistServices ~()" );
if ( iCollectionUtility )
{
iCollectionUtility->Close();
iCollectionUtility = 0;
}
delete iMpxHelper;
}
// --------------------------------------------------------------------------
// CUPnPPlaylistServices::ListPlaylistsL
// --------------------------------------------------------------------------
//
EXPORT_C void CUPnPPlaylistServices::ListPlaylistsL(
CDesCArray& aPlaylistIds,
CDesCArray& aPlaylistNames )
{
__LOG( "ListPlaylistsL()" );
if( iStatus != KErrNone)
{
__LOG1( "CUPnPPlaylistServices::ListPlaylistsL iStatus %d return",
iStatus );
return;
}
CMPXMedia* result = FindItemL( EPlaylists,
KNullDesC, &KMPXMediaGeneralId, &KMPXMediaGeneralTitle );
if ( result != 0 )
{
CleanupStack::PushL( result );
__LOG("getting media array");
const CMPXMediaArray* medias = result->Value<CMPXMediaArray>(
KMPXMediaArrayContents );
TInt count = medias->Count();
for( TInt i = 0; i < count; ++i )
{
const CMPXMedia* entry = (*medias)[i];
TMPXItemId id = *entry->Value<TMPXItemId>(
KMPXMediaGeneralId );
const TDesC& title = entry->ValueText(
KMPXMediaGeneralTitle );
__LOG3( "media array %d/%d [%S]",
i, count, &title );
aPlaylistIds.AppendL( Id2Desc( id ) );
aPlaylistNames.AppendL( title );
}
CleanupStack::PopAndDestroy( result );
}
}
// --------------------------------------------------------------------------
// CUPnPPlaylistServices::OpenPlaylistL
// --------------------------------------------------------------------------
//
EXPORT_C void CUPnPPlaylistServices::OpenPlaylistL(
const TDesC& aPlaylistId,
CDesCArray& aContentMedia )
{
__LOG1( "OpenPlaylistL(%S)", &aPlaylistId );
if( iStatus != KErrNone)
{
__LOG1( "CUPnPPlaylistServices::OpenPlaylistL iStatus %d return",
iStatus );
return;
}
CMPXMedia* result = FindItemL( EPlaylistById, aPlaylistId,
&KMPXMediaArrayContents, &KMPXMediaGeneralUri );
if ( result != 0 )
{
CleanupStack::PushL( result );
const CMPXMediaArray* resultMedias =
result->Value<CMPXMediaArray>( KMPXMediaArrayContents );
if ( resultMedias->Count() == 1 )
{
// fetch content
CMPXMedia* playlist = FetchPlaylistContentL( aPlaylistId );
if( playlist != 0 )
{
CleanupStack::PushL( playlist );
const CMPXMediaArray* playlistMedias =
playlist->Value<CMPXMediaArray>( KMPXMediaArrayContents );
if ( playlistMedias )
{
TInt count = playlistMedias->Count();
for( TInt i = 0; i < count; ++i )
{
__LOG2( "accessing mediaList: item %d of %d",
i, count );
const CMPXMedia* entry = (*playlistMedias)[i];
aContentMedia.AppendL( entry->ValueText(
KMPXMediaGeneralUri ) );
}
}
CleanupStack::PopAndDestroy( playlist );
}
}
else
{
__LOG1("Unknown result medias count: %d",
resultMedias->Count() );
}
CleanupStack::PopAndDestroy( result );
}
else
{
User::Leave( KErrNotFound );
}
// now ready to return
}
// --------------------------------------------------------------------------
// CUPnPPlaylistServices::CreateTrackL
// --------------------------------------------------------------------------
//
EXPORT_C void CUPnPPlaylistServices::CreateTrackL(
const TDesC& aTrackPath,
const CUpnpItem& aTrackMetadata )
{
__LOG1( "CreateTrackL(%S)", &aTrackPath );
if( iStatus != KErrNone)
{
__LOG1( "CUPnPPlaylistServices::CreateTrackL iStatus %d return",
iStatus );
return;
}
CMPXMedia* item = CMPXMedia::NewL();
CleanupStack::PushL( item );
item->SetTObjectValueL<TUid>(
KMPXMediaGeneralCollectionId, KMpxLocalCollectionUid );
item->SetTObjectValueL<TMPXGeneralType>(
KMPXMediaGeneralType, EMPXItem );
item->SetTObjectValueL<TMPXGeneralCategory>(
KMPXMediaGeneralCategory, EMPXSong );
item->SetTextValueL(
KMPXMediaGeneralUri, aTrackPath );
// Insert metadata
HBufC16* buf = NULL;
// title
buf = EscapeUtils::ConvertToUnicodeFromUtf8L( aTrackMetadata.Title() );
CleanupStack::PushL( buf );
item->SetTextValueL(
KMPXMediaGeneralTitle, *buf );
CleanupStack::PopAndDestroy( buf );
// artist
if ( ( buf = GetElementLC( aTrackMetadata, KElementArtist ) ) != 0 )
{
item->SetTextValueL(
KMPXMediaMusicArtist, *buf );
CleanupStack::PopAndDestroy( buf );
}
else if ( ( buf = GetElementLC( aTrackMetadata, KElementCreator ) ) != 0 )
{
item->SetTextValueL(
KMPXMediaMusicArtist, *buf );
CleanupStack::PopAndDestroy( buf );
}
// album
if ( ( buf = GetElementLC( aTrackMetadata, KElementAlbum ) ) != 0 )
{
item->SetTextValueL(
KMPXMediaMusicAlbum, *buf );
CleanupStack::PopAndDestroy( buf );
}
// genre
if ( ( buf = GetElementLC( aTrackMetadata, KElementGenre ) ) != 0 )
{
item->SetTextValueL(
KMPXMediaMusicGenre, *buf );
CleanupStack::PopAndDestroy( buf );
}
// date and year
const CUpnpElement* elem = UPnPItemUtility::FindElementByName(
aTrackMetadata, KElementDate );
if ( elem != 0 )
{
TTime timestamp;
TInt err =
UPnPItemUtility::UPnPDateAsTTime( elem->Value(), timestamp );
if( err == KErrNone )
{
item->SetTObjectValueL<TInt64>(
KMPXMediaGeneralDate, timestamp.Int64() );
item->SetTObjectValueL<TInt64>(
KMPXMediaMusicYear, timestamp.Int64() );
}
}
// duration
const CUpnpElement* trackResource =
&UPnPItemUtility::ResourceFromItemL( aTrackMetadata );
if( trackResource != 0 )
{
const CUpnpAttribute* attr = UPnPItemUtility
::FindAttributeByName( *trackResource, KAttributeDuration );
if ( attr != 0 )
{
TInt ms = 0;
UPnPItemUtility
::UPnPDurationAsMilliseconds( attr->Value(), ms );
item->SetTObjectValueL<TInt>(
KMPXMediaGeneralDuration, ms );
}
}
// track number
if ( ( buf = GetElementLC( aTrackMetadata, KElementTrackNumber ) ) != 0 )
{
item->SetTextValueL(
KMPXMediaMusicAlbumTrack, *buf );
CleanupStack::PopAndDestroy( buf );
}
__LOG("...about to add track...");
iMpxHelper->AddTrackL( item );
CleanupStack::PopAndDestroy( item );
}
// --------------------------------------------------------------------------
// CUPnPPlaylistServices::GetElement
// --------------------------------------------------------------------------
//
HBufC16* CUPnPPlaylistServices::GetElementLC(
const CUpnpItem& aSource, const TDesC8& aSourceField ) const
{
HBufC16* result = 0;
const CUpnpElement* elem = UPnPItemUtility::FindElementByName(
aSource, aSourceField );
if ( elem != 0 )
{
result = EscapeUtils::ConvertToUnicodeFromUtf8L( elem->Value() );
CleanupStack::PushL( result );
}
return result;
}
// --------------------------------------------------------------------------
// CUPnPPlaylistServices::CreatePlaylistL
// --------------------------------------------------------------------------
//
EXPORT_C void CUPnPPlaylistServices::CreatePlaylistL(
const TDesC& aPlaylistName,
const MDesCArray& aTrackPaths,
TDes* aPlaylistId )
{
__LOG1( "CreatePlaylistL(%S)", &aPlaylistName );
if( iStatus != KErrNone)
{
__LOG1( "CUPnPPlaylistServices::CreatePlaylistL iStatus %d return",
iStatus );
return;
}
// create a media list
CMPXMediaArray* medias = CMPXMediaArray::NewL();
CleanupStack::PushL( medias );
// add track info into the media list
for( TInt i = 0; i < aTrackPaths.MdcaCount(); ++i )
{
TPtrC16 trackUri = aTrackPaths.MdcaPoint(i);
CMPXMedia* entry = CMPXMedia::NewL();
CleanupStack::PushL( entry );
entry->SetTObjectValueL<TUid>(
KMPXMediaGeneralCollectionId, KMpxLocalCollectionUid );
entry->SetTObjectValueL<TMPXGeneralType>(
KMPXMediaGeneralType, EMPXItem );
entry->SetTObjectValueL<TMPXGeneralCategory>(
KMPXMediaGeneralCategory, EMPXSong );
entry->SetTextValueL(
KMPXMediaGeneralUri, trackUri );
medias->AppendL( entry );
CleanupStack::Pop( entry );
}
// create a media item for the playlist
CMPXMedia* playlist = CMPXMedia::NewL();
CleanupStack::PushL( playlist );
CUPnPSettingsEngine* engine = CUPnPSettingsEngine::NewL();;
CleanupStack::PushL( engine );
HBufC* location = HBufC::NewLC( KMaxFileName );
TPtr locationPtr( location->Des() );
TBool isPhoneMemory;
engine->GetCopyLocationL( locationPtr, isPhoneMemory );
// add playlist info into the playlist media
playlist->SetTObjectValueL<TUid>(
KMPXMediaGeneralCollectionId, KMpxLocalCollectionUid );
playlist->SetTObjectValueL<TMPXGeneralType>(
KMPXMediaGeneralType, EMPXItem );
playlist->SetTObjectValueL<TMPXGeneralCategory>(
KMPXMediaGeneralCategory, EMPXPlaylist );
playlist->SetTextValueL(
KMPXMediaGeneralTitle, aPlaylistName );
playlist->SetTextValueL(
KMPXMediaGeneralUri, locationPtr );
playlist->SetCObjectValueL(
KMPXMediaArrayContents, medias );
playlist->SetTObjectValueL<TInt>(
KMPXMediaArrayCount, medias->Count() );
// add in collection
__LOG("...about to add playlist...");
iMpxHelper->AddPlaylistL( playlist );
iCurrentId = *playlist->Value<TMPXItemId>(
KMPXMediaGeneralId );
CleanupStack::PopAndDestroy( location );
CleanupStack::PopAndDestroy( engine );
CleanupStack::PopAndDestroy( playlist );
CleanupStack::PopAndDestroy( medias );
// Find out playlist ID
if ( aPlaylistId )
{
__LOG("...about to retrieve playlist id...");
aPlaylistId->Copy( Id2Desc( iCurrentId ) );
}
}
// --------------------------------------------------------------------------
// CUPnPPlaylistServices::AddMediaToPlaylistL
// --------------------------------------------------------------------------
//
EXPORT_C void CUPnPPlaylistServices::AddMediaToPlaylistL(
const TDesC& aPlaylistId,
const TDesC& aTrackPath )
{
__LOG2( "AddMediaToPlaylistL(%S,%S)",
&aPlaylistId, &aTrackPath );
if( iStatus != KErrNone)
{
__LOG1( "CUPnPPlaylistServices::AddMediaToPlaylistL iStatus %d return",
iStatus );
return;
}
// create a media list
CMPXMediaArray* medias = CMPXMediaArray::NewL();
CleanupStack::PushL( medias );
// add new track to media list
CMPXMedia* entry = CMPXMedia::NewL();
CleanupStack::PushL( entry );
entry->SetTObjectValueL<TUid>(
KMPXMediaGeneralCollectionId, KMpxLocalCollectionUid );
entry->SetTObjectValueL<TMPXGeneralType>(
KMPXMediaGeneralType, EMPXItem );
entry->SetTObjectValueL<TMPXGeneralCategory>(
KMPXMediaGeneralCategory, EMPXSong );
entry->SetTextValueL(
KMPXMediaGeneralUri, aTrackPath );
medias->AppendL( entry );
CleanupStack::Pop( entry );
// create the playlist delta
CMPXMedia* playlistDelta = CMPXMedia::NewL();
CleanupStack::PushL( playlistDelta );
// add playlist info into the playlist delta media
playlistDelta->SetTObjectValueL<TUid>(
KMPXMediaGeneralCollectionId, KMpxLocalCollectionUid );
playlistDelta->SetTObjectValueL<TMPXGeneralType>(
KMPXMediaGeneralType, EMPXItem );
playlistDelta->SetTObjectValueL<TMPXGeneralCategory>(
KMPXMediaGeneralCategory, EMPXPlaylist );
playlistDelta->SetTObjectValueL<TMPXItemId>(
KMPXMediaGeneralId, Desc2Id( aPlaylistId ) );
playlistDelta->SetCObjectValueL(
KMPXMediaArrayContents, medias ); // new content
playlistDelta->SetTObjectValueL<TInt>(
KMPXMediaArrayCount, medias->Count() );
// add in collection
__LOG("Add playlist delta to collection");
iMpxHelper->AddPlaylistL( playlistDelta );
CleanupStack::PopAndDestroy( playlistDelta );
CleanupStack::PopAndDestroy( medias );
}
// --------------------------------------------------------------------------
// CUPnPPlaylistServices::DeleteTrackL
// --------------------------------------------------------------------------
//
EXPORT_C void CUPnPPlaylistServices::DeleteTrackL(
const TDesC& aContentFile )
{
__LOG1( "DeleteTrackL(%S)", &aContentFile );
if( iStatus != KErrNone)
{
__LOG1( "CUPnPPlaylistServices::DeleteTrackL iStatus %d return",
iStatus );
return;
}
// item to delete
CMPXMedia* item = CMPXMedia::NewL();
CleanupStack::PushL( item );
item->SetTObjectValueL<TUid>(
KMPXMediaGeneralCollectionId, KMpxLocalCollectionUid );
item->SetTObjectValueL<TMPXGeneralType>(
KMPXMediaGeneralType, EMPXItem );
item->SetTObjectValueL<TMPXGeneralCategory>(
KMPXMediaGeneralCategory, EMPXSong );
item->SetTextValueL(
KMPXMediaGeneralUri, aContentFile );
iCollectionUtility->Collection().RemoveL( *item );
CleanupStack::PopAndDestroy( item );
}
// --------------------------------------------------------------------------
// CUPnPPlaylistServices::DeletePlaylistL
// --------------------------------------------------------------------------
//
EXPORT_C void CUPnPPlaylistServices::DeletePlaylistL(
const TDesC& aPlaylistId )
{
__LOG1( "DeletePlaylistL(%S)", &aPlaylistId );
if( iStatus != KErrNone)
{
__LOG1( "CUPnPPlaylistServices::DeletePlaylistL iStatus %d return",
iStatus );
return;
}
// item to delete
CMPXMedia* playlist = CMPXMedia::NewL();
CleanupStack::PushL( playlist );
playlist->SetTObjectValueL<TUid>(
KMPXMediaGeneralCollectionId, KMpxLocalCollectionUid );
playlist->SetTObjectValueL<TMPXGeneralType>(
KMPXMediaGeneralType, EMPXItem );
playlist->SetTObjectValueL<TMPXGeneralCategory>(
KMPXMediaGeneralCategory, EMPXPlaylist );
playlist->SetTObjectValueL<TMPXItemId>(
KMPXMediaGeneralId, Desc2Id( aPlaylistId ) );
iCollectionUtility->Collection().RemoveL( *playlist );
CleanupStack::PopAndDestroy( playlist );
}
// --------------------------------------------------------------------------
// CUPnPPlaylistServices::IsValidTrackL
// --------------------------------------------------------------------------
//
EXPORT_C TBool CUPnPPlaylistServices::IsValidTrackL(
const TDesC& aContentFile )
{
__LOG1( "IsValidTrackL(%S)", &aContentFile );
if( iStatus != KErrNone)
{
__LOG1( "CUPnPPlaylistServices::IsValidTrackL iStatus %d return",
iStatus );
return EFalse;
}
TBool found = EFalse;
CMPXMedia* track = FindItemL( ESongByUri, aContentFile );
if ( track != 0 )
{
CleanupStack::PushL( track );
TInt count = *track->Value<TInt>( KMPXMediaArrayCount );
if ( count >= 0 )
{
found = ETrue;
}
CleanupStack::PopAndDestroy( track );
}
return found;
}
// --------------------------------------------------------------------------
// CUPnPPlaylistServices::IsValidPlaylistL
// --------------------------------------------------------------------------
//
EXPORT_C TBool CUPnPPlaylistServices::IsValidPlaylistL(
const TDesC& aPlaylistTitle )
{
__LOG1( "IsValidPlaylistL(%S)", &aPlaylistTitle );
if( iStatus != KErrNone)
{
__LOG1( "CUPnPPlaylistServices::IsValidPlaylistL iStatus %d return",
iStatus );
return EFalse;
}
TBool found = EFalse;
// find the playlist
CMPXMedia* playlist = FindItemL( EPlaylistByTitle, aPlaylistTitle );
if ( playlist != 0 )
{
CleanupStack::PushL( playlist );
TInt count = *playlist->Value<TInt>( KMPXMediaArrayCount );
if ( count >= 0 )
{
found = ETrue;
}
CleanupStack::PopAndDestroy( playlist );
}
return found;
}
// --------------------------------------------------------------------------
// Find a playlist
// --------------------------------------------------------------------------
//
CMPXMedia* CUPnPPlaylistServices::FindItemL(
TFindCategory aCategory,
const TDesC& aKey,
const TMPXAttributeData* aAttribute1,
const TMPXAttributeData* aAttribute2,
const TMPXAttributeData* aAttribute3 )
{
__LOG( "FindItemL" );
CMPXMedia* criteria = CMPXMedia::NewL();
CleanupStack::PushL( criteria );
criteria->SetTObjectValueL<TUid>(
KMPXMediaGeneralCollectionId, KMpxLocalCollectionUid );
criteria->SetTObjectValueL<TMPXGeneralType>(
KMPXMediaGeneralType, EMPXItem );
// set search keys
if ( aCategory == ESongs ||
aCategory == ESongByUri )
{
criteria->SetTObjectValueL<TMPXGeneralCategory>(
KMPXMediaGeneralCategory, EMPXSong );
if ( aCategory == ESongByUri )
{
criteria->SetTextValueL(
KMPXMediaGeneralUri, aKey );
}
}
else if ( aCategory == EPlaylists ||
aCategory == EPlaylistById ||
aCategory == EPlaylistByTitle )
{
criteria->SetTObjectValueL<TMPXGeneralCategory>(
KMPXMediaGeneralCategory, EMPXPlaylist );
if ( aCategory == EPlaylistById )
{
criteria->SetTObjectValueL<TMPXItemId>(
KMPXMediaGeneralId, Desc2Id( aKey ) );
}
else if ( aCategory == EPlaylistByTitle )
{
criteria->SetTextValueL(
KMPXMediaGeneralTitle, aKey );
}
}
else
{
__PANICD( __FILE__, __LINE__ );
}
// define attributes fetched
RArray<TMPXAttribute> attributes;
CleanupClosePushL( attributes );
if ( aAttribute1 )
{
// add attribute 1
attributes.AppendL( *aAttribute1 );
if ( aAttribute2 )
{
// add attribute 2
attributes.AppendL( *aAttribute2 );
if ( aAttribute3 )
{
// add attribute 3
attributes.AppendL( *aAttribute3 );
}
}
}
else
{
// add a dummy attribute because the query will fail if
// there are no attributes
attributes.AppendL( KMPXMediaGeneralId );
}
// now find
CMPXMedia* result = 0;
TRAPD( err, result = iCollectionUtility->Collection()
.FindAllL( *criteria , attributes.Array() ) );
CleanupStack::PopAndDestroy(); // attributes
CleanupStack::PopAndDestroy( criteria );
if ( err == KErrNotFound ||
err == KErrPathNotFound )
{
__LOG1( "FindAll: err=%d - not found.", err );
result = 0;
}
else if ( err != KErrNone )
{
__LOG1("FindAll: error=%d", err);
User::Leave( err );
}
else
{
__LOG( "FindAll: ok" );
}
return result;
}
// --------------------------------------------------------------------------
// Fetch a playlist content
// --------------------------------------------------------------------------
//
CMPXMedia* CUPnPPlaylistServices::FetchPlaylistContentL( const TDesC& aId )
{
__LOG( "FindPlaylistContentL" );
CMPXMedia* criteria = CMPXMedia::NewL();
CleanupStack::PushL( criteria );
criteria->SetTObjectValueL<TUid>(
KMPXMediaGeneralCollectionId, KMpxLocalCollectionUid );
criteria->SetTObjectValueL<TMPXGeneralType>(
KMPXMediaGeneralType, EMPXGroup );
// set search keys
criteria->SetTObjectValueL<TMPXGeneralCategory>(
KMPXMediaGeneralCategory, EMPXSong );
criteria->SetTObjectValueL<TMPXItemId>(
KMPXMediaGeneralId, Desc2Id( aId ) );
// define attributes fetched
RArray<TMPXAttribute> attributes;
CleanupClosePushL( attributes );
attributes.AppendL( KMPXMediaGeneralUri );
// now find
CMPXMedia* result = 0;
TRAPD( err, result = iCollectionUtility->Collection()
.FindAllL( *criteria , attributes.Array() ) );
CleanupStack::PopAndDestroy(); // attributes
CleanupStack::PopAndDestroy( criteria );
if ( err == KErrNotFound ||
err == KErrPathNotFound )
{
__LOG1( "FindAll: err=%d - not found.", err );
result = 0;
}
else if ( err != KErrNone )
{
__LOG1("FindAll: error=%d", err);
User::Leave( err );
}
else
{
__LOG( "FindAll: ok" );
}
return result;
}
// --------------------------------------------------------------------------
// Converts an ID from TMPXItemId form to descriptor form.
// --------------------------------------------------------------------------
//
const TDesC& CUPnPPlaylistServices::Id2Desc( const TMPXItemId& aId )
{
iTempBuffer.Num( aId );
return iTempBuffer;
}
// --------------------------------------------------------------------------
// Converts an ID from descriptor form to TMPXItemId form.
// --------------------------------------------------------------------------
//
TMPXItemId CUPnPPlaylistServices::Desc2Id( const TDesC& aDesc )
{
TLex convert( aDesc );
TUint temp;
convert.Val( temp, EDecimal );
TMPXItemId id(temp);
return id;
}