/*
* Copyright (c) 2002 - 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:  Scripted STIF cases for MPXCollectionHelper
*
*/

// INCLUDE FILES
#include <e32svr.h>
#include <StifParser.h>
#include <Stiftestinterface.h>
#include "collectionhelpertest.h"
#include <mpxmessagegeneraldefs.h>
#include <mpxmediageneraldefs.h>
#include <mpxmediaaudiodefs.h>
#include <mpxmediamusicdefs.h>
#include <mpxmediadrmdefs.h>
#include <mpxmediaarray.h>
#include <mpxmediacontainerdefs.h>
#include <mpxattribute.h>


// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CCollectionHelperTest::Delete
// Delete here all resources allocated and opened from test methods. 
// Called from destructor. 
// -----------------------------------------------------------------------------
//
void CCollectionHelperTest::Delete() 
    {
    FTRACE(FPrint(_L("CTunerUtilityTest::Delete")));
    
    iExpectedEvents.Close();
    iOcurredEvents.Close();
    
    iLog->Log(_L("Deleting test class..."));
	iLog->Log(_L(""));
	iLog->Log(_L(""));
    
    if(iUIHelper)
   		{
        //delete iUIHelper;
        iUIHelper = NULL;
 	  	}
    if(iHelper)
   		{
        //delete iHelper;
        iHelper = NULL;
   		}
    if(iCachedHelper)
   		{
        //delete iCachedHelper;
        iCachedHelper = NULL;
   		}
    }

// -----------------------------------------------------------------------------
// CCollectionHelperTest::RunMethodL
// Run specified method. Contains also table of test mothods and their names.
// -----------------------------------------------------------------------------
//
TInt CCollectionHelperTest::RunMethodL( CStifItemParser& aItem ) 
    {
    
    static TStifFunctionInfo const KFunctions[] =
        {  
        // Copy this line for every implemented function.
        // First string is the function name used in TestScripter script file.
        // Second is the actual implementation member function. 
             
        ENTRY( "OpenCollectionUtility", CCollectionHelperTest::OpenCollectionUtilityL ),
        ENTRY( "NewUiHelper", CCollectionHelperTest::NewUiHelperL ),
        ENTRY( "NewHelper", CCollectionHelperTest::NewHelperL ),
        ENTRY( "NewCachedHelper", CCollectionHelperTest::NewCachedHelperL ),
        ENTRY( "CloseUiHelper", CCollectionHelperTest::CloseUiHelperL ),
        ENTRY( "CloseHelper", CCollectionHelperTest::CloseHelperL ),
        ENTRY( "CloseCachedHelper", CCollectionHelperTest::CloseCachedHelperL ),        
        ENTRY( "AddFile", CCollectionHelperTest::AddFileL),
        ENTRY( "AddMedia", CCollectionHelperTest::AddMediaL ),
        ENTRY( "RemoveFile", CCollectionHelperTest::RemoveFileL ),
        ENTRY( "RemoveAll", CCollectionHelperTest::RemoveAllL ),
        ENTRY( "CleanupDeletedMedias", CCollectionHelperTest::CleanupDeletedMediasL ),
        ENTRY( "SetMedia", CCollectionHelperTest::SetMediaL ),
        ENTRY( "RenameUri", CCollectionHelperTest::RenameUriL ),
        ENTRY( "GetFile", CCollectionHelperTest::GetFileL ),
        ENTRY( "GetFile2", CCollectionHelperTest::GetFile2L ),
        ENTRY( "FindAll", CCollectionHelperTest::FindAllL ),
        //ADD NEW ENTRY HERE
        // [test cases entries] - Do not remove
        };

    const TInt count = sizeof( KFunctions ) / 
                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );
    
    }

TInt CCollectionHelperTest::OpenCollectionUtilityL(CStifItemParser& /*aItem*/)
	{    
	FTRACE(FPrint(_L("CCollectionHelperTest::OpenCollectionUtilityL")));
	iLog->Log(_L("CCollectionHelperTest::OpenCollectionUtilityL"));
		
    TRAPD( result, iCollectionUtility->Collection().OpenL() );
    
	if( KErrNone == result )
		{		
		AddExpectedEvent( EColHandleCollectionMessage, KMediumTimeout );
		AddExpectedEvent( EColHandleOpen, KMediumTimeout );
		}
	
	return result;
    }    
	    	
	    	
TInt CCollectionHelperTest::NewUiHelperL(CStifItemParser& /*aItem*/)
	{
	FTRACE(FPrint(_L("CCollectionHelperTest::NewUiHelperL")));
	iLog->Log(_L("CCollectionHelperTest::NewUiHelperL"));

	TRAPD( result, 
	       iUIHelper = CMPXCollectionHelperFactory::NewCollectionUiHelperL() ); 

	return result;
    }    

		
TInt CCollectionHelperTest::NewHelperL(CStifItemParser& /*aItem*/)
	{
	FTRACE(FPrint(_L("CCollectionHelperTest::NewHelperL")));
	iLog->Log(_L("CCollectionHelperTest::NewHelperL"));

	TRAPD( result, 
	       iHelper = CMPXCollectionHelperFactory::NewCollectionHelperL() ); 

	return result;
	}

TInt CCollectionHelperTest::NewCachedHelperL(CStifItemParser& /*aItem*/)
	{
	FTRACE(FPrint(_L("CCollectionHelperTest::NewCachedHelperL")));
	iLog->Log(_L("CCollectionHelperTest::NewCachedHelperL"));

	TRAPD( result, 
	       iCachedHelper = 
               CMPXCollectionHelperFactory::NewCollectionCachedHelperL() ); 

	return result;
	}

TInt CCollectionHelperTest::CloseUiHelperL(CStifItemParser& /*aItem*/)
	{
	FTRACE(FPrint(_L("CCollectionHelperTest::CloseUiHelperL")));
	iLog->Log(_L("CCollectionHelperTest::CloseUiHelperL"));

	TRAPD( result, iUIHelper->Close() ); 

	return result;
	}
	
TInt CCollectionHelperTest::CloseHelperL(CStifItemParser& /*aItem*/)
	{
	FTRACE(FPrint(_L("CCollectionHelperTest::CloseHelperL")));
	iLog->Log(_L("CCollectionHelperTest::CloseHelperL"));
	
	TRAPD( result, iHelper->Close() ); 

	return result;
	}
	
TInt CCollectionHelperTest::CloseCachedHelperL(CStifItemParser& /*aItem*/)
	{
	FTRACE(FPrint(_L("CCollectionHelperTest::CloseCachedHelperL")));
	iLog->Log(_L("CCollectionHelperTest::CloseCachedHelperL"));

	TRAPD( result, iCachedHelper->Close() ); 

	return result;
	}
			
TInt CCollectionHelperTest::AddFileL(CStifItemParser& /*aItem*/)
	{
	FTRACE(FPrint(_L("CCollectionHelperTest::AddFileL")));	
	iLog->Log(_L("CCollectionHelperTest::AddFileL"));
	
	TRAPD( result, iHelper->AddL( KTestFile, this ) );
	
	if( KErrNone == result )
		{		
		AddExpectedEvent( EColHandleAddFileComplete, KMediumTimeout );
		}
	
	return result;
	}
	
TInt CCollectionHelperTest::AddMediaL(CStifItemParser& /*aItem*/)
	{
	FTRACE(FPrint(_L("CCollectionHelperTest::AddMediaL")));
	iLog->Log(_L("CCollectionHelperTest::AddMediaL"));
    	  	
    CMPXMedia* media( NULL );
	CreateTestMediaL( media );
    CleanupStack::PushL( media );

    TRAPD( result, iHelper->AddL( media ) );
		    
    CleanupStack::PopAndDestroy( media );    	
    
	return result; 
	};

TInt CCollectionHelperTest::RemoveFileL(CStifItemParser& /*aItem*/)
	{
	FTRACE(FPrint(_L("CCollectionHelperTest::RemoveFileL")));
	iLog->Log(_L("CCollectionHelperTest::RemoveFileL"));
    TRAPD( result, iHelper->RemoveL( KTestFile ) );
    
	//if( KErrNone == result )
	//	{		
	//	AddExpectedEvent( EHandleRemove, KMediumTimeout );
	//	}
		
	return result;
	}

TInt CCollectionHelperTest::RemoveAllL(CStifItemParser& /*aItem*/)
	{
	FTRACE(FPrint(_L("CCollectionHelperTest::RemoveAllL")));
	iLog->Log(_L("CCollectionHelperTest::RemoveAllL"));
    
    TRAPD( result, iHelper->RemoveAllL() );
    
    //if( KErrNone == result )
	//	{		
	//	AddExpectedEvent( EHandleRemove, KMediumTimeout );
	//	}
		
	return result;
	}

TInt CCollectionHelperTest::CleanupDeletedMediasL(CStifItemParser& /*aItem*/)
	{
	FTRACE(FPrint(_L("CCollectionHelperTest::CleanupDeletedMediasL")));
	iLog->Log(_L("CCollectionHelperTest::CleanupDeletedMediasL"));
	
    TRAPD( result, iHelper->CleanupDeletedMediasL() );  
      
    // This method is unsupported.
    result = (result == KErrNotSupported) ? KErrNone : result;
	return result;
	}

TInt CCollectionHelperTest::SetMediaL(CStifItemParser& /*aItem*/)
	{
	FTRACE(FPrint(_L("CCollectionHelperTest::SetMediaL")));
	iLog->Log(_L("CCollectionHelperTest::SetMediaL"));
    	
    CMPXMedia* media( NULL );
	CreateTestMediaL( media );
    CleanupStack::PushL( media );

    TRAPD( result, iHelper->SetL( media ) );
		    
    CleanupStack::PopAndDestroy( media );           	
		
	return result;
	}

TInt CCollectionHelperTest::RenameUriL(CStifItemParser& /*aItem*/)
	{
	FTRACE(FPrint(_L("CCollectionHelperTest::RenameUriL")));
	iLog->Log(_L("CCollectionHelperTest::RenameUriL"));
    	
    TRAPD( result, iHelper->RenameL( KRenameOldUri,KRenameNewUri ) );
		
    return result;
	}

TInt CCollectionHelperTest::GetFileL(CStifItemParser& /*aItem*/)
	{
	FTRACE(FPrint(_L("CCollectionHelperTest::GetFileL")));
	iLog->Log(_L("CCollectionHelperTest::GetFileL"));
    	
    RArray<TMPXAttribute> attrs;
    CleanupClosePushL( attrs );
    
    CMPXMedia* theFile = NULL;
	TRAPD( result, theFile = iHelper->GetL( KTestFile, attrs.Array() ) );
	if(theFile)
		{
		delete theFile;
		}
	
	CleanupStack::PopAndDestroy( &attrs );   // attrs
		
    return result;
	}
	
TInt CCollectionHelperTest::GetFile2L(CStifItemParser& /*aItem*/)
	{
	FTRACE(FPrint(_L("CCollectionHelperTest::GetFile2L")));
	iLog->Log(_L("CCollectionHelperTest::GetFile2L"));
	
	TRAPD( result, const CMPXMedia& theFile = iHelper->GetL( KTestFile ) );
		
	// This method is unsupported.
	result = (result == KErrNotSupported) ? KErrNone : result;		
    return result;
	}

TInt CCollectionHelperTest::FindAllL(CStifItemParser& /*aItem*/)
	{	
	FTRACE(FPrint(_L("CCollectionHelperTest::FindAllL")));
	iLog->Log(_L("CCollectionHelperTest::FindAllL"));
    
    RArray<TMPXAttribute> attrs;
    CleanupClosePushL( attrs );
    
    CMPXMedia* media( NULL );
	CreateTestMediaL( media );
    CleanupStack::PushL( media );
    
    CMPXMedia* allMedia = NULL;
	TRAPD( result, allMedia = iHelper->FindAllL( *media, attrs.Array() ) );
	if(allMedia)
		{
		delete allMedia;
		}
			
	CleanupStack::PopAndDestroy( media );
	CleanupStack::PopAndDestroy( &attrs );   // attrs
			
    return result;
	}

void CCollectionHelperTest::CreateTestMediaL( CMPXMedia*& aNewProperty )
    {
    RArray<TInt> contentIDs;
    contentIDs.AppendL( KMPXMediaIdGeneral );
    contentIDs.AppendL( KMPXMediaIdAudio );
    contentIDs.AppendL( KMPXMediaIdMusic );
    contentIDs.AppendL( KMPXMediaIdDrm ); 
            
    aNewProperty = NULL;
    CMPXMedia* media = CMPXMedia::NewL( contentIDs.Array() );
    CleanupStack::PushL( media );
    contentIDs.Close();
    
    // CMPXMedia default types    
    media->SetTObjectValueL<TMPXGeneralType>( KMPXMediaGeneralType, 
                                              EMPXItem );
    media->SetTObjectValueL<TMPXGeneralCategory>( KMPXMediaGeneralCategory, 
                                                  EMPXSong );
    media->SetTextValueL( KMPXMediaGeneralUri, KTestFile() );
    
    // Title, default is file name
    media->SetTextValueL( KMPXMediaGeneralTitle, KTestFile() );
    
    // Default album track
    media->SetTextValueL( KMPXMediaMusicAlbumTrack, KNullDesC );
    
    // Set the Mime Type and collection UID
    media->SetTextValueL( KMPXMediaGeneralMimeType, KTestFileMimeType() );
    //media->SetTObjectValueL( KMPXMediaGeneralCollectionId, );

    // Set the pointers now that the object is ready
    CleanupStack::Pop( media );
    aNewProperty = media;
    }  
    
// ---------------------------------------------------------------------------
// Handle collection message
// ---------------------------------------------------------------------------
//
void CCollectionHelperTest::HandleCollectionMessageL(const CMPXMessage& aMsg)
    {
	FTRACE(FPrint(_L("CCollectionHelperTest::HandleCollectionMessageL")));
	iLog->Log(_L("CCollectionHelperTest::HandleCollectionMessageL"));
	
	if( aMsg.IsSupported(KMPXMessageGeneralEvent) &&
        aMsg.IsSupported(KMPXMessageGeneralType) )         
        {
        TMPXCollectionMessage::TEvent event = 
        *aMsg.Value<TMPXCollectionMessage::TEvent>( KMPXMessageGeneralEvent );
        TInt type = *aMsg.Value<TInt>( KMPXMessageGeneralType );
        TInt data = *aMsg.Value<TInt>( KMPXMessageGeneralData );
        
        TMPXCollectionMessage message(event, type, data);
	    if(message.Event() == TMPXCollectionMessage::EPathChanged && 
	       message.Type() == EMcPathChangedByOpen)
        	{
        	iCollectionUtility->Collection().OpenL();
        	
        	this->ProcessEvent(EColHandleCollectionMessage, KErrNone);
        	}	
        }
    }

// ---------------------------------------------------------------------------
//  Handles the collection entries being opened. Typically called
//  when client has Open()'d a folder
// ---------------------------------------------------------------------------
//
void CCollectionHelperTest::HandleOpenL(const CMPXMedia& /*aEntries*/,
                                  TInt /*aIndex*/, TBool aComplete,TInt aError)
    {
	FTRACE(FPrint(_L("CCollectionHelperTest::HandleOpenL")));
	iLog->Log(_L("CCollectionHelperTest::HandleOpenL"));
	
	this->ProcessEvent(EColHandleOpen, aError);
    }
                     
// ---------------------------------------------------------------------------
// Handles the item being opened. Typically called
// when client has Open()'d an item. Client typically responds by
// 'playing' the item via the playlist
// ---------------------------------------------------------------------------
void CCollectionHelperTest::HandleOpenL(
        const CMPXCollectionPlaylist& /*aPlaylist*/, TInt /*aError*/)
    {
	FTRACE(FPrint(_L("CCollectionHelperTest::HandleOpenL")));
	iLog->Log(_L("CCollectionHelperTest::HandleOpenL"));
    }

// ---------------------------------------------------------------------------
// Handle completion of a asynchronous command
// ---------------------------------------------------------------------------
void CCollectionHelperTest::HandleCommandComplete(
        CMPXCommand* /*aCommandResult*/, TInt /*aError*/)
    {
	FTRACE(FPrint(_L("CCollectionHelperTest::HandleCommandComplete")));
	iLog->Log(_L("CCollectionHelperTest::HandleCommandComplete"));
	
	Signal();
	iTimeoutController->Cancel();
    }
    
// ---------------------------------------------------------------------------
//  Handle extended media properties
// ---------------------------------------------------------------------------
//
void CCollectionHelperTest::HandleCollectionMediaL(const CMPXMedia& /*aMedia*/, 
                                             TInt /*aError*/)
    {
	FTRACE(FPrint(_L("CCollectionHelperTest::HandleCollectionMediaL")));
	iLog->Log(_L("CCollectionHelperTest::HandleCollectionMediaL"));
	
	Signal();
	iTimeoutController->Cancel();
    }

// ---------------------------------------------------------------------------
//  Handles removing a collection path
// ---------------------------------------------------------------------------
//
void CCollectionHelperTest::HandleRemoveL(MDesCArray& /*aUriArray*/, TInt aError)
    {
	FTRACE(FPrint(_L("CCollectionHelperTest::HandleRemoveL")));
	iLog->Log(_L("CCollectionHelperTest::HandleRemoveL"));
	
	this->ProcessEvent(EColHandleRemove, aError);
    }

// ---------------------------------------------------------------------------
//  Handle callback for "find" operation
// ---------------------------------------------------------------------------
//
void CCollectionHelperTest::HandleFindAllL(const CMPXMedia& /*aResults*/, 
        TBool aComplete, TInt aError)
    {
	FTRACE(FPrint(_L("CCollectionHelperTest::HandleFindAllL")));
	iLog->Log(_L("CCollectionHelperTest::HandleFindAllL"));
	
	if(aComplete)
		{
		this->ProcessEvent(EColHandleFindAllComplete, aError);
		}
		else 
		{
		this->ProcessEvent(EColHandleFindAllComplete, KErrGeneral );
		}	
    }
   

void CCollectionHelperTest::HandleAddFileCompleteL( TInt aErr )
	{
	FTRACE(FPrint(_L("CCollectionHelperTest::HandleAddFileCompleteL")));
	iLog->Log(_L("CCollectionHelperTest::HandleAddFileCompleteL"));
	
	this->ProcessEvent(EColHandleAddFileComplete, aErr);
	}

void CCollectionHelperTest::HandleOperationCompleteL( 
		TCHelperOperation /*aOperation*/, TInt /*aErr*/, void* /*aArgument*/ )
    {
	FTRACE(FPrint(_L("CCollectionHelperTest::HandleOperationCompleteL")));
	iLog->Log(_L("CCollectionHelperTest::HandleOperationCompleteL"));
	
	Signal();
	iTimeoutController->Cancel();
	}      
	                                 
void CCollectionHelperTest::HandleEmbeddedOpenL( 
		TInt /*aErr*/, TMPXGeneralCategory /*aCategory*/ )
    {
	FTRACE(FPrint(_L("CCollectionHelperTest::HandleEmbeddedOpenL")));
	iLog->Log(_L("CCollectionHelperTest::HandleEmbeddedOpenL"));
	
	Signal();
	iTimeoutController->Cancel();
	}