profilesservices/MediaFileList/Src/mediafilehandler.cpp
branchRCL_3
changeset 54 7e0eff37aedb
child 57 e78c61e77b1a
--- /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