--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/profilesservices/MediaFileList/Src/mediafilehandler.cpp Wed Sep 01 12:20:44 2010 +0100
@@ -0,0 +1,3740 @@
+/*
+* 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 "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: Used to interact with the MDE.
+*
+*/
+
+
+
+
+#include "mediafilehandler.h"
+#include "mediafilelistdebug.h"
+#include "mediafiledialogstate.h"
+#include "mediafilelist.h"
+
+#include <pathinfo.h>
+#include <bautils.h>
+
+
+
+
+/******************************************************************************
+ * class CMediaFileData
+ ******************************************************************************/
+
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileData::NewL
+//
+// -----------------------------------------------------------------------------
+//
+CMediaFileData* CMediaFileData::NewL()
+ {
+ CMediaFileData* self = new (ELeave) CMediaFileData();
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+
+ return self;
+ }
+
+
+// -----------------------------------------------------------------------------
+// Destructor
+//
+// -----------------------------------------------------------------------------
+//
+CMediaFileData::~CMediaFileData()
+ {
+ delete iFullName;
+ delete iName;
+ delete iArtist;
+ delete iAlbum;
+ delete iGenre;
+ delete iComposer;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileData::CMediaFileData
+//
+// -----------------------------------------------------------------------------
+//
+CMediaFileData::CMediaFileData()
+ {
+ iMediaFileType = KErrNotFound;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileData::ConstructL
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileData::ConstructL()
+ {
+ iFullName = HBufC::NewL( 0 );
+ iName = HBufC::NewL( 0 );
+ iArtist = HBufC::NewL( 0 );
+ iAlbum = HBufC::NewL( 0 );
+ iGenre = HBufC::NewL( 0 );
+ iComposer = HBufC::NewL( 0 );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileData::Attr
+//
+// -----------------------------------------------------------------------------
+//
+const TDesC& CMediaFileData::Attr( TInt aAttr )
+ {
+ if ( aAttr == CMediaFileHandler::EAttrFullName )
+ {
+ return *iFullName;
+ }
+ if ( aAttr == CMediaFileHandler::EAttrSongName )
+ {
+ return *iName;
+ }
+ if ( aAttr == CMediaFileHandler::EAttrArtist )
+ {
+ return *iArtist;
+ }
+ if ( aAttr == CMediaFileHandler::EAttrAlbum )
+ {
+ return *iAlbum;
+ }
+ if ( aAttr == CMediaFileHandler::EAttrGenre )
+ {
+ return *iGenre;
+ }
+ if ( aAttr == CMediaFileHandler::EAttrComposer )
+ {
+ return *iComposer;
+ }
+
+ return KNullDesC;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileData::SetAttrL
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileData::SetAttrL( TInt aAttr, const TDesC& aValue )
+ {
+ if ( aAttr == CMediaFileHandler::EAttrFullName )
+ {
+ delete iFullName;
+ iFullName = NULL;
+ iFullName = aValue.AllocL();
+ }
+ if ( aAttr == CMediaFileHandler::EAttrSongName )
+ {
+ delete iName;
+ iName = NULL;
+ iName = aValue.AllocL();
+
+ }
+ if ( aAttr == CMediaFileHandler::EAttrArtist )
+ {
+ delete iArtist;
+ iArtist = NULL;
+ iArtist = aValue.AllocL();
+ }
+ if ( aAttr == CMediaFileHandler::EAttrAlbum )
+ {
+ delete iAlbum;
+ iAlbum = NULL;
+ iAlbum = aValue.AllocL();
+ }
+ if ( aAttr == CMediaFileHandler::EAttrGenre )
+ {
+ delete iGenre;
+ iGenre = NULL;
+ iGenre = aValue.AllocL();
+ }
+ if ( aAttr == CMediaFileHandler::EAttrComposer )
+ {
+ delete iComposer;
+ iComposer = NULL;
+ iComposer = aValue.AllocL();
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileData::GetAttr
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileData::GetAttr( TInt aAttr, TDes& aValue )
+ {
+ if ( aAttr == CMediaFileHandler::EAttrFullName )
+ {
+ TMFDialogUtil::StrCopy( aValue, iFullName->Des() );
+ }
+ else if ( aAttr == CMediaFileHandler::EAttrSongName )
+ {
+ TMFDialogUtil::StrCopy( aValue, iName->Des() );
+ }
+ else if ( aAttr == CMediaFileHandler::EAttrArtist )
+ {
+ TMFDialogUtil::StrCopy( aValue, iArtist->Des() );
+ }
+ else if ( aAttr == CMediaFileHandler::EAttrAlbum )
+ {
+ TMFDialogUtil::StrCopy( aValue, iAlbum->Des() );
+ }
+ else if ( aAttr == CMediaFileHandler::EAttrGenre )
+ {
+ TMFDialogUtil::StrCopy( aValue, iGenre->Des() );
+ }
+ else if ( aAttr == CMediaFileHandler::EAttrComposer )
+ {
+ TMFDialogUtil::StrCopy( aValue, iComposer->Des() );
+ }
+ else
+ {
+ aValue = KNullDesC;
+ }
+ }
+
+
+/******************************************************************************
+ * class CMediaFileHandler
+ ******************************************************************************/
+
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::NewL
+//
+// -----------------------------------------------------------------------------
+//
+CMediaFileHandler* CMediaFileHandler::NewL()
+ {
+ CMediaFileHandler* self = new (ELeave) CMediaFileHandler();
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+
+ return self;
+ }
+
+
+// -----------------------------------------------------------------------------
+// Destructor
+//
+// -----------------------------------------------------------------------------
+//
+CMediaFileHandler::~CMediaFileHandler()
+ {
+ delete iSearchList;
+
+ delete iQueryCaller;
+ delete iObjectNotificationCaller;
+
+ delete iDriveUtil;
+ delete iExcludedMimeTypes;
+ delete iIdle;
+
+ delete iQuery;
+ delete iArtistQuery;
+ delete iSession;
+
+ delete iRomFileList;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::CMediaFileHandler
+//
+// -----------------------------------------------------------------------------
+//
+CMediaFileHandler::CMediaFileHandler()
+ {
+ iSessionOpen = EFalse;
+ iObserverCallEnabled = ETrue;
+
+ iMaxFileSize = KErrNotFound;
+ iQueryId = KErrNotFound;
+ iQueryType = KErrNotFound;
+ iQueryError = KErrNone;
+ iQueryEvent = KErrNotFound;
+ iVideoSearchDisabled = EFalse;
+
+ iMediaFileCounter = 0;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::ConstructL
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::ConstructL()
+ {
+ iSession = CMdESession::NewL( *this );
+ iSearchList = CSearchList::NewL();
+
+ iQueryCaller = CMFActiveCaller::NewL( this );
+ iObjectNotificationCaller = CMFActiveCaller::NewL( this );
+
+ iDriveUtil = CDriveUtil::NewL();
+ iArtistQuery = CArtistQuery::NewL();
+ iExcludedMimeTypes = CMimeTypeList::NewL();
+
+ iRomFileList = CRomFileList::NewL();
+ iQueryinProgress = EFalse;
+ iRomScanState = MMediaFileHandlerObserver::ENoneRomScan;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::SetAttr
+//
+// -----------------------------------------------------------------------------
+void CMediaFileHandler::SetAttrL( TInt aAttr, TInt aValue )
+ {
+ switch ( aAttr )
+ {
+ case CMediaFileList::EAttrFileSize:
+ {
+ iMaxFileSize = aValue;
+ break;
+ }
+ case CMediaFileList::EAttrExcludeFolder:
+ {
+ if ( aValue == CMediaFileList::EFolderVideos )
+ {
+ iVideoSearchDisabled = ETrue;
+ }
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::SetAttrL
+//
+// -----------------------------------------------------------------------------
+void CMediaFileHandler::SetAttrL( TInt aAttr, const TDesC& aValue )
+ {
+ if ( aAttr == CMediaFileList::EAttrExcludeMimeType )
+ {
+ iExcludedMimeTypes->AddMimeTypeL( aValue );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::SetAttr
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::SetAttrL( TInt /*aAttr*/, TAny* /*aValue*/ )
+ {
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::HandleSessionOpened (from MMdESessionObserver)
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::HandleSessionOpened( CMdESession& /*aSession*/, TInt aError )
+ {
+ if ( aError != KErrNone )
+ {
+ delete iSession;
+ iSession = NULL;
+ iSessionOpen = EFalse;
+ }
+ else
+ {
+ iSessionOpen = ETrue;
+
+ TRAP_IGNORE( AddObjectObserverL() );
+ }
+
+ CallObserver( MMediaFileHandlerObserver::EInitComplete, aError );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::AddObjectObserverL
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::AddObjectObserverL()
+ {
+ if ( iSessionOpen )
+ {
+ TUint32 notificationType = ENotifyAdd | ENotifyModify | ENotifyRemove;
+ CMdENamespaceDef& defNS = iSession->GetDefaultNamespaceDefL();
+ iSession->AddObjectObserverL( *this, NULL, notificationType, &defNS );
+
+ iSession->AddObjectPresentObserverL( *this );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::HandleSessionError (from MMdESessionObserver)
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::HandleSessionError( CMdESession& /*aSession*/, TInt aError )
+ {
+ if ( aError == KErrNone )
+ {
+ return;
+ }
+
+ delete iSession;
+ iSession = NULL;
+ iSessionOpen = EFalse;
+
+ CallObserver( MMediaFileHandlerObserver::EError, aError );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::HandleQueryNewResults (from MMdEQueryObserver)
+//
+// This observer function is called during query. Calling frequency is defined
+// in second parameter of CMdEQuery::FindL.
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::HandleQueryNewResults( CMdEQuery& /*aQuery*/,
+ TInt /*aFirstNewItemIndex*/,
+ TInt /*aNewItemCount*/ )
+ {
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::HandleObjectNotification (MMdEObjectObserver)
+//
+// Called when metadata database changes.
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::HandleObjectNotification( CMdESession& /*aSession*/,
+ TObserverNotificationType aType,
+ const RArray<TItemId>& aObjectIdArray )
+ {
+ const TInt KObserverCallStep = 100;
+
+ if ( aType == ENotifyAdd || aType == ENotifyModify || aType == ENotifyRemove )
+ {
+ if ( iObserver )
+ {
+ TInt count = aObjectIdArray.Count();
+ FLOG( _L("CMediaFileHandler::HandleObjectNotification: count is %d"), count );
+
+ iMediaFileCounter = iMediaFileCounter + count;
+ if ( iMediaFileCounter >= KObserverCallStep )
+ {
+ iMediaFileCounter = 0;
+ TRAP_IGNORE( iObserver->HandleMFEventL(
+ MMediaFileHandlerObserver::EMediaFileChanged, KErrNone ) );
+ }
+ else
+ {
+ // delayed call to avoid many consecutive observer calls
+ CallObserverWithDelay();
+ }
+ }
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::HandleObjectPresentNotification (MMdEObjectPresentObserver)
+//
+// Called when previously used memory card is inserted and hidden
+// metadata files are made present again.
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::HandleObjectPresentNotification( CMdESession& /*aSession*/,
+ TBool /*aPresent*/, const RArray<TItemId>& aObjectIdArray )
+ {
+ if ( iObserver )
+ {
+ TInt count = aObjectIdArray.Count();
+ FLOG( _L("CMediaFileHandler::HandleObjectPresentNotification: count is %d"), count );
+
+ // delayed call to avoid many consecutive observer calls
+ CallObserverWithDelay();
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::HandleQueryCompleted (MMdEQueryObserver)
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::HandleQueryCompleted( CMdEQuery& aQuery, TInt aError )
+ {
+
+ TInt err = KErrNone;
+ TRAP( err, HandleQueryCompletedL( aQuery, aError ) );
+
+ if ( err == KErrCancel )
+ {
+ CallObserver( MMediaFileHandlerObserver::EQueryCanceled, KErrNone );
+ }
+ else if ( err != KErrNone )
+ {
+ iSearchList->Reset();
+ TRAP_IGNORE( iArtistQuery->ResetL() );
+
+ CallObserver( MMediaFileHandlerObserver::EError, err );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::HandleQueryCompletedL
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::HandleQueryCompletedL( CMdEQuery& /*aQuery*/, TInt aError )
+ {
+ TInt err = aError;
+
+ if ( !iQuery && ( iRomScanState != MMediaFileHandlerObserver::ERomScanComplete
+ && (iQueryType == EQueryTone || iQueryType == ESearchTones )) )
+ {
+ err = KErrGeneral;
+ }
+ if ( err == KErrCancel )
+ {
+ if ( iQueryType == ESearchAudio || iQueryType == ESearchMusic ||
+ iQueryType == ESearchTones || iQueryType == ESearchVideo )
+ {
+ iSearchList->Reset();
+ }
+ User::Leave( err );
+ }
+ if ( err != KErrNone )
+ {
+ User::Leave( err );
+ }
+
+
+ iSearchList->SetSession( iSession );
+
+ TQueryResultMode resultMode = EQueryResultModeItem;
+ if ( iQuery )
+ {
+ resultMode = iQuery->ResultMode();
+ }
+
+
+ if ( resultMode == EQueryResultModeDistinctValues )
+ {
+ iSearchList->Reset();
+ iSearchList->TakeDistinctResultL( iQuery, KErrNotFound );
+ iSearchList->SetSearchId( iQueryId );
+ iSearchList->Sort();
+
+ CallObserver( MMediaFileHandlerObserver::EQueryComplete, KErrNone );
+ }
+ else if ( resultMode == EQueryResultModeCount )
+ {
+ // EQueryResultModeCount currently not used
+ CallObserver( MMediaFileHandlerObserver::EUnknownQueryComplete, KErrNone );
+ }
+ else if ( resultMode == EQueryResultModeItem )
+ {
+ if ( iQueryType == ESearchAudio )
+ {
+ // ESearchAudio currently not used
+ iSearchList->Reset();
+ iSearchList->TakeResultL( iQuery, EMediaTypeMusic );
+ iSearchList->Sort();
+ iSearchList->SetSearchId( iQueryId );
+
+ CallObserver( MMediaFileHandlerObserver::EQueryComplete, KErrNone );
+
+ /*
+ // ESearchAudio currently not used
+ iSearchList->Reset();
+ iSearchList->TakeResultL( iQuery, EMediaTypeMusic );
+
+ delete iIdle;
+ iIdle = NULL;
+ iIdle = CIdle::NewL( CActive::EPriorityIdle );
+ if ( iIdle )
+ {
+ iIdle->Start( TCallBack( SearchVideo, this ) );
+ }
+ */
+ }
+ else if ( iQueryType == ESearchMusic )
+ {
+ // search is done in 3 steps (music, tones and videos)
+ iSearchList->Reset();
+ iSearchList->TakeResultL( iQuery, EMediaTypeMusic );
+
+ // call SearchTonesL after short delay (iQuery cannot
+ // be deleted in this function)
+ delete iIdle;
+ iIdle = NULL;
+ iIdle = CIdle::NewL( CActive::EPriorityIdle );
+ if ( iIdle )
+ {
+ iIdle->Start( TCallBack( SearchTones, this ) );
+ }
+ else
+ {
+ User::Leave( KErrNoMemory );
+ }
+ }
+ else if ( iQueryType == ESearchTones )
+ {
+ iSearchList->SearchInToneL( iRomFileList, iSearchText );
+ iQueryinProgress = EFalse;
+ // call SearchVideosL after short delay (iQuery cannot
+ // be deleted in this function)
+ delete iIdle;
+ iIdle = NULL;
+ iIdle = CIdle::NewL( CActive::EPriorityIdle );
+ if ( iIdle )
+ {
+ iIdle->Start( TCallBack( SearchVideo, this ) );
+ }
+ else
+ {
+ User::Leave( KErrNoMemory );
+ }
+ }
+ else if ( iQueryType == ESearchVideo )
+ {
+ iSearchList->TakeResultL( iQuery, EMediaTypeVideo );
+ iSearchList->VideoSearchInRomL( iRomFileList, iSearchText );
+ iSearchList->Sort();
+ iSearchList->SetSearchId( iQueryId );
+
+ CallObserver( MMediaFileHandlerObserver::EQueryComplete, KErrNone );
+ }
+
+ else if ( iQueryType == EQueryArtist )
+ {
+ // store CMdEObjectQuery to avoid multiple queries for one artist
+ iArtistQuery->SetQuery( iQuery );
+ iQuery = NULL;
+
+ iSearchList->Reset();
+ iSearchList->TakeArtistResultL( iArtistQuery );
+ iSearchList->Sort();
+ iSearchList->SetSearchId( iQueryId );
+
+ CallObserver( MMediaFileHandlerObserver::EQueryComplete, KErrNone );
+ }
+ else if ( iQueryType == EQueryArtistEmpty )
+ {
+ // use previously stored CMdEObjectQuery for artist query
+ iSearchList->Reset();
+ iSearchList->TakeArtistResultL( iArtistQuery );
+ iSearchList->Sort();
+ iSearchList->SetSearchId( iQueryId );
+
+ CallObserver( MMediaFileHandlerObserver::EQueryComplete, KErrNone );
+ }
+ else if ( iQueryType == EQueryEmpty )
+ {
+ iSearchList->Reset();
+ iSearchList->SetSearchId( iQueryId );
+
+ CallObserver( MMediaFileHandlerObserver::EQueryComplete, KErrNone );
+ }
+ else if ( iQueryType == EQueryUnknown )
+ {
+ iSearchList->Reset();
+ iSearchList->TakeResultL( iQuery, EMediaTypeMusic );
+ iSearchList->SetSearchId( iQueryId );
+
+ CallObserver( MMediaFileHandlerObserver::EUnknownQueryComplete, KErrNone );
+ }
+ else
+ {
+ TInt mediaType = MediaType( iQueryType );
+ iSearchList->Reset();
+ if ( mediaType == EMediaTypeTone )
+ {
+ iSearchList->AddRomItemL( iRomFileList, mediaType );
+ }
+ else
+ {
+ iSearchList->TakeResultL( iQuery, mediaType );
+ if ( mediaType == EMediaTypeVideo )
+ {
+ iSearchList->AddRomItemL( iRomFileList, mediaType );
+ }
+ }
+ iQueryinProgress = EFalse;
+ iSearchList->SetSearchId( iQueryId );
+ iSearchList->Sort();
+
+ CallObserver( MMediaFileHandlerObserver::EQueryComplete, KErrNone );
+ }
+ }
+ else
+ {
+ CallObserver( MMediaFileHandlerObserver::EError, KErrNotSupported );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::QueryArtistL
+//
+// Finds all music files for one artist. Query results are placed in
+// CArtistQuery.
+// CArtistQuery can then be used for artist subqueries (all albums, one album,
+// all songs, unknown songs).
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::QueryArtistL( TInt aAttr, const TDesC& aArtist,
+ const TDesC& aAlbum, TBool aRefresh )
+ {
+ LeaveIfSessionClosedL();
+
+ if ( aAttr != EQueryArtist && aAttr != EQueryArtistAlbum &&
+ aAttr != EQueryArtistAll && aAttr != EQueryArtistUnknown )
+ {
+ User::Leave( KErrNotSupported );
+ }
+
+ TBool updateFromDatabase = aRefresh;
+ if ( iArtistQuery->Artist().Compare( aArtist ) != 0 )
+ {
+ updateFromDatabase = ETrue;
+ }
+
+ if ( updateFromDatabase )
+ {
+ CMdENamespaceDef& defNS = iSession->GetDefaultNamespaceDefL();
+ CMdEObjectDef& objectDef = defNS.GetObjectDefL( MdeConstants::Audio::KAudioObject );
+
+ delete iQuery;
+ iQuery = NULL;
+ iQuery = iSession->NewObjectQueryL( defNS, objectDef, this );
+
+ // set attributes that are included in query result
+ CMdEPropertyDef& namePropertyDef = PropertyDefL( EAttrSongName );
+ iQuery->AddPropertyFilterL( &namePropertyDef );
+ CMdEPropertyDef& albumPropertyDef = PropertyDefL( EAttrAlbum );
+ iQuery->AddPropertyFilterL( &albumPropertyDef );
+
+ CMdELogicCondition& conditions = iQuery->Conditions();
+ CMdEPropertyDef& propertyDef = PropertyDefL( EAttrArtist );
+ conditions.AddPropertyConditionL( propertyDef,
+ ETextPropertyConditionCompareEquals, aArtist );
+
+ iQuery->SetResultMode( EQueryResultModeItem );
+
+ iArtistQuery->SetArtistL( aArtist );
+ iArtistQuery->SetAlbumL( aAlbum );
+ iQuery->FindL();
+ iQueryType = EQueryArtist;
+ }
+ else
+ {
+ iArtistQuery->SetAlbumL( aAlbum );
+ QueryArtistEmptyL();
+ iQueryType = EQueryArtistEmpty;
+ }
+
+ iArtistQuery->SetQueryType( aAttr );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::QueryArtistEmptyL
+//
+// Makes empty query. Query results were previously placed into CArtistQuery.
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::QueryArtistEmptyL()
+ {
+ LeaveIfSessionClosedL();
+
+ CMdENamespaceDef& defNS = iSession->GetDefaultNamespaceDefL();
+ CMdEObjectDef& objectDef =
+ defNS.GetObjectDefL( MdeConstants::Object::KBaseObject );
+
+ delete iQuery;
+ iQuery = NULL;
+ iQuery = iSession->NewObjectQueryL( defNS, objectDef, this );
+
+ iQuery->SetResultMode( EQueryResultModeItem );
+
+ iQuery->FindL( 1 );
+
+ iQueryType = EQueryArtistEmpty;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::QueryMusicL
+//
+// Finds music files.
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::QueryMusicL( TInt /*aAttr*/ )
+ {
+ LeaveIfSessionClosedL();
+
+ CMdENamespaceDef& defNS = iSession->GetDefaultNamespaceDefL();
+ CMdEObjectDef& musicObjectDef =
+ defNS.GetObjectDefL( MdeConstants::Audio::KAudioObject );
+
+ delete iQuery;
+ iQuery = NULL;
+ iQuery = iSession->NewObjectQueryL( defNS, musicObjectDef, this );
+
+ // set attributes that are included in query result
+ CMdEPropertyDef& namePropertyDef = PropertyDefL( EAttrSongName );
+ iQuery->AddPropertyFilterL( &namePropertyDef );
+ CMdEPropertyDef& fileTypePropertyDef = PropertyDefL( EAttrMediaType );
+ iQuery->AddPropertyFilterL( &fileTypePropertyDef );
+
+
+ CMdELogicCondition& conditions = iQuery->Conditions();
+
+ // include properties that identify music
+ IncludeMusicPropertiesL( conditions );
+
+ //
+ // example of defining sort order
+ //
+ // iQuery->AppendOrderRuleL( TMdEOrderRule( namePropertyDef, ESortAscending ) );
+
+ iQuery->SetResultMode( EQueryResultModeItem );
+
+ iQuery->FindL();
+
+ iQueryType = EQueryMusic;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::QueryMusicL
+//
+// Finds music files with attibute that matches aFindText. Supported attributes
+// are EAttrArtist, EAttrAlbum, EAttrGenre and EAttrComposer.
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::QueryMusicL( TInt aAttr, const TDesC& aFindText )
+ {
+ LeaveIfSessionClosedL();
+ CheckAttrL( aAttr );
+
+ CMdENamespaceDef& defNS = iSession->GetDefaultNamespaceDefL();
+ CMdEObjectDef& objectDef =
+ defNS.GetObjectDefL( MdeConstants::Audio::KAudioObject );
+
+ delete iQuery;
+ iQuery = NULL;
+ iQuery = iSession->NewObjectQueryL( defNS, objectDef, this );
+
+ // set attributes that are included in query result
+ CMdEPropertyDef& namePropertyDef = PropertyDefL( EAttrSongName );
+ iQuery->AddPropertyFilterL( &namePropertyDef );
+
+ CMdELogicCondition& conditions = iQuery->Conditions();
+ CMdEPropertyDef& propertyDef = PropertyDefL( aAttr );
+ conditions.AddPropertyConditionL( propertyDef,
+ ETextPropertyConditionCompareEquals, aFindText );
+ IncludeMusicPropertiesL( conditions );
+ iQuery->SetResultMode( EQueryResultModeItem );
+
+ iQuery->FindL();
+
+ iQueryType = EQueryMusic;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::QueryVideosL
+//
+// Finds all video files.
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::QueryVideosL( TInt /*aAttr*/ )
+ {
+ LeaveIfSessionClosedL();
+
+ CMdENamespaceDef& defNS = iSession->GetDefaultNamespaceDefL();
+ CMdEObjectDef& videoObjectDef =
+ defNS.GetObjectDefL( MdeConstants::Video::KVideoObject );
+
+ delete iQuery;
+ iQuery = NULL;
+ iQuery = iSession->NewObjectQueryL( defNS, videoObjectDef, this );
+
+ // set attributes that are included in query result
+ CMdEPropertyDef& namePropertyDef = PropertyDefL( EAttrSongName );
+ iQuery->AddPropertyFilterL( &namePropertyDef );
+
+ iQuery->SetResultMode( EQueryResultModeItem );
+
+ iQuery->FindL();
+
+ iQueryType = EQueryVideo;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::QueryAttributeValuesL
+//
+// Finds all different values for aAttr (all artists, albums, genres,
+// or composers).
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::QueryAttributeValuesL( TInt aAttr )
+ {
+ LeaveIfSessionClosedL();
+ CheckAttrL( aAttr );
+
+ CMdENamespaceDef& defNS = iSession->GetDefaultNamespaceDefL();
+ CMdEObjectDef& objectDef =
+ defNS.GetObjectDefL( MdeConstants::Audio::KAudioObject );
+
+ delete iQuery;
+ iQuery = NULL;
+ iQuery = iSession->NewObjectQueryL( defNS, objectDef, this );
+
+ iQuery->SetResultMode( EQueryResultModeDistinctValues );
+
+ CMdEPropertyDef& propertyDef = PropertyDefL( aAttr );
+
+ // distinct query requires exactly one property filter
+ // (eg. attribute that is included in query result)
+ CMdELogicCondition& conditions = iQuery->Conditions();
+ conditions.AddPropertyConditionL( propertyDef );
+ iQuery->AddPropertyFilterL( &propertyDef );
+ IncludeMusicPropertiesL( conditions );
+ iQuery->FindL();
+
+ iQueryType = EQueryMusic;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::QueryMusicUnknownL
+//
+// Find music files that do not have attribute aAttr (eg find all files without
+// album attribute).
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::QueryMusicUnknownL( TInt aAttr )
+ {
+ LeaveIfSessionClosedL();
+ CheckAttrL( aAttr );
+
+ CMdENamespaceDef& defNS = iSession->GetDefaultNamespaceDefL();
+ CMdEObjectDef& objectDef =
+ defNS.GetObjectDefL( MdeConstants::Audio::KAudioObject );
+
+ delete iQuery;
+ iQuery = NULL;
+ iQuery = iSession->NewObjectQueryL( defNS, objectDef, this );
+
+ iQuery->SetResultMode( EQueryResultModeItem );
+
+ CMdEPropertyDef& propertyDef = PropertyDefL( aAttr );
+ CMdEPropertyDef& namePropertyDef = PropertyDefL( EAttrSongName );
+
+
+ CMdELogicCondition& conditions = iQuery->Conditions();
+
+ // include properties that identify music
+ IncludeMusicPropertiesL( conditions );
+
+ // add condition: get music that do not have aAttr attribute
+ CMdELogicCondition& condition =
+ conditions.AddLogicConditionL( ELogicConditionOperatorAnd );
+ condition.AddPropertyConditionL( propertyDef );
+ condition.SetNegate( ETrue );
+
+ // set attributes that are included in query result
+ iQuery->AddPropertyFilterL( &namePropertyDef );
+
+ iQuery->FindL();
+
+ iQueryType = EQueryMusic;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::QueryMusicUnknownCountL
+//
+// Find whether there are music files that do not have attribute aAttr
+// (eg files without album attribute)
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::QueryMusicUnknownCountL( TInt aAttr )
+ {
+ LeaveIfSessionClosedL();
+ CheckAttrL( aAttr );
+
+ CMdENamespaceDef& defNS = iSession->GetDefaultNamespaceDefL();
+ CMdEObjectDef& objectDef =
+ defNS.GetObjectDefL( MdeConstants::Audio::KAudioObject );
+
+ delete iQuery;
+ iQuery = NULL;
+ iQuery = iSession->NewObjectQueryL( defNS, objectDef, this );
+
+ iQuery->SetResultMode( EQueryResultModeItem );
+
+ CMdEPropertyDef& propertyDef = PropertyDefL( aAttr );
+
+ CMdELogicCondition& conditions = iQuery->Conditions();
+
+ // include properties that identify music
+ IncludeMusicPropertiesL( conditions );
+
+ // add condition: get music that do not have aAttr attribute
+ CMdELogicCondition& condition =
+ conditions.AddLogicConditionL( ELogicConditionOperatorAnd );
+ condition.AddPropertyConditionL( propertyDef );
+ condition.SetNegate( ETrue );
+
+
+ // count 0 or 1 is enough for UI
+ iQuery->FindL( 1 );
+ iQueryType = EQueryUnknown;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::QueryEmptyL
+//
+// Makes empty query.
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::QueryEmptyL()
+ {
+ LeaveIfSessionClosedL();
+ iQueryType = EQueryEmpty;
+ if ( iQuery )
+ {
+ iQuery->SetResultMode( EQueryResultModeItem );
+ HandleQueryCompleted( *iQuery , KErrNone);
+ }
+ else
+ {
+ CMdENamespaceDef& defNS = iSession->GetDefaultNamespaceDefL();
+ CMdEObjectDef& objectDef =
+ defNS.GetObjectDefL( MdeConstants::Object::KBaseObject );
+
+ delete iQuery;
+ iQuery = NULL;
+ iQuery = iSession->NewObjectQueryL( defNS, objectDef, this );
+
+ iQuery->SetResultMode( EQueryResultModeItem );
+ iQuery->FindL( 0 );
+
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::QueryRomEmptyL( TInt aQueryType )
+//
+// Makes empty query.
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::QueryRomEmptyL( TInt aQueryType )
+ {
+ LeaveIfSessionClosedL();
+ if ( iQuery )
+ {
+ iQueryType = aQueryType;
+ HandleQueryCompleted( *iQuery , KErrNone);
+ }
+ else
+ {
+ CMdENamespaceDef& defNS = iSession->GetDefaultNamespaceDefL();
+ CMdEObjectDef& objectDef =
+ defNS.GetObjectDefL( MdeConstants::Object::KBaseObject );
+
+ delete iQuery;
+ iQuery = NULL;
+ iQuery = iSession->NewObjectQueryL( defNS, objectDef, this );
+
+ iQuery->SetResultMode( EQueryResultModeItem );
+ iQuery->FindL( 0 );
+
+ iQueryType = aQueryType;
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::QueryRecordingsL
+//
+// Finds all recordings.
+//
+// Note: File is considered a recording if file extension is "amr" or "wav" and
+// file is not in rom.
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::QueryRecordingsL( TInt /*aAttr*/ )
+ {
+ LeaveIfSessionClosedL();
+
+ CMdENamespaceDef& defNS = iSession->GetDefaultNamespaceDefL();
+ CMdEObjectDef& musicObjectDef =
+ defNS.GetObjectDefL( MdeConstants::Audio::KAudioObject );
+
+ delete iQuery;
+ iQuery = NULL;
+ iQuery = iSession->NewObjectQueryL( defNS, musicObjectDef, this );
+
+
+ // set attributes that are included in query result
+ CMdEPropertyDef& namePropertyDef = PropertyDefL( EAttrSongName );
+ iQuery->AddPropertyFilterL( &namePropertyDef );
+
+ iQuery->SetResultMode( EQueryResultModeItem );
+
+ CMdEPropertyDef& fileTypeDef = PropertyDefL( EAttrMediaType );
+
+
+ CMdELogicCondition& conditions = iQuery->Conditions();
+ CMdEObjectCondition& cond = conditions.AddObjectConditionL(
+ EObjectConditionCompareUriBeginsWith, KDriveZ );
+ cond.SetNegate( ETrue );
+
+
+ CMdELogicCondition& condition =
+ conditions.AddLogicConditionL( ELogicConditionOperatorOr );
+ condition.AddPropertyConditionL( fileTypeDef,
+ ETextPropertyConditionCompareContains, KMimeTypeAMR );
+ condition.AddPropertyConditionL( fileTypeDef,
+ ETextPropertyConditionCompareContains, KMimeTypeWAV );
+
+ iQuery->FindL();
+
+ iQueryType = EQueryRecording;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::QueryTonesL
+//
+// Finds all tones.
+// Note: Audio file is considered a tone if it is not music or video.
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::QueryTonesL( TInt /*aAttr*/ )
+ {
+ LeaveIfSessionClosedL();
+
+ CMdENamespaceDef& defNS = iSession->GetDefaultNamespaceDefL();
+ CMdEObjectDef& musicObjectDef =
+ defNS.GetObjectDefL( MdeConstants::Audio::KAudioObject );
+
+ delete iQuery;
+ iQuery = NULL;
+ iQuery = iSession->NewObjectQueryL( defNS, musicObjectDef, this );
+
+
+ // set attributes that are included in query result
+ CMdEPropertyDef& namePropertyDef = PropertyDefL( EAttrSongName );
+ iQuery->AddPropertyFilterL( &namePropertyDef );
+
+ iQuery->SetResultMode( EQueryResultModeItem );
+
+ CMdELogicCondition& conditions = iQuery->Conditions();
+ ExcludeMusicPropertiesL( conditions );
+
+ iQuery->FindL();
+
+ iQueryType = EQueryTone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::QueryDefaultTonesL
+//
+// Finds all sound files from rom (nokia default tones).
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::QueryDefaultTonesL( TInt /*aAttr*/ )
+ {
+
+ if ( iRomScanState == MMediaFileHandlerObserver::ERomScanComplete )
+ {
+ QueryRomEmptyL( EQueryTone );
+ }
+ else if ( iRomScanState == MMediaFileHandlerObserver::ERomScanInProgress )
+ {
+ iQueryinProgress = ETrue;
+ }
+ else
+ {
+ //Rom scan not start or failed for some reason
+ iQueryinProgress = ETrue;
+ StartRomScaning( EQueryTone );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::QueryDefaultTTonessL
+//
+// Finds all sound files from rom (nokia default tones).
+// -----------------------------------------------------------------------------
+//
+//void CMediaFileHandler::QueryDefaultTonesL( TInt /*aAttr*/ )
+// {
+// LeaveIfSessionClosedL();
+//
+// CMdENamespaceDef& defNS = iSession->GetDefaultNamespaceDefL();
+// CMdEObjectDef& musicObjectDef =
+// defNS.GetObjectDefL( MdeConstants::Audio::KAudioObject );
+//
+// delete iQuery;
+// iQuery = NULL;
+// iQuery = iSession->NewObjectQueryL( defNS, musicObjectDef, this );
+//
+//
+// // set attributes that are included in query result
+// CMdEPropertyDef& namePropertyDef = PropertyDefL( EAttrSongName );
+// iQuery->AddPropertyFilterL( &namePropertyDef );
+//
+// iQuery->SetResultMode( EQueryResultModeItem );
+//
+// CMdELogicCondition& conditions = iQuery->Conditions();
+// CMdEObjectCondition& cond = conditions.AddObjectConditionL(
+// EObjectConditionCompareUriBeginsWith, KDriveZ );
+//
+// iQuery->FindL();
+//
+// iQueryType = EQueryTone;
+// }
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::SearchL
+//
+// Finds all music, tone and video files with any attibute that
+// matches aFindText.
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::SearchL( const TDesC& aSearchText )
+ {
+ //
+ // search is done in 3 steps, SearchTonesL and SearchVideoL are
+ // called after SearchMusicL is done. Search results are collected
+ // in iSearchList.
+ //
+
+ if ( aSearchText.Length() == 0 )
+ {
+ iSearchText = KNullDesC;
+ QueryEmptyL();
+ }
+ else
+ {
+ StrCopy( iSearchText, aSearchText );
+ SearchMusicL( iSearchText );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::SearchAudioL
+//
+// Finds all audio files with attibute that matches aFindText.
+// Searched attributes are name, artist, album, genre, composer.
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::SearchAudioL( const TDesC& aSearchText )
+ {
+ SearchMusicL( aSearchText );
+ iQueryType = ESearchAudio;
+
+ /*
+ LeaveIfSessionClosedL();
+
+ CMdENamespaceDef& defNS = iSession->GetDefaultNamespaceDefL();
+ CMdEObjectDef& objectDef =
+ defNS.GetObjectDefL( MdeConstants::Audio::KAudioObject );
+
+ delete iQuery;
+ iQuery = NULL;
+ iQuery = iSession->NewObjectQueryL( defNS, objectDef, this );
+
+ // set attributes that are included in query result
+ CMdEPropertyDef& song = PropertyDefL( EAttrSongName );
+ iQuery->AddPropertyFilterL( &song );
+
+ CMdEPropertyDef& artist = PropertyDefL( EAttrArtist );
+ iQuery->AddPropertyFilterL( &artist );
+ CMdEPropertyDef& album = PropertyDefL( EAttrAlbum );
+ iQuery->AddPropertyFilterL( &album );
+ CMdEPropertyDef& genre = PropertyDefL( EAttrGenre );
+ iQuery->AddPropertyFilterL( &genre );
+ CMdEPropertyDef& composer = PropertyDefL( EAttrComposer );
+ iQuery->AddPropertyFilterL( &composer );
+
+ CMdEPropertyDef& fileTypePropertyDef = PropertyDefL( EAttrMediaType );
+ iQuery->AddPropertyFilterL( &fileTypePropertyDef );
+
+
+ CMdELogicCondition& conditions = iQuery->Conditions();
+ conditions.SetOperator( ELogicConditionOperatorAnd );
+
+ IncludeMusicSearchConditionL( conditions, aSearchText );
+
+
+
+ // iQuery->AppendOrderRuleL( TMdEOrderRule( song, ESortAscending ) );
+ iQuery->SetResultMode( EQueryResultModeItem );
+ iQuery->FindL();
+
+ iQueryType = ESearchAudio;
+ */
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::SearchMusicL
+//
+// Finds all music with attibute that matches aFindText.
+// Searched attributes are name, artist, album, genre, composer.
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::SearchMusicL( const TDesC& aSearchText )
+ {
+ LeaveIfSessionClosedL();
+
+ CMdENamespaceDef& defNS = iSession->GetDefaultNamespaceDefL();
+ CMdEObjectDef& objectDef =
+ defNS.GetObjectDefL( MdeConstants::Audio::KAudioObject );
+
+ delete iQuery;
+ iQuery = NULL;
+ iQuery = iSession->NewObjectQueryL( defNS, objectDef, this );
+
+ // set attributes that are included in query result
+ CMdEPropertyDef& songName = PropertyDefL( EAttrSongName );
+ iQuery->AddPropertyFilterL( &songName );
+ CMdEPropertyDef& fileTypePropertyDef = PropertyDefL( EAttrMediaType );
+ iQuery->AddPropertyFilterL( &fileTypePropertyDef );
+
+
+ CMdELogicCondition& conditions = iQuery->Conditions();
+ conditions.SetOperator( ELogicConditionOperatorAnd );
+
+ //IncludeMusicPropertiesL( conditions );
+ IncludeMusicSearchConditionL( conditions, aSearchText );
+
+ iQuery->SetResultMode( EQueryResultModeItem );
+ iQuery->FindL();
+
+ iQueryType = ESearchMusic;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::SearchTonesL
+//
+// Finds all tones with attibute that matches aFindText.
+// Searched attribute is file name.
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::SearchTonesL( const TDesC& /*aSearchText */)
+ {
+ if ( iRomScanState == MMediaFileHandlerObserver::ERomScanComplete )
+ {
+ QueryRomEmptyL( ESearchTones );
+ }
+ else if ( iRomScanState == MMediaFileHandlerObserver::ERomScanInProgress )
+ {
+ iQueryinProgress = ETrue;
+ }
+ else
+ {
+ //Rom scan not start or failed for some reason
+ iQueryinProgress = ETrue;
+ StartRomScaning( ESearchTones );
+ }
+ }
+
+//
+//// -----------------------------------------------------------------------------
+//// CMediaFileHandler::SearchTonesL
+////
+//// Finds all tones with attibute that matches aFindText.
+//// Searched attribute is file name.
+//// -----------------------------------------------------------------------------
+////
+//void CMediaFileHandler::SearchTonesL( const TDesC& aSearchText )
+// {
+// LeaveIfSessionClosedL();
+//
+// CMdENamespaceDef& defNS = iSession->GetDefaultNamespaceDefL();
+// CMdEObjectDef& objectDef =
+// defNS.GetObjectDefL( MdeConstants::Audio::KAudioObject );
+//
+// delete iQuery;
+// iQuery = NULL;
+// iQuery = iSession->NewObjectQueryL( defNS, objectDef, this );
+//
+// // set attributes that are included in query result
+// CMdEPropertyDef& songName = PropertyDefL( EAttrSongName );
+// iQuery->AddPropertyFilterL( &songName );
+// CMdEPropertyDef& fileTypePropertyDef = PropertyDefL( EAttrMediaType );
+// iQuery->AddPropertyFilterL( &fileTypePropertyDef );
+//
+//
+// CMdELogicCondition& conditions = iQuery->Conditions();
+// conditions.SetOperator( ELogicConditionOperatorAnd );
+//
+// //ExcludeMusicPropertiesL( conditions );
+// CMdEObjectCondition& cond = conditions.AddObjectConditionL(
+// EObjectConditionCompareUriBeginsWith, KDriveZ );
+//
+// IncludeToneSearchConditionL( conditions, aSearchText );
+//
+// iQuery->SetResultMode( EQueryResultModeItem );
+// iQuery->FindL();
+//
+// iQueryType = ESearchTones;
+// }
+
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::SearchVideoL
+//
+// Finds all videos with attibute that matches aFindText.
+// Searched attributes are name, artist, genre.
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::SearchVideoL( const TDesC& aSearchText )
+ {
+ LeaveIfSessionClosedL();
+ if ( iRomScanState != MMediaFileHandlerObserver::ERomScanComplete )
+ {
+
+ StartRomScaning( ESearchVideo );
+ }
+
+ CMdENamespaceDef& defNS = iSession->GetDefaultNamespaceDefL();
+ CMdEObjectDef& objectDef =
+ defNS.GetObjectDefL( MdeConstants::Video::KVideoObject );
+
+ delete iQuery;
+ iQuery = NULL;
+ iQuery = iSession->NewObjectQueryL( defNS, objectDef, this );
+
+ // set attributes that are included in query result
+ CMdEPropertyDef& songName = PropertyDefL( EAttrSongName );
+ iQuery->AddPropertyFilterL( &songName );
+
+ CMdELogicCondition& conditions = iQuery->Conditions();
+ IncludeVideoSearchConditionL( conditions, aSearchText );
+
+ iQuery->SetResultMode( EQueryResultModeItem );
+
+ if ( iVideoSearchDisabled )
+ {
+ iQuery->FindL( 0 );
+ }
+ else
+ {
+ iQuery->FindL();
+ }
+
+ iQueryType = ESearchVideo;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::SearchVideo
+//
+// -----------------------------------------------------------------------------
+//
+TInt CMediaFileHandler::SearchVideo( TAny *aObj )
+ {
+ CMediaFileHandler* handler = (CMediaFileHandler*) aObj;
+
+ TInt err = KErrNone;
+ TRAP( err, handler->SearchVideoL( handler->iSearchText ) );
+
+ if ( err != KErrNone )
+ {
+ handler->CallObserver( MMediaFileHandlerObserver::EError, err );
+ }
+
+ return 0;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::SearchTones
+//
+// -----------------------------------------------------------------------------
+//
+TInt CMediaFileHandler::SearchTones( TAny *aObj )
+ {
+ CMediaFileHandler* handler = (CMediaFileHandler*) aObj;
+
+ TInt err = KErrNone;
+ TRAP( err, handler->SearchTonesL( handler->iSearchText ) );
+
+ if ( err != KErrNone )
+ {
+ handler->CallObserver( MMediaFileHandlerObserver::EError, err );
+ }
+
+ return 0;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::ResultCount
+//
+// -----------------------------------------------------------------------------
+//
+TInt CMediaFileHandler::ResultCount()
+ {
+ if ( !iSessionOpen )
+ {
+ return 0;
+ }
+
+ return iSearchList->Count();
+ }
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::Remove
+// Remove an item from list of search reuslt
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::Remove( TInt aIndex )
+ {
+ if( aIndex >= ResultCount() )
+ {
+ // Invalid index
+ return;
+ }
+ iSearchList->Remove( aIndex );
+ }
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::UnknownArtistCount
+//
+// Returns 1 if artist has at least one music file without album attribute,
+// 0 otherwise.
+// -----------------------------------------------------------------------------
+//
+TInt CMediaFileHandler::UnknownArtistCount()
+ {
+ TInt ret = 0;
+
+ TInt err = KErrNone;
+ TRAP( err, ret = UnknownArtistCountL() );
+ if ( err != KErrNone )
+ {
+ ret = 0;
+ }
+ return ret;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::UnknownArtistCountL
+//
+// Returns 1 if artist has at least one music file without album attribute,
+// 0 otherwise.
+// -----------------------------------------------------------------------------
+//
+TInt CMediaFileHandler::UnknownArtistCountL()
+ {
+ CMdEObjectQuery* artistQuery = iArtistQuery->Query();
+ if ( !artistQuery )
+ {
+ return 0;
+ }
+
+ TInt count = artistQuery->Count();
+ for ( TInt i=0; i<count; i++ )
+ {
+ CMdEObject& object = artistQuery->Result( i );
+
+ CMdEPropertyDef& propDef =
+ CMediaFileHandler::PropertyDefL( iSession, CMediaFileHandler::EAttrAlbum );
+
+ CMdEProperty* property = NULL;
+ TInt ret = object.Property( propDef, property, 0 );
+ if ( ret == KErrNotFound )
+ {
+ return 1;
+ }
+ }
+
+ return 0;
+ }
+// -----------------------------------------------------------------------------
+// void CMediaFileHandler::StartRomScaning()
+//
+// Start rom scanning
+// -----------------------------------------------------------------------------
+//
+
+void CMediaFileHandler::StartRomScaning( TInt aQueryType )
+ {
+
+ if ( iRomScanState != MMediaFileHandlerObserver::ERomScanComplete )
+ {
+ iRomScanState = MMediaFileHandlerObserver::ERomScanInProgress;
+ iRomFileList->Reset();
+ TRAPD( err , iRomFileList->ReadRomFilesL() );
+ if ( err != KErrNone )
+ {
+ iRomScanState = MMediaFileHandlerObserver::ERomScanError;
+ }
+ else
+ {
+ iRomScanState = MMediaFileHandlerObserver::ERomScanComplete;
+ }
+ }
+
+ iSearchList->SetRomFileList( iRomFileList );
+
+ if ( iQueryinProgress )
+ {
+ QueryRomEmptyL( aQueryType );
+ }
+
+ CallObserver( MMediaFileHandlerObserver::EScanRomComplete, KErrNone );
+ }
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::CancelQuery
+//
+// Cancels ongoing query.
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::CancelQuery()
+ {
+ if ( !iSessionOpen || !iQuery )
+ {
+ return;
+ }
+
+ if ( !iQuery->IsComplete() )
+ {
+ iQuery->Cancel(); // this calls HandleQueryCompleted synchronously
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::LeaveIfSessionClosedL
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::LeaveIfSessionClosedL()
+ {
+ if ( !iSession || !iSessionOpen )
+ {
+ User::Leave( KErrDisconnected );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::SetObserver
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::SetObserver( MMediaFileHandlerObserver* aObserver )
+ {
+ iObserver = aObserver;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::CheckAttrL
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::CheckAttrL( TInt aAttr )
+ {
+ if ( aAttr != EAttrArtist && aAttr != EAttrAlbum &&
+ aAttr != EAttrGenre && aAttr != EAttrComposer )
+ {
+ User::Leave( KErrNotSupported );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::GetAttributeL
+//
+// NOTE: GetAttributeL only gets full name or file name
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::GetAttributeL( TInt aIndex, TInt aAttr,
+ TDes& aValue, TInt aQueryId )
+ {
+ aValue = KNullDesC;
+
+ if ( !iSessionOpen )
+ {
+ return;
+ }
+
+ TInt id = iSearchList->SearchId();
+ if ( id != aQueryId )
+ {
+ return; // search list and UI do not match
+ }
+
+ iSearchList->SetSession( iSession );
+ iSearchList->GetAttributeL( aIndex, aAttr, aValue );
+ }
+
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::GetAttribute
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::GetAttribute( TInt aIndex, TInt aAttr,
+ TDes& aValue, TInt aQueryId )
+ {
+ TRAP_IGNORE( GetAttributeL( aIndex, aAttr, aValue, aQueryId ) );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::Attribute
+//
+// -----------------------------------------------------------------------------
+//
+TInt CMediaFileHandler::Attribute( TInt aIndex, TInt aAttr, TInt aQueryId )
+ {
+ if ( !iSessionOpen )
+ {
+ return KErrNotFound;
+ }
+
+ TInt id = iSearchList->SearchId();
+ if ( id != aQueryId )
+ {
+ return KErrNotFound;
+ }
+
+ return iSearchList->Attribute( aIndex, aAttr );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::ItemIndex
+//
+// -----------------------------------------------------------------------------
+//
+TInt CMediaFileHandler::ItemIndex( TInt aItemId, TInt aIndex )
+ {
+ return iSearchList->ItemIndex( aItemId, aIndex );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::ItemIndex
+//
+// -----------------------------------------------------------------------------
+//
+TInt CMediaFileHandler::ItemIndex( const TDesC& aItemText, TInt aIndex )
+ {
+ return iSearchList->ItemIndex( aItemText, aIndex );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::ReadMediaFileDataL
+//
+// -----------------------------------------------------------------------------
+//
+CMediaFileData* CMediaFileHandler::ReadMediaFileDataL( TInt aId )
+ {
+ if ( !iSessionOpen )
+ {
+ User::Leave( KErrNotFound );
+ }
+
+ CMdEObject* object = iSession->GetFullObjectL( aId );
+ CleanupStack::PushL( object );
+
+ CMediaFileData* data = CMediaFileData::NewL();
+ CleanupStack::PushL( data );
+
+ data->SetAttrL( EAttrFullName, object->Uri() );
+
+ CMdEProperty* property = NULL;
+ TInt ret = object->Property( PropertyDefL( EAttrSongName ), property, 0 );
+ if ( ret != KErrNotFound )
+ {
+ data->SetAttrL( EAttrSongName, property->TextValueL() );
+ }
+
+ ret = object->Property( PropertyDefL( EAttrArtist ), property, 0 );
+ if ( ret != KErrNotFound )
+ {
+ data->SetAttrL( EAttrArtist, property->TextValueL() );
+ }
+
+ ret = object->Property( PropertyDefL( EAttrAlbum ), property, 0 );
+ if ( ret != KErrNotFound )
+ {
+ data->SetAttrL( EAttrAlbum, property->TextValueL() );
+ }
+
+ ret = object->Property( PropertyDefL( EAttrGenre ), property, 0 );
+ if ( ret != KErrNotFound )
+ {
+ data->SetAttrL( EAttrGenre, property->TextValueL() );
+ }
+
+ ret = object->Property( PropertyDefL( EAttrComposer ), property, 0 );
+ if ( ret != KErrNotFound )
+ {
+ data->SetAttrL( EAttrComposer, property->TextValueL() );
+ }
+
+ CleanupStack::Pop( data );
+ CleanupStack::PopAndDestroy( object );
+
+ return data;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::ReadMediaFileDataL
+//
+// -----------------------------------------------------------------------------
+//
+CMediaFileData* CMediaFileHandler::RomMediaFileDataL( TInt aId ,TInt aMediaType )
+ {
+ if (!iRomFileList)
+ {
+ User::Leave(KErrNotFound);
+ }
+
+ TBuf<KBufSize128> buf;
+ CMediaFileData* data = CMediaFileData::NewL();
+ CleanupStack::PushL(data);
+
+ if (aMediaType == EMediaTypeTone)
+ {
+ data->SetAttrL(EAttrFullName, iRomFileList->Item(aId, 0));
+ iRomFileList->GetRomFileName(aId, 0, buf);
+ data->SetAttrL(EAttrSongName, buf);
+ }
+
+ if (aMediaType == EMediaTypeVideo)
+ {
+ data->SetAttrL(EAttrFullName, iRomFileList->Item(aId, 1));
+ iRomFileList->GetRomFileName(aId, 1, buf);
+ data->SetAttrL(EAttrSongName, buf);
+ }
+
+ CleanupStack::Pop(data);
+
+ return data;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::PropertyDefL
+//
+// -----------------------------------------------------------------------------
+//
+CMdEPropertyDef& CMediaFileHandler::PropertyDefL( TInt aAttr )
+ {
+ return PropertyDefL( iSession, aAttr );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::PropertyDefL
+//
+// -----------------------------------------------------------------------------
+//
+CMdEPropertyDef& CMediaFileHandler::PropertyDefL( CMdESession* aSession, TInt aAttr )
+ {
+ CMdENamespaceDef& defNS = aSession->GetDefaultNamespaceDefL();
+
+ CMdEObjectDef& objectDef =
+ defNS.GetObjectDefL( MdeConstants::Audio::KAudioObject );
+
+ if ( aAttr == EAttrFileSize )
+ {
+ return objectDef.GetPropertyDefL( MdeConstants::Object::KSizeProperty );
+ }
+ else if ( aAttr == EAttrMediaType )
+ {
+ return objectDef.GetPropertyDefL( MdeConstants::Object::KItemTypeProperty );
+ }
+ else if ( aAttr == EAttrSongName || aAttr == EAttrFileName )
+ {
+ return objectDef.GetPropertyDefL( MdeConstants::Object::KTitleProperty );
+ }
+ else if ( aAttr == EAttrArtist )
+ {
+ return objectDef.GetPropertyDefL( MdeConstants::MediaObject::KArtistProperty );
+ }
+ else if ( aAttr == EAttrAlbum )
+ {
+ return objectDef.GetPropertyDefL( MdeConstants::Audio::KAlbumProperty );
+ }
+ else if ( aAttr == EAttrGenre )
+ {
+ return objectDef.GetPropertyDefL( MdeConstants::MediaObject::KGenreProperty );
+ }
+ else if ( aAttr == EAttrComposer )
+ {
+ return objectDef.GetPropertyDefL( MdeConstants::Audio::KComposerProperty );
+ }
+ else
+ {
+ User::Leave( KErrNotSupported );
+ }
+
+ return objectDef.GetPropertyDefL( MdeConstants::Object::KTitleProperty );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::QueryReady
+//
+// -----------------------------------------------------------------------------
+//
+TBool CMediaFileHandler::QueryReady()
+ {
+ if ( iIdle )
+ {
+ TBool isSearching = iIdle->IsActive();
+ if ( isSearching )
+ {
+ return EFalse; // we are between audio, tone and and video search
+ }
+ }
+
+ TBool isWaitingObserverCall = iQueryCaller->IsActive();
+ if ( isWaitingObserverCall )
+ {
+ return EFalse; // query is ready but observer not called yet
+ }
+
+ if ( iQuery )
+ {
+ return iQuery->IsComplete();
+ }
+
+ return ETrue;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::ExcludeMimeTypesL
+//
+// Exclude mime types from query.
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::ExcludeMimeTypesL( CMdELogicCondition& aCondition,
+ TInt /*aAttr*/ )
+ {
+ TInt count = iExcludedMimeTypes->Count();
+
+ if ( count == 0 )
+ {
+ return;
+ }
+
+ CMdEPropertyDef& fileTypeDef = PropertyDefL( EAttrMediaType );
+ CMdELogicCondition& condition =
+ aCondition.AddLogicConditionL( ELogicConditionOperatorAnd );
+
+ for ( TInt i=0; i<count; i++ )
+ {
+ TPtrC ptr = iExcludedMimeTypes->MimeType( i );
+ condition.AddPropertyConditionL( fileTypeDef,
+ ETextPropertyConditionCompareEquals, ptr );
+ }
+ condition.SetNegate( ETrue );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::IncludeMusicPropertiesL
+//
+// Adds properties that are used to find out whether media file is music.
+// File is considered music if:
+// 1. it has metadata artist or album or genre or composer
+// 2. its mime type is 'music' mime type (eg mp3)
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::IncludeMusicPropertiesL( CMdELogicCondition& aCondition )
+ {
+ ExcludeRomFilesL( aCondition );
+// CMdEObjectCondition& cond = aCondition.AddObjectConditionL(
+// EObjectConditionCompareUriBeginsWith, KDriveZ );
+// cond.SetNegate( ETrue );
+
+// CMdELogicCondition& condition =
+// aCondition.AddLogicConditionL( ELogicConditionOperatorAnd );
+ ExcludeRecordingsL( aCondition );
+// CMdEPropertyDef& fileTypeDef = PropertyDefL( EAttrMediaType );
+// condition.AddPropertyConditionL( fileTypeDef,
+// ETextPropertyConditionCompareContains, KMimeTypeAMR );
+// condition.AddPropertyConditionL( fileTypeDef,
+// ETextPropertyConditionCompareContains, KMimeTypeWAV );
+// condition.SetNegate( ETrue );
+ }
+
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::IncludeMusicPropertiesL
+//
+// Adds properties that are used to find out whether media file is music.
+// File is considered music if:
+// 1. it has metadata artist or album or genre or composer
+// 2. its mime type is 'music' mime type (eg mp3)
+// -----------------------------------------------------------------------------
+//
+/*
+void CMediaFileHandler::IncludeMusicPropertiesL( CMdELogicCondition& aCondition )
+ {
+ //aLogicCondition.SetOperator( ELogicConditionOperatorAnd );
+
+ CMdEPropertyDef& mimeTypeDef = PropertyDefL( EAttrMediaType );
+ CMdEPropertyDef& artistTypeDef = PropertyDefL( EAttrArtist );
+ CMdEPropertyDef& albumTypeDef = PropertyDefL( EAttrAlbum );
+ CMdEPropertyDef& genreTypeDef = PropertyDefL( EAttrGenre );
+ CMdEPropertyDef& composerTypeDef = PropertyDefL( EAttrComposer );
+
+ CMdELogicCondition& condition =
+ aCondition.AddLogicConditionL( ELogicConditionOperatorOr );
+
+ condition.AddPropertyConditionL( mimeTypeDef,
+ ETextPropertyConditionCompareContains, KMimeMp3 );
+ condition.AddPropertyConditionL( artistTypeDef );
+ condition.AddPropertyConditionL( albumTypeDef );
+ condition.AddPropertyConditionL( genreTypeDef );
+ condition.AddPropertyConditionL( composerTypeDef );
+ }
+*/
+
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::ExcludeMusicPropertiesL
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::ExcludeMusicPropertiesL( CMdELogicCondition& aCondition )
+ {
+ CMdEPropertyDef& mimeTypeDef = PropertyDefL( EAttrMediaType );
+ CMdEPropertyDef& artistTypeDef = PropertyDefL( EAttrArtist );
+ CMdEPropertyDef& albumTypeDef = PropertyDefL( EAttrAlbum );
+ CMdEPropertyDef& genreTypeDef = PropertyDefL( EAttrGenre );
+ CMdEPropertyDef& composerTypeDef = PropertyDefL( EAttrComposer );
+
+ CMdELogicCondition& condition =
+ aCondition.AddLogicConditionL( ELogicConditionOperatorAnd );
+
+ condition.AddPropertyConditionL( mimeTypeDef,
+ ETextPropertyConditionCompareContains, KMimeMp3 );
+ condition.AddPropertyConditionL( artistTypeDef );
+ condition.AddPropertyConditionL( albumTypeDef );
+ condition.AddPropertyConditionL( genreTypeDef );
+ condition.AddPropertyConditionL( composerTypeDef );
+
+ condition.SetNegate( ETrue );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::IncludeMusicSearchConditionL
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::IncludeMusicSearchConditionL( CMdELogicCondition& aCondition,
+ const TDesC& aSearchText )
+
+ {
+ _LIT( KFormat, "%S%S" );
+
+ CMdELogicCondition& condition =
+ aCondition.AddLogicConditionL( ELogicConditionOperatorOr );
+
+ CMdEPropertyDef& songName = PropertyDefL( EAttrSongName );
+ CMdEPropertyDef& artist = PropertyDefL( EAttrArtist );
+ CMdEPropertyDef& album = PropertyDefL( EAttrAlbum );
+ CMdEPropertyDef& genre = PropertyDefL( EAttrGenre );
+ CMdEPropertyDef& composer = PropertyDefL( EAttrComposer );
+
+ // first find from the start of the property
+ condition.AddPropertyConditionL( songName,
+ ETextPropertyConditionCompareBeginsWith, aSearchText );
+
+ condition.AddPropertyConditionL( artist,
+ ETextPropertyConditionCompareBeginsWith, aSearchText );
+
+
+ condition.AddPropertyConditionL( album,
+ ETextPropertyConditionCompareBeginsWith, aSearchText );
+
+
+ condition.AddPropertyConditionL( genre,
+ ETextPropertyConditionCompareBeginsWith, aSearchText );
+
+
+ condition.AddPropertyConditionL( composer,
+ ETextPropertyConditionCompareBeginsWith, aSearchText );
+
+
+ // then find from the start of property words
+ TBuf<KBufSize128> buf;
+ if ( aSearchText.Length() < KBufSize128-1 )
+ {
+ buf.Format( KFormat, &KSpace, &aSearchText );
+
+ condition.AddPropertyConditionL( songName,
+ ETextPropertyConditionCompareContains, buf );
+ condition.AddPropertyConditionL( artist,
+ ETextPropertyConditionCompareContains, buf );
+ condition.AddPropertyConditionL( album,
+ ETextPropertyConditionCompareContains, buf );
+ condition.AddPropertyConditionL( genre,
+ ETextPropertyConditionCompareContains, buf );
+ condition.AddPropertyConditionL( composer,
+ ETextPropertyConditionCompareContains, buf );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::IncludeVideoConditionL
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::IncludeVideoSearchConditionL(
+ CMdELogicCondition& aCondition, const TDesC& aSearchText )
+
+ {
+ _LIT( KFormat, "%S%S" );
+
+ CMdELogicCondition& condition =
+ aCondition.AddLogicConditionL( ELogicConditionOperatorOr );
+
+ CMdEPropertyDef& songName = PropertyDefL( EAttrSongName );
+ CMdEPropertyDef& artist = PropertyDefL( EAttrArtist );
+ CMdEPropertyDef& genre = PropertyDefL( EAttrGenre );
+
+ // first find from the start of the property
+ condition.AddPropertyConditionL( songName,
+ ETextPropertyConditionCompareBeginsWith, aSearchText );
+ condition.AddPropertyConditionL( artist,
+ ETextPropertyConditionCompareBeginsWith, aSearchText );
+ condition.AddPropertyConditionL( genre,
+ ETextPropertyConditionCompareBeginsWith, aSearchText );
+
+ // then find from the start of property words
+ TBuf<KBufSize128> buf;
+ if ( aSearchText.Length() < KBufSize128-1 )
+ {
+ buf.Format( KFormat, &KSpace, &aSearchText );
+
+ condition.AddPropertyConditionL( songName,
+ ETextPropertyConditionCompareContains, buf );
+ condition.AddPropertyConditionL( artist,
+ ETextPropertyConditionCompareContains, buf );
+ condition.AddPropertyConditionL( genre,
+ ETextPropertyConditionCompareContains, buf );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::IncludeToneSearchConditionL
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::IncludeToneSearchConditionL( CMdELogicCondition& aCondition,
+ const TDesC& aSearchText )
+
+ {
+ _LIT( KFormat, "%S%S" );
+
+ CMdELogicCondition& condition =
+ aCondition.AddLogicConditionL( ELogicConditionOperatorOr );
+
+ CMdEPropertyDef& songName = PropertyDefL( EAttrSongName );
+
+ // first find from the start of the property
+ condition.AddPropertyConditionL( songName,
+ ETextPropertyConditionCompareBeginsWith, aSearchText );
+
+ // then find from the start of property words
+ TBuf<KBufSize128> buf;
+ if ( aSearchText.Length() < KBufSize128-1 )
+ {
+ buf.Format( KFormat, &KSpace, &aSearchText );
+
+ condition.AddPropertyConditionL( songName,
+ ETextPropertyConditionCompareContains, buf );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::ExcludeRecordingsL
+//
+// Exclude recording mime types from query (.amr and .wav).
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::ExcludeRecordingsL( CMdELogicCondition& aCondition )
+ {
+ CMdEPropertyDef& mimeTypeDef = PropertyDefL( EAttrMediaType );
+ CMdELogicCondition& condition =
+ aCondition.AddLogicConditionL( ELogicConditionOperatorAnd );
+ condition.AddPropertyConditionL( mimeTypeDef,
+ ETextPropertyConditionCompareEquals, KMimeTypeAMR );
+ condition.AddPropertyConditionL( mimeTypeDef,
+ ETextPropertyConditionCompareEquals, KMimeTypeWAV );
+ condition.SetNegate( ETrue );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::ExcludeRomFilesL
+//
+// Exclude music files that are in rom (default tones).
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::ExcludeRomFilesL( CMdELogicCondition& aCondition )
+ {
+ _LIT( KDriveZ, "z:\\" );
+
+ CMdEObjectCondition& cond = aCondition.AddObjectConditionL(
+ EObjectConditionCompareUriBeginsWith, KDriveZ );
+ cond.SetNegate( ETrue );
+ }
+
+
+// -------------------------------------------------------------------------------
+// CMediaFileHandler::StrCopy
+//
+// String copy with lenght check.
+// -------------------------------------------------------------------------------
+//
+void CMediaFileHandler::StrCopy( TDes& aTarget, const TDesC& aSource )
+ {
+ TInt len = aTarget.MaxLength();
+ if( len < aSource.Length() )
+ {
+ aTarget.Copy( aSource.Left( len ) );
+ return;
+ }
+ aTarget.Copy( aSource );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::EnableObserverCall
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::EnableObserverCall( TBool aEnable )
+ {
+ iObserverCallEnabled = aEnable;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::CallObserver
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::CallObserver( TInt aEvent, TInt aError )
+ {
+ const TInt KDelay = 100; // milliseconds
+
+ if ( !iObserverCallEnabled )
+ {
+ return;
+ }
+
+ iQueryError = aError;
+ iQueryEvent = aEvent;
+
+ iQueryCaller->Start( 0, KDelay );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::CallObserverWithDelay
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::CallObserverWithDelay()
+ {
+ const TInt KOneSecond = 1000;
+
+ if ( !iObserverCallEnabled )
+ {
+ return;
+ }
+
+ iObjectNotificationCaller->Start( 1, 2*KOneSecond );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::HandleActiveCallL (from MMFActiveCallerObserver)
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::HandleActiveCallL( TInt aCallId )
+ {
+ if ( !iObserver )
+ {
+ return;
+ }
+
+ // inform observer that query is ready
+ if ( aCallId == 0 )
+ {
+ TRAP_IGNORE( iObserver->HandleMFEventL( iQueryEvent, iQueryError ) );
+ }
+
+ // inform observer that database has changed
+ if ( aCallId == 1 )
+ {
+ if ( QueryReady() )
+ {
+ TRAP_IGNORE( iObserver->HandleMFEventL( MMediaFileHandlerObserver::EMediaFileChanged, KErrNone ) );
+ }
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::SetQueryId
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::SetQueryId( TInt aId )
+ {
+ // this id is passed to CSearchList after successful database search
+ iQueryId = aId;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::Panic
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileHandler::Panic( TInt aReason )
+ {
+ _LIT( KPanicCategory, "CMediaFileHandler" );
+
+ User::Panic( KPanicCategory, aReason );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileHandler::MediaType
+//
+// -----------------------------------------------------------------------------
+//
+TInt CMediaFileHandler::MediaType( TInt aQueryType )
+ {
+ TInt mediaType = EMediaTypeMusic;
+ if ( aQueryType == EQueryVideo )
+ {
+ mediaType = EMediaTypeVideo;
+ }
+ if ( aQueryType == EQueryRecording )
+ {
+ mediaType = EMediaTypeRecording;
+ }
+ if ( aQueryType == EQueryTone )
+ {
+ mediaType = EMediaTypeTone;
+ }
+
+ return mediaType;
+ }
+
+
+
+/******************************************************************************
+ * class CSearchListItem
+ ******************************************************************************/
+
+
+// -----------------------------------------------------------------------------
+// CSearchListItem::NewL
+//
+// -----------------------------------------------------------------------------
+//
+CSearchListItem* CSearchListItem::NewLC()
+ {
+ CSearchListItem* self = new (ELeave) CSearchListItem();
+ CleanupStack::PushL( self );
+ self->ConstructL();
+
+ return self;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSearchListItem::NewL
+//
+// -----------------------------------------------------------------------------
+//
+CSearchListItem* CSearchListItem::NewL()
+ {
+ CSearchListItem* self = new (ELeave) CSearchListItem();
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+
+// -----------------------------------------------------------------------------
+// Destructor
+//
+// -----------------------------------------------------------------------------
+//
+CSearchListItem::~CSearchListItem()
+ {
+ delete iTitle;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSearchListItem::CSearchListItem
+//
+// -----------------------------------------------------------------------------
+//
+CSearchListItem::CSearchListItem()
+ {
+ iId = KErrNotFound;
+ iMediaType = KErrNotFound;
+ iStorageType = KErrNotFound;
+ iTitle = NULL;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSearchListItem::ConstructL
+//
+// -----------------------------------------------------------------------------
+//
+void CSearchListItem::ConstructL()
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CSearchListItem::SetTitleL
+//
+// -----------------------------------------------------------------------------
+//
+
+void CSearchListItem::SetTitleL( const TDesC& aText, TBool aFullName )
+ {
+ delete iTitle;
+ iTitle = NULL;
+
+ if ( aFullName )
+ {
+ TParsePtrC parse( aText );
+ iTitle = parse.Name().AllocL();
+ }
+ else
+ {
+ iTitle = aText.AllocL();
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSearchListItem::Title
+//
+// -----------------------------------------------------------------------------
+//
+
+const TDesC& CSearchListItem::Title() const
+ {
+ return *iTitle;
+ }
+
+
+
+
+/******************************************************************************
+ * class CRomFileList
+ ******************************************************************************/
+
+
+
+// -----------------------------------------------------------------------------
+// Static constructor function CRomFileList::NewL
+//
+// -----------------------------------------------------------------------------
+//
+CRomFileList* CRomFileList::NewL()
+ {
+ CRomFileList* self = new (ELeave) CRomFileList();
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+
+ return self;
+ }
+
+
+// -----------------------------------------------------------------------------
+// Destructor
+//
+// -----------------------------------------------------------------------------
+//
+CRomFileList::~CRomFileList()
+ {
+ iRomToneList.ResetAndDestroy();
+ iRomVideoList.ResetAndDestroy();
+ iList.Reset();
+ iList.Close();
+ iVedioList.Reset();
+ iVedioList.Close();
+ }
+
+
+// -----------------------------------------------------------------------------
+// CRomFileList::CRomFileList
+//
+// -----------------------------------------------------------------------------
+//
+CRomFileList::CRomFileList()
+ {
+ }
+
+
+// -----------------------------------------------------------------------------
+// CRomFileList::ConstructL
+//
+// -----------------------------------------------------------------------------
+//
+void CRomFileList::ConstructL()
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CRomFileList::RomFileItem( TInt aIndex )
+//
+// -----------------------------------------------------------------------------
+//
+TInt CRomFileList::RomFileItem( CSearchListItem* aItem, TInt aIndex)
+ {
+ if( aIndex >= 0 && aIndex < iRomToneList.Count() )
+ {
+ aItem->iId = iRomToneList[aIndex]->iId;
+ aItem->iMediaType = iRomToneList[aIndex]->iMediaType;
+ aItem->iStorageType = iRomToneList[aIndex]->iStorageType;
+ TPtrC title = iRomToneList[aIndex]->Title();
+ aItem->SetTitleL( title, EFalse );
+ return KErrNone;
+ }
+ return KErrGeneral;
+ }
+
+// -----------------------------------------------------------------------------
+// CRomFileList::RomVedioItem( TInt aIndex )
+//
+// -----------------------------------------------------------------------------
+//
+TInt CRomFileList::RomVedioItem( CSearchListItem* aItem, TInt aIndex)
+ {
+ if( aIndex >= 0 && aIndex < iRomVideoList.Count() )
+ {
+ aItem->iId = iRomVideoList[aIndex]->iId;
+ aItem->iMediaType = iRomVideoList[aIndex]->iMediaType;
+ aItem->iStorageType = iRomVideoList[aIndex]->iStorageType;
+ TPtrC title = iRomVideoList[aIndex]->Title();
+ aItem->SetTitleL( title, EFalse );
+ return KErrNone;
+ }
+ return KErrGeneral;
+ }
+// -----------------------------------------------------------------------------
+// CRomFileList::Count()
+//
+// -----------------------------------------------------------------------------
+//
+
+TInt CRomFileList::Count(TInt aType )
+ {
+ if ( aType == 0 )
+ {
+ //Tone item count
+ return iRomToneList.Count();
+ }
+ else if ( aType == 1 )
+ {
+ // Video item count()
+ return iRomVideoList.Count();
+ }
+ return KErrNotSupported;
+ }
+
+// -----------------------------------------------------------------------------
+// CRomFileList::Reset()
+//
+// -----------------------------------------------------------------------------
+//
+
+void CRomFileList::Reset()
+ {
+ iRomToneList.Reset();
+ iRomVideoList.Reset();
+ iList.Reset();
+ iVedioList.Reset();
+ }
+// -----------------------------------------------------------------------------
+// CRomFileList::ReadRomFilesL()
+//
+// -----------------------------------------------------------------------------
+//
+
+void CRomFileList::ReadRomFilesL()
+ {
+ _LIT( KFormat, "%S%S" );
+
+ iRomToneList.ResetAndDestroy();
+ iList.Reset();
+
+ iFileName.Format( KFormat, &PathInfo::RomRootPath(), &PathInfo::SoundsPath() );
+ TRAP_IGNORE( ReadDirectoryL( iFileName, iRomToneList ) );
+ TRAP_IGNORE( ReadDirectoryL( iFileName, iList ) );
+
+ iFileName.Format( KFormat, &PathInfo::RomRootPath(), &PathInfo::DigitalSoundsPath() );
+ TRAP_IGNORE( ReadDirectoryL( iFileName, iRomToneList ) );
+ TRAP_IGNORE( ReadDirectoryL( iFileName, iList ) );
+
+ iFileName.Format( KFormat, &PathInfo::RomRootPath(), &PathInfo::SimpleSoundsPath() );
+ TRAP_IGNORE( ReadDirectoryL( iFileName, iRomToneList ) );
+ TRAP_IGNORE( ReadDirectoryL( iFileName, iList ) );
+
+ TRAP_IGNORE( ReadRomVediosL() );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CRomFileList::ReadRomFilesL()
+//
+// -----------------------------------------------------------------------------
+//
+
+void CRomFileList::ReadRomVediosL()
+ {
+ _LIT( KFormat, "%S%S" );
+
+ iRomVideoList.Reset();
+ iVedioList.Reset();
+
+ iFileName.Format( KFormat, &PathInfo::RomRootPath(), &PathInfo::VideosPath() );
+ TRAP_IGNORE( ReadDirectoryL( iFileName, iRomVideoList ) );
+ TRAP_IGNORE( ReadDirectoryL( iFileName, iVedioList ) );
+
+ if ( iRomVideoList.Count() > 0 )
+ {
+ for( TInt i(0); i < iRomVideoList.Count(); i++)
+ {
+ iRomVideoList[i]->iMediaType = CMediaFileHandler::EMediaTypeVideo;
+ }
+ }
+
+ }
+
+
+// -----------------------------------------------------------------------------
+// TDesC& CRomFileList::Item( TInt aIndex )
+//
+// -----------------------------------------------------------------------------
+//
+const TDesC& CRomFileList::Item(TInt aIndex, TInt aType)
+ {
+ TInt count = 0;
+ if ( aType == 0 )
+ {
+ count = iList.Count();
+ if (aIndex >= 0 && aIndex < count)
+ {
+ return iList[aIndex];
+ }
+ }
+ else if ( aType == 1 )
+ {
+ count = iVedioList.Count();
+ if (aIndex >= 0 && aIndex < count)
+ {
+ return iVedioList[aIndex];
+ }
+ }
+ return KNullDesC;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CRomFileList::ReadDirectoryL( const TDesC& aDirectory,
+// RPointerArray<CSearchListItem>& aList )
+//
+// -----------------------------------------------------------------------------
+//
+
+void CRomFileList::ReadDirectoryL( const TDesC& aDirectory,
+ RPointerArray<CSearchListItem>& aList )
+ {
+ _LIT( KFormat, "%S%S" );
+
+ CDir* dir = NULL;
+ RFs fsSession;
+ User::LeaveIfError( fsSession.Connect() );
+ CleanupClosePushL( fsSession );
+
+ if ( !BaflUtils::FolderExists( fsSession, aDirectory ) )
+ {
+ User::Leave( KErrNotFound );
+ }
+
+ TInt err = fsSession.GetDir( aDirectory, KEntryAttNormal, ESortByName, dir );
+ User::LeaveIfError( err );
+ CleanupStack::PushL( dir );
+ TInt index;
+ TInt count = dir->Count();
+ TFileName filename;
+ for ( TInt i=0; i<count; i++ )
+ {
+ const TEntry item = (*dir)[i];
+ filename.Format( KFormat, &aDirectory, &item.iName );
+ index = aList.Count();
+ CSearchListItem* item2 = SearchListItemFromRomL( filename, index );
+ aList.AppendL( item2 );
+ }
+
+ CleanupStack::PopAndDestroy( dir );
+
+ CleanupStack::PopAndDestroy(); // fsSession
+ }
+
+// -----------------------------------------------------------------------------
+// CRomFileList::ReadDirectoryL( const TDesC& aDirectory,
+// RPointerArray<CSearchListItem>& aList )
+//
+// -----------------------------------------------------------------------------
+//
+
+void CRomFileList::ReadDirectoryL( const TDesC& aDirectory,
+ RArray<TFileName>& aList )
+ {
+ _LIT( KFormat, "%S%S" );
+
+ CDir* dir = NULL;
+ RFs fsSession;
+ User::LeaveIfError( fsSession.Connect() );
+ CleanupClosePushL( fsSession );
+
+ if ( !BaflUtils::FolderExists( fsSession, aDirectory ) )
+ {
+ User::Leave( KErrNotFound );
+ }
+
+ TInt err = fsSession.GetDir( aDirectory, KEntryAttNormal, ESortByName, dir );
+ User::LeaveIfError( err );
+ CleanupStack::PushL( dir );
+
+ TInt count = dir->Count();
+ TFileName filename;
+ for ( TInt i=0; i<count; i++ )
+ {
+ const TEntry item = (*dir)[i];
+ filename.Format( KFormat, &aDirectory, &item.iName );
+ aList.AppendL( filename );
+ }
+
+ CleanupStack::PopAndDestroy( dir );
+
+ CleanupStack::PopAndDestroy(); // fsSession
+ }
+// -----------------------------------------------------------------------------
+// CRomFileList::SearchListItemFromRomL( const TDesC& aFileName )
+//
+// -----------------------------------------------------------------------------
+//
+
+CSearchListItem* CRomFileList::SearchListItemFromRomL( const TDesC& aFileName ,TInt aIndex )
+ {
+ TParsePtrC parsedName( aFileName );
+
+ CSearchListItem* item = CSearchListItem::NewLC();
+
+ item->iId = aIndex;
+ item->SetTitleL( aFileName , ETrue);
+ item->iStorageType = CMediaFileHandler::ERomStorage;
+ item->iMediaType = CMediaFileHandler::EMediaTypeTone;
+
+ CleanupStack::Pop(); // item
+
+ return item;
+ }
+
+// -----------------------------------------------------------------------------
+// CRomFileList::GetRomFileName
+//
+// -----------------------------------------------------------------------------
+//
+TInt CRomFileList::GetRomFileName(TInt aIndex, TInt aType, TDes& aValue)
+ {
+ //return title of rom item;
+ if (aType == 0)
+ {
+ if (aIndex >= 0 && aIndex < Count(0))
+ {
+ aValue.Copy( iRomToneList[aIndex]->Title() );
+ return KErrNone;
+ }
+ return KErrGeneral;
+ }
+ else if (aType == 1)
+ {
+ if (aIndex >= 0 && aIndex < Count(1))
+ {
+ aValue.Copy(iRomVideoList[aIndex]->Title());
+ return KErrNone;
+ }
+ return KErrGeneral;
+ }
+ return KErrNotFound;
+ }
+
+
+/******************************************************************************
+ * class CSearchList
+ ******************************************************************************/
+
+
+// -----------------------------------------------------------------------------
+// CSearchList::NewL
+//
+// -----------------------------------------------------------------------------
+//
+CSearchList* CSearchList::NewL()
+ {
+ CSearchList* self = new (ELeave) CSearchList();
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+
+ return self;
+ }
+
+
+// -----------------------------------------------------------------------------
+// Destructor
+//
+// -----------------------------------------------------------------------------
+//
+CSearchList::~CSearchList()
+ {
+ iList.ResetAndDestroy();
+ delete iDriveUtil;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSearchList::CSearchList
+//
+// -----------------------------------------------------------------------------
+//
+CSearchList::CSearchList()
+ {
+ iSearchId = KErrNotFound;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSearchList::ConstructL
+//
+// -----------------------------------------------------------------------------
+//
+void CSearchList::ConstructL()
+ {
+ iDriveUtil = CDriveUtil::NewL();
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSearchList::SetSession
+//
+// -----------------------------------------------------------------------------
+//
+void CSearchList::SetSession( CMdESession* aSession )
+ {
+ iSession = aSession;
+ }
+
+// -----------------------------------------------------------------------------
+// CSearchList::SetRomFileList
+//
+// -----------------------------------------------------------------------------
+//
+void CSearchList::SetRomFileList( CRomFileList* aRomFileList )
+ {
+ iRomFileList = aRomFileList;
+ }
+
+// -----------------------------------------------------------------------------
+// CSearchList::SetSearchId
+//
+// -----------------------------------------------------------------------------
+//
+void CSearchList::SetSearchId( TInt aSearchId )
+ {
+ iSearchId = aSearchId;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSearchList::SearchId
+//
+// -----------------------------------------------------------------------------
+//
+TInt CSearchList::SearchId()
+ {
+ return iSearchId;
+ }
+
+// -----------------------------------------------------------------------------
+// CSearchList::Remove
+// Remove an item from the list of search results
+// -----------------------------------------------------------------------------
+//
+void CSearchList::Remove( TInt aIndex )
+ {
+ iList.Remove( aIndex );
+ }
+
+// -----------------------------------------------------------------------------
+// CSearchList::TakeResultL
+//
+// -----------------------------------------------------------------------------
+//
+void CSearchList::TakeResultL( CMdEObjectQuery* aQuery, TInt aMediaType )
+ {
+ if ( !aQuery )
+ {
+ return;
+ }
+ CMdEObjectQuery* query = static_cast<CMdEObjectQuery*> (aQuery);
+ TInt count = query->Count();
+
+ for (TInt i = 0; i < count; i++)
+ {
+ CMdEObject* object = (CMdEObject*) query->TakeOwnershipOfResult(i);
+ CleanupStack::PushL(object);
+ AddItemL(*object, aMediaType);
+ CleanupStack::PopAndDestroy(object);
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSearchList::SearchInToneL
+//
+// -----------------------------------------------------------------------------
+//
+void CSearchList::SearchInToneL( CRomFileList* aQuery, const TDesC& aSearchText )
+ {
+ if ( !aQuery )
+ {
+ return;
+ }
+ TInt error = KErrNone;
+ TInt count = aQuery->Count( 0 );
+ for( int i = 0; i< count; i++ )
+ {
+ CSearchListItem* item = CSearchListItem::NewL();
+ error = aQuery->RomFileItem( item, i );
+ if ( error == KErrNone )
+ {
+ TPtrC title = item->Title();
+ TInt rt = title.FindF( aSearchText );
+ if ( rt != KErrNotFound )
+ {
+ iList.AppendL( item );
+ }
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSearchList::VideoSearchInRomL
+//
+// -----------------------------------------------------------------------------
+//
+void CSearchList::VideoSearchInRomL( CRomFileList* aQuery, const TDesC& aSearchText )
+ {
+ if ( !aQuery )
+ {
+ return;
+ }
+ TInt error = KErrNone;
+ TInt count = aQuery->Count( 1 );
+ for( int i = 0; i< count; i++ )
+ {
+ CSearchListItem* item = CSearchListItem::NewL();
+ error = aQuery->RomVedioItem( item, i );
+ if ( error == KErrNone )
+ {
+ TPtrC title = item->Title();
+ TInt rt = title.FindF( aSearchText );
+ if ( rt != KErrNotFound )
+ {
+ iList.AppendL( item );
+ }
+ }
+ }
+ }
+// -----------------------------------------------------------------------------
+// CSearchList::TakeArtistResultL
+//
+// -----------------------------------------------------------------------------
+//
+void CSearchList::TakeArtistResultL( CArtistQuery* aArtistQuery )
+ {
+ if ( !aArtistQuery )
+ {
+ return;
+ }
+
+ CMdEObjectQuery* query = aArtistQuery->Query();
+ if ( !query )
+ {
+ return;
+ }
+ TInt queryType = aArtistQuery->QueryType();
+
+
+ TInt count = query->Count();
+ for ( TInt i=0; i<count; i++ )
+ {
+ CMdEObject& object = query->Result( i );
+ AddArtistItemL( object, queryType, aArtistQuery->Album() );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSearchList::TakeDistinctResultL
+//
+// -----------------------------------------------------------------------------
+//
+void CSearchList::TakeDistinctResultL( CMdEObjectQuery* aQuery,
+ TInt /*aMediaType*/ )
+ {
+ if ( !aQuery )
+ {
+ return;
+ }
+
+ TInt count = aQuery->Count();
+
+ for ( TInt i=0; i<count; i++ )
+ {
+ TPtrC ptr = aQuery->ResultDistinctValue( i );
+
+ CSearchListItem* item = CSearchListItem::NewLC();
+
+ item->SetTitleL( ptr, EFalse );
+ item->iMediaType = KErrNotFound;
+ item->iStorageType = KErrNotFound;
+
+ iList.AppendL( item );
+
+ CleanupStack::Pop( item );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSearchList::AddItemL
+//
+// -----------------------------------------------------------------------------
+//
+void CSearchList::AddItemL( CMdEObject& aObject, TInt aMediaType )
+ {
+ CSearchListItem* item = CSearchListItem::NewLC();
+
+ TPtrC songName = TextL( aObject, CMediaFileHandler::EAttrSongName );
+
+ if ( songName.Length() > 0 )
+ {
+ item->SetTitleL( songName, EFalse );
+ }
+ else
+ {
+ item->SetTitleL( aObject.Uri(), ETrue );
+ }
+
+
+ item->iId = aObject.Id();
+ item->iMediaType = aMediaType;
+
+ TInt storageType = CMediaFileHandler::EPhoneMemory;
+ if ( iDriveUtil->IsMemoryCard( aObject.Uri() ) )
+ {
+ storageType = CMediaFileHandler::EMemoryCard;
+ }
+ else if ( iDriveUtil->IsMassStorage( aObject.Uri() ) )
+ {
+ storageType = CMediaFileHandler::EMassStorage;
+ }
+ item->iStorageType = storageType;
+
+ iList.AppendL( item );
+
+ CleanupStack::Pop( item );
+ }
+
+// -----------------------------------------------------------------------------
+// CSearchList::AddRomItemL
+//
+// -----------------------------------------------------------------------------
+//
+void CSearchList::AddRomItemL( CRomFileList* aRomList, TInt aMediaType )
+ {
+ if ( !aRomList )
+ {
+ return;
+ }
+
+ TInt count =0;
+ TInt error = KErrNone;
+ if ( aMediaType == CMediaFileHandler::EMediaTypeTone )
+ {
+ count = aRomList->Count( 0 );
+ for ( TInt i=0; i< count; i++ )
+ {
+ CSearchListItem* item = CSearchListItem::NewL();
+ error = aRomList->RomFileItem( item, i );
+ if ( error == KErrNone )
+ {
+ iList.AppendL( item );
+ }
+ }
+ }
+ else if ( aMediaType == CMediaFileHandler::EMediaTypeVideo )
+ {
+ count = aRomList->Count( 1 );
+ for (TInt i = 0; i < count; i++)
+ {
+ CSearchListItem* item = CSearchListItem::NewL();
+ error = aRomList->RomVedioItem(item, i);
+ if (error == KErrNone)
+ {
+ iList.AppendL(item);
+ }
+ }
+ }
+
+ }
+
+// -----------------------------------------------------------------------------
+// CSearchList::AddAlbumItemL
+//
+// -----------------------------------------------------------------------------
+//
+void CSearchList::AddAlbumItemL( const TDesC& aAlbum )
+ {
+ TLinearOrder<CSearchListItem> sortFunction( CSearchList::Compare );
+
+ CSearchListItem* item = CSearchListItem::NewLC();
+
+ item->SetTitleL( aAlbum, EFalse );
+
+ CleanupStack::Pop( item );
+
+ item->iMediaType = KErrNotFound;
+ item->iStorageType = KErrNotFound;
+ item->iId = KErrNotFound;
+
+ TInt err = iList.InsertInOrder( item, sortFunction );
+ if ( err != KErrNone )
+ {
+ delete item;
+ }
+ if ( err != KErrNone && err != KErrAlreadyExists )
+ {
+ User::Leave( err );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSearchList::AddArtistItemL
+//
+// -----------------------------------------------------------------------------
+//
+void CSearchList::AddArtistItemL( CMdEObject& aObject,
+ TInt aQueryType, const TDesC& aAlbum )
+ {
+ // all songs for one artist
+ if ( aQueryType == CMediaFileHandler::EQueryArtistAll )
+ {
+ AddItemL( aObject, CMediaFileHandler::EMediaTypeMusic );
+ return;
+ }
+
+ TPtrC album = TextL( aObject, CMediaFileHandler::EAttrAlbum );
+
+ // unknown songs (no album metadata) for one artist
+ if ( aQueryType == CMediaFileHandler::EQueryArtistUnknown )
+ {
+ if ( album.Length() == 0 )
+ {
+ AddItemL( aObject, CMediaFileHandler::EMediaTypeMusic );
+ }
+ }
+
+ // all albums for one artist
+ if ( aQueryType == CMediaFileHandler::EQueryArtist )
+ {
+ if ( album.Length() > 0 )
+ {
+ AddAlbumItemL( album );
+ }
+ }
+
+ // songs in one album
+ if ( aQueryType == CMediaFileHandler::EQueryArtistAlbum )
+ {
+ if ( album.Length() > 0 )
+ {
+ if ( album.Compare( aAlbum ) == 0 )
+ {
+ AddItemL( aObject, CMediaFileHandler::EMediaTypeMusic );
+ }
+ }
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSearchList::Sort
+//
+// -----------------------------------------------------------------------------
+//
+void CSearchList::Sort()
+ {
+ iList.Sort( TLinearOrder<CSearchListItem>(CSearchList::Compare) );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSearchList::Reset
+//
+// -----------------------------------------------------------------------------
+//
+void CSearchList::Reset()
+ {
+ iSearchId = KErrNotFound;
+ iList.ResetAndDestroy();
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSearchList::Count
+//
+// -----------------------------------------------------------------------------
+//
+TInt CSearchList::Count()
+ {
+ return iList.Count();
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSearchList::GetAttributeL
+//
+// -----------------------------------------------------------------------------
+//
+void CSearchList::GetAttributeL( TInt aIndex, TInt aAttr, TDes& aValue )
+ {
+ aValue = KNullDesC;
+
+ if ( !iSession )
+ {
+ return;
+ }
+
+ if ( aIndex == KErrNotFound )
+ {
+ return;
+ }
+
+ TInt count = iList.Count();
+ if ( aIndex < 0 || aIndex >= count )
+ {
+ return;
+ }
+
+ if ( aAttr == CMediaFileHandler::EAttrFullName )
+ {
+ CSearchListItem* item = iList[aIndex];
+ if ( item->iStorageType == CMediaFileHandler::ERomStorage )
+ {
+ if ( item->iMediaType == CMediaFileHandler::EMediaTypeTone )
+ {
+ TPtrC name = iRomFileList->Item( item->iId , 0 );
+ TMFDialogUtil::StrCopy( aValue, name );
+ }
+
+ if ( item->iMediaType == CMediaFileHandler::EMediaTypeVideo )
+ {
+ TPtrC name = iRomFileList->Item( item->iId , 1 );
+ TMFDialogUtil::StrCopy( aValue, name );
+ }
+ }
+ else
+ {
+ CMdEObject* object = iSession->GetFullObjectL( item->iId );
+ CleanupStack::PushL( object );
+ TMFDialogUtil::StrCopy( aValue, object->Uri() );
+ CleanupStack::PopAndDestroy( object );
+ }
+ }
+
+ else if ( aAttr == CMediaFileHandler::EAttrSongName ||
+ aAttr == CMediaFileHandler::EAttrFileName )
+ {
+ CSearchListItem* item = iList[aIndex];
+ TMFDialogUtil::StrCopy( aValue, item->Title() );
+ if ( aValue.Length() == 0 )
+ {
+ if ( item->iStorageType == CMediaFileHandler::ERomStorage )
+ {
+ if ( item->iMediaType == CMediaFileHandler::EMediaTypeTone )
+ {
+ TPtrC name = iRomFileList->Item( aIndex,0 );
+ TMFDialogUtil::StrCopy( aValue, name );
+ }
+
+ if ( item->iMediaType == CMediaFileHandler::EMediaTypeVideo )
+ {
+ TPtrC name = iRomFileList->Item( aIndex,1 );
+ TMFDialogUtil::StrCopy( aValue, name );
+ }
+ }
+ else
+ {
+ CMdEObject* object = iSession->GetFullObjectL( item->iId );
+ CleanupStack::PushL( object );
+ TParsePtrC parse( object->Uri() );
+ TMFDialogUtil::StrCopy( aValue, parse.Name() );
+ CleanupStack::PopAndDestroy( object );
+ }
+ }
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSearchList::Attribute
+//
+// -----------------------------------------------------------------------------
+//
+TInt CSearchList::Attribute( TInt aIndex, TInt aAttr )
+ {
+ if ( aIndex == KErrNotFound )
+ {
+ return KErrNotFound;
+ }
+
+ TInt count = iList.Count();
+ if ( aIndex < 0 || aIndex >= count )
+ {
+ return KErrNotFound;
+ }
+
+
+ TInt ret = KErrNotFound;
+ if ( aAttr == CMediaFileHandler::EAttrMediaType )
+ {
+ CSearchListItem* item = iList[aIndex];
+ ret = item->iMediaType;
+ }
+
+ else if ( aAttr == CMediaFileHandler::EAttrStorageType )
+ {
+ CSearchListItem* item = iList[aIndex];
+ ret = item->iStorageType;
+ }
+ else if ( aAttr == CMediaFileHandler::EAttrMediaFileId )
+ {
+ CSearchListItem* item = iList[aIndex];
+ ret = item->iId;
+ }
+
+ return ret;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSearchList::Compare
+//
+// -----------------------------------------------------------------------------
+//
+TInt CSearchList::Compare( const CSearchListItem& aFirst,
+ const CSearchListItem& aSecond )
+ {
+ TPtrC first = aFirst.Title();
+ TPtrC second = aSecond.Title();
+
+ return first.Compare( second );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSearchList::Panic
+//
+// -----------------------------------------------------------------------------
+//
+void CSearchList::Panic( TInt aReason )
+ {
+ TMFDialogUtil::Panic( aReason );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSearchList::TextL
+//
+// -----------------------------------------------------------------------------
+//
+const TDesC& CSearchList::TextL( CMdEObject& aObject, TInt aId )
+ {
+ CMdEPropertyDef& propDef =
+ CMediaFileHandler::PropertyDefL( iSession, aId );
+
+ CMdEProperty* property = NULL;
+ TInt err = aObject.Property( propDef, property, 0 );
+
+ if ( err != KErrNotFound && property )
+ {
+ return property->TextValueL();
+ }
+
+ return KNullDesC;
+ }
+
+
+
+// -----------------------------------------------------------------------------
+// CSearchList::ItemIndex
+//
+// -----------------------------------------------------------------------------
+//
+TInt CSearchList::ItemIndex( TInt aId )
+ {
+ TInt count = iList.Count();
+
+ for ( TInt i=0; i<count; i++ )
+ {
+ CSearchListItem* item = iList[i];
+ if ( item->iId == aId )
+ {
+ return i;
+ }
+ }
+
+ return KErrNotFound;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSearchList::ItemIndex
+//
+// -----------------------------------------------------------------------------
+//
+TInt CSearchList::ItemIndex( const TDesC& aText )
+ {
+ TInt count = iList.Count();
+
+ for ( TInt i=0; i<count; i++ )
+ {
+ CSearchListItem* item = iList[i];
+ if ( aText.CompareF( item->Title() ) == 0 )
+ {
+ return i;
+ }
+ }
+
+
+
+ return KErrNotFound;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSearchList::ItemIndex
+//
+// -----------------------------------------------------------------------------
+//
+TInt CSearchList::ItemIndex( TInt aId, TInt aIndex )
+ {
+ TInt count = iList.Count();
+ if ( aIndex >= 0 && aIndex < count )
+ {
+ CSearchListItem* item = iList[aIndex];
+ if ( item->iId == aId )
+ {
+ return aIndex;
+ }
+ }
+
+ return ItemIndex( aId );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSearchList::ItemIndex
+//
+// -----------------------------------------------------------------------------
+//
+TInt CSearchList::ItemIndex( const TDesC& aText, TInt aIndex )
+ {
+ TInt count = iList.Count();
+ if ( aIndex >= 0 && aIndex < count )
+ {
+ CSearchListItem* item = iList[aIndex];
+ if ( aText.CompareF( item->Title() ) == 0 )
+ {
+ return aIndex;
+ }
+ }
+
+ return ItemIndex( aText );
+ }
+
+
+/******************************************************************************
+ * class CArtistQuery
+ ******************************************************************************/
+
+
+
+// -----------------------------------------------------------------------------
+// CArtistQuery::NewL
+//
+// -----------------------------------------------------------------------------
+//
+CArtistQuery* CArtistQuery::NewL()
+ {
+ CArtistQuery* self = new (ELeave) CArtistQuery();
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+
+ return self;
+ }
+
+
+// -----------------------------------------------------------------------------
+// Destructor
+//
+// -----------------------------------------------------------------------------
+//
+CArtistQuery::~CArtistQuery()
+ {
+ delete iArtist;
+ delete iAlbum;
+ delete iQuery;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CArtistQuery::CArtistQuery
+//
+// -----------------------------------------------------------------------------
+//
+CArtistQuery::CArtistQuery()
+ {
+ iQueryType = KErrNotFound;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CArtistQuery::ConstructL
+//
+// -----------------------------------------------------------------------------
+//
+void CArtistQuery::ConstructL()
+ {
+ iArtist = HBufC::NewL( 0 );
+ iAlbum = HBufC::NewL( 0 );
+ }
+
+// -----------------------------------------------------------------------------
+// CArtistQuery::SetQueryType
+//
+// -----------------------------------------------------------------------------
+//
+void CArtistQuery::SetQueryType( TInt aType )
+ {
+ iQueryType = aType;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CArtistQuery::QueryType
+//
+// -----------------------------------------------------------------------------
+//
+TInt CArtistQuery::QueryType()
+ {
+ return iQueryType;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CArtistQuery::SetQuery
+//
+// -----------------------------------------------------------------------------
+//
+void CArtistQuery::SetQuery( CMdEObjectQuery* aQuery )
+ {
+ delete iQuery;
+ iQuery = NULL;
+ iQuery = aQuery;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CArtistQuery::Query
+//
+// -----------------------------------------------------------------------------
+//
+CMdEObjectQuery* CArtistQuery::Query()
+ {
+ return iQuery;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CArtistQuery::Artist
+//
+// -----------------------------------------------------------------------------
+//
+const TDesC& CArtistQuery::Artist()
+ {
+ return *iArtist;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CArtistQuery::Album
+//
+// -----------------------------------------------------------------------------
+//
+const TDesC& CArtistQuery::Album()
+ {
+ return *iAlbum;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CArtistQuery::SetAlbumL
+//
+// -----------------------------------------------------------------------------
+//
+void CArtistQuery::SetAlbumL( const TDesC& aText )
+ {
+ delete iAlbum;
+ iAlbum = NULL;
+ iAlbum = aText.AllocL();
+ }
+
+// -----------------------------------------------------------------------------
+// CArtistQuery::SetArtistL
+//
+// -----------------------------------------------------------------------------
+//
+void CArtistQuery::SetArtistL( const TDesC& aText )
+ {
+ delete iArtist;
+ iArtist = NULL;
+ iArtist = aText.AllocL();
+ }
+
+
+// -----------------------------------------------------------------------------
+// CArtistQuery::ResetL
+//
+// -----------------------------------------------------------------------------
+//
+void CArtistQuery::ResetL()
+ {
+ iQueryType = KErrNotFound;
+
+ delete iArtist;
+ iArtist = NULL;
+
+ delete iAlbum;
+ iAlbum = NULL;
+
+ delete iQuery;
+ iQuery = NULL;
+
+ iArtist = HBufC::NewL( 0 );
+ iAlbum = HBufC::NewL( 0 );
+ }
+
+
+// End of File