/*

* 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:  mpxplaybackutilitytest blocks implementation for STIF Test Framework TestScripter.

*

*/

// [INCLUDE FILES] - do not remove

#include <e32svr.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include <mpxvideoplaybackdefs.h>

#include <mpxplaybackcommanddefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcommand.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxplaybackmessage.h>

#include <mpxmediageneraldefs.h>

#include <mpxlog.h>

#include <mpxcollectionplaylist.h>

#include "mpxplaybackutilitytest.h"

#include "mpxplaybackutilitytestdefs.h"

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

// ---------------------------------------------------------------------------

// From MMPXPlaybackObserver

// Handle playback message.

// ---------------------------------------------------------------------------

//

void Cmpxplaybackutilitytest::HandlePlaybackMessage( CMPXMessage* aMessage, TInt aError )

    if ( !aError )

        TMPXMessageId id( *(aMessage->Value<TMPXMessageId>(KMPXMessageGeneralId)) );

        TInt event( *aMessage->Value<TInt>( KMPXMessageGeneralEvent ) );

        TInt type( *aMessage->Value<TInt>( KMPXMessageGeneralType ) );

        TInt data( *aMessage->Value<TInt>( KMPXMessageGeneralData ) );

        if ( KMPXMessageGeneral == id )

            iLog->Log(_L("Cmpxplaybackutilitytest::HandlePlaybackMessage() General event = %d type = %d  value = %d"),

                         event, type, data );

            RemoveExpectedEventL( KGeneralPlaybackMsgOffset + event, type, data );

        else if ( KMPXMediaIdVideoPlayback == id )

            iLog->Log(_L("Cmpxplaybackutilitytest::HandlePlaybackMessage() Video event = %d type = %d  value = %d"),

                         event, type, data );

            RemoveExpectedEventL( KVideoPlaybackMsgOffset + event, type, data );

        else if ( KMPXMessageStif )

            iLog->Log(_L("Cmpxplaybackutilitytest::HandlePlaybackMessage() STIF event = %d type = %d  value = %d"),

                         event, type, data );

            RemoveExpectedEventL( KStifPlaybackMsgOffset + event, type, data );

        }

    }

// ---------------------------------------------------------------------------

//  Handle playback property.

// ---------------------------------------------------------------------------

//

void Cmpxplaybackutilitytest::HandlePropertyL( TMPXPlaybackProperty aProperty, TInt aValue, TInt aError )

            aProperty, aValue, aError);   

// ---------------------------------------------------------------------------

//  Method is called continously until aComplete=ETrue, signifying that 

//  it is done and there will be no more callbacks.

//  Only new items are passed each time.

// ---------------------------------------------------------------------------

//

void Cmpxplaybackutilitytest::HandleSubPlayerNamesL( TUid aPlayer, 

                                                     const MDesCArray* aSubPlayers,

                                                     TBool aComplete,

                                                     TInt aError )

// ---------------------------------------------------------------------------

//  Call back of media request.

// ---------------------------------------------------------------------------

//

void Cmpxplaybackutilitytest::HandleMediaL( const CMPXMedia& aProperties, TInt aError )

// ---------------------------------------------------------------------------

//  Handle completion of a asynchronous command.

//  Note: All clients should implement this callback.

// ---------------------------------------------------------------------------

//

void Cmpxplaybackutilitytest::HandlePlaybackCommandComplete( CMPXCommand* aCommandResult, TInt aError )

// -----------------------------------------------------------------------------

// Cmpxplaybackutilitytest::Delete

// Delete here all resources allocated and opened from test methods. 

// Called from destructor. 

// -----------------------------------------------------------------------------

//

void Cmpxplaybackutilitytest::Delete()

#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

    iFile64.Close();

#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

    iFile.Close();

    iFs.Close();

    iExpectedEventArray->ResetAndDestroy();

// -----------------------------------------------------------------------------

// Cmpxplaybackutilitytest::CreateL

// Create here all resources needed for test methods. 

// Called from ConstructL(). 

// -----------------------------------------------------------------------------

//

void Cmpxplaybackutilitytest::CreateL()

    iFs.Connect();

    iFs.ShareProtected();

    iExpectedEventArray = new (ELeave) CArrayPtrFlat<TMpxPlaybackTestEvent>( 1 );

    iCallbackError = KErrNone;

    iMPXPlaybackUtility = NULL;

// -----------------------------------------------------------------------------

// Cmpxplaybackutilitytest::AddExpectedEventL

// -----------------------------------------------------------------------------

//

void Cmpxplaybackutilitytest::AddExpectedEventL( TInt aEvent, TInt aType, TInt aData )

    iLog->Log(_L("Cmpxplaybackutilitytest::AddExpectedEventL() event = %d type = %d  value = %d"),

                 aEvent, aType, aData );

    TMpxPlaybackTestEvent* event = new (ELeave) TMpxPlaybackTestEvent;

    event->iEvent = aEvent;

    event->iType = aType;

    event->iData = aData;

    iExpectedEventArray->AppendL( event );

// -----------------------------------------------------------------------------

// Cmpxplaybackutilitytest::RemoveExpectedEventL

// -----------------------------------------------------------------------------

//

void Cmpxplaybackutilitytest::RemoveExpectedEventL( TInt aEvent, TInt aType, TInt aData )

    iLog->Log(_L("Cmpxplaybackutilitytest::RemoveExpectedEventL() event = %d type = %d  value = %d"),

                 aEvent, aType, aData );

    if ( (iExpectedEventArray->Count() > 0) &&

        iLog->Log(_L("Cmpxplaybackutilitytest::RemoveExpectedEventL() event = %d removed."), aEvent);

        iExpectedEventArray->Delete( 0 );

    }

// -----------------------------------------------------------------------------

// Cmpxplaybackutilitytest::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

// -----------------------------------------------------------------------------

//

TInt Cmpxplaybackutilitytest::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. 

        //ADD NEW ENTRY HERE

        // [test cases entries] - Do not remove

        ENTRY( "MMPXPlaybackUtilityNewL", Cmpxplaybackutilitytest::MMPXPlaybackUtilityNewL ),

        ENTRY( "MMPXPlaybackUtilityNewWithCatL", Cmpxplaybackutilitytest::MMPXPlaybackUtilityNewWithCatL ),

        ENTRY( "MMPXPlaybackUtilityUtilityL", Cmpxplaybackutilitytest::MMPXPlaybackUtilityUtilityL ),

        ENTRY( "MMPXPlaybackUtilityUtilityWithCatL", Cmpxplaybackutilitytest::MMPXPlaybackUtilityUtilityWithCatL ),

        ENTRY( "MMPXPlaybackUtilityInitWithPlaylistL", Cmpxplaybackutilitytest::MMPXPlaybackUtilityInitWithPlaylistL ),

        ENTRY( "MMPXPlaybackUtilityInitWithUriL", Cmpxplaybackutilitytest::MMPXPlaybackUtilityInitWithUriL ),

        ENTRY( "MMPXPlaybackUtilityInitWithRFileL", Cmpxplaybackutilitytest::MMPXPlaybackUtilityInitWithRFileL ),

        ENTRY( "MMPXPlaybackUtilityInitStreamingWithUriL", Cmpxplaybackutilitytest::MMPXPlaybackUtilityInitStreamingWithUriL ),

        ENTRY( "MMPXPlaybackUtilityInitStreamingWithRFileL", Cmpxplaybackutilitytest::MMPXPlaybackUtilityInitStreamingWithRFileL ),

        ENTRY( "MMPXPlaybackUtilityInit64L", Cmpxplaybackutilitytest::MMPXPlaybackUtilityInit64L ),

        ENTRY( "MMPXPlaybackUtilityInitStreaming64L", Cmpxplaybackutilitytest::MMPXPlaybackUtilityInitStreaming64L ),

        ENTRY( "MMPXPlaybackUtilityFile64L", Cmpxplaybackutilitytest::MMPXPlaybackUtilityFile64L ),

        ENTRY( "MMPXPlaybackUtilityAddObserverL", Cmpxplaybackutilitytest::MMPXPlaybackUtilityAddObserverL ),

        ENTRY( "MMPXPlaybackUtilityRemoveObserverL", Cmpxplaybackutilitytest::MMPXPlaybackUtilityRemoveObserverL ),

        ENTRY( "MMPXPlaybackUtilityPlayerManagerSelectPlayerL", Cmpxplaybackutilitytest::MMPXPlaybackUtilityPlayerManagerSelectPlayerL ),

        ENTRY( "EndTest", Cmpxplaybackutilitytest::EndTest ),

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

// -----------------------------------------------------------------------------

// Cmpxplaybackutilitytest::MMPXPlaybackUtilityNewL

// NewL test method function.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt Cmpxplaybackutilitytest::MMPXPlaybackUtilityNewL( CStifItemParser& aItem )

	TInt err = KErrNone;

    TInt mode;

    if ( aItem.GetNextInt(mode) != KErrNone )

        iLog->Log(_L("MMPXPlaybackUtilityNewL - Missing playback mode."));

        err = KErrArgument;

        return err;

	TRAP( err,iMPXPlaybackUtility = MMPXPlaybackUtility::NewL(TUid::Uid(mode), this ));

	if (err!= KErrNone)

	return err;

// -----------------------------------------------------------------------------

// Cmpxplaybackutilitytest::MMPXPlaybackUtilityNewWithCatL

// NewL test method function.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt Cmpxplaybackutilitytest::MMPXPlaybackUtilityNewWithCatL( CStifItemParser& aItem )

    iLog->Log(_L("Cmpxplaybackutilitytest::MMPXPlaybackUtilityNewWithCatL"));

    TInt err = KErrNone;

    TInt mode;

    TInt category;

    if ( aItem.GetNextInt(category) != KErrNone )

        iLog->Log(_L("MMPXPlaybackUtilityNewWithCatL - Missing category."));

        err = KErrArgument;

        return err;

    if ( aItem.GetNextInt(mode) != KErrNone )

        iLog->Log(_L("MMPXPlaybackUtilityNewWithCatL - Missing playback mode."));

        err = KErrArgument;

        return err;

    TRAP( err,iMPXPlaybackUtility = MMPXPlaybackUtility::NewL((TMPXCategory)category, TUid::Uid(mode), this ));

    if (err!= KErrNone)

    }

// -----------------------------------------------------------------------------

// Cmpxplaybackutilitytest::MMPXPlaybackUtilityUtilityL

// UtilityL test method function.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt Cmpxplaybackutilitytest::MMPXPlaybackUtilityUtilityL( CStifItemParser& aItem )

    iLog->Log(_L("Cmpxplaybackutilitytest::MMPXPlaybackUtilityUtilityL"));

	TInt err = KErrNone;

	TInt mode = 0;

	aItem.GetNextInt(mode);

	if ( mode )

	    TRAP(err,iMPXPlaybackUtility = MMPXPlaybackUtility::UtilityL(TUid::Uid(mode)));

	else

        TRAP(err,iMPXPlaybackUtility = MMPXPlaybackUtility::UtilityL());

	return err;

// -----------------------------------------------------------------------------

// Cmpxplaybackutilitytest::MMPXPlaybackUtilityUtilityWithCatL

// UtilityL test method function.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt Cmpxplaybackutilitytest::MMPXPlaybackUtilityUtilityWithCatL( CStifItemParser& aItem )

    iLog->Log(_L("Cmpxplaybackutilitytest::MMPXPlaybackUtilityUtilityWithCatL"));

    TInt err = KErrNone;

    TInt category;

    TInt mode = 0;

    if ( aItem.GetNextInt(category) != KErrNone )

        iLog->Log(_L("MMPXPlaybackUtilityNewWithCatL - Missing category."));

        err = KErrArgument;

        return err;

    aItem.GetNextInt(mode);

    if ( mode )

        TRAP(err,iMPXPlaybackUtility = MMPXPlaybackUtility::UtilityL((TMPXCategory)category, TUid::Uid(mode)));

    else

        TRAP(err,iMPXPlaybackUtility = MMPXPlaybackUtility::UtilityL((TMPXCategory)category));

    return err;

// -----------------------------------------------------------------------------

// Cmpxplaybackutilitytest::MMPXPlaybackUtilityInitWithPlaylistL

// InitL(CMPXCollectionPlaylist) test method function.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt Cmpxplaybackutilitytest::MMPXPlaybackUtilityInitWithPlaylistL( CStifItemParser& /*aItem*/ )

    iLog->Log(_L("Cmpxplaybackutilitytest::MMPXPlaybackUtilityInitWithPlaylistL"));

    TInt err = KErrNone;

    CMPXCollectionPlaylist* playlist = CMPXCollectionPlaylist::NewL();

    CleanupStack::PushL(playlist);

    TRAP(err,iMPXPlaybackUtility->InitL(*playlist));

    CleanupStack::PopAndDestroy(playlist);

    iLog->Log(_L("Cmpxplaybackutilitytest::MMPXPlaybackUtilityInitWithPlaylistL - error=%d"),err);

    return err;

// -----------------------------------------------------------------------------

// Cmpxplaybackutilitytest::MMPXPlaybackUtilityInitWithUriL

// InitL(Uri) test method function.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt Cmpxplaybackutilitytest::MMPXPlaybackUtilityInitWithUriL( CStifItemParser& aItem )

    iLog->Log(_L("Cmpxplaybackutilitytest::MMPXPlaybackUtilityInitWithUriL"));

    TPtrC string;

    if( aItem.GetNextString( string ) == KErrNone )

        uri.Append(KmpxplaybackutilityTestFilePath);

        uri.Append(string);

        iLog->Log(_L("Cmpxplaybackutilitytest::MMPXPlaybackUtilityInitWithUriL - uri = %S."), &uri);

        TRAP(err,iMPXPlaybackUtility->InitL(uri));

        if ( !err )

            TInt event = KGeneralPlaybackMsgOffset + TMPXPlaybackMessage::EPlayerChanged;

            AddExpectedEventL(event, 0, 0);

            event = KGeneralPlaybackMsgOffset + TMPXPlaybackMessage::EInitializeComplete;

            AddExpectedEventL(event, 0, 0);

            }

        }

    else

        iLog->Log(_L("MMPXPlaybackUtilityInitWithUriL - Missing file name."));

        err = KErrArgument;

    }

// -----------------------------------------------------------------------------

// Cmpxplaybackutilitytest::MMPXPlaybackUtilityInitWithRFileL

// Init64L test method function.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt Cmpxplaybackutilitytest::MMPXPlaybackUtilityInitWithRFileL( CStifItemParser& aItem )

    iLog->Log(_L("Cmpxplaybackutilitytest::MMPXPlaybackUtilityInitWithRFileL"));

    TInt err = KErrNone;

    TPtrC string;

    if( aItem.GetNextString( string ) == KErrNone )

        TBuf<120> KFrom;

        KFrom.Append(KmpxplaybackutilityTestFilePath);

        KFrom.Append(string);

        if ( iFile.SubSessionHandle() )

            iFile.Close();

        err = iFile.Open(iFs, KFrom, EFileRead | EFileShareReadersOrWriters);

        if ( err == KErrNone )

            iLog->Log(_L("Cmpxplaybackutilitytest::MMPXPlaybackUtilityInitWithRFileL - Open passed."));

            TRAP(err,iMPXPlaybackUtility->InitL(iFile));

            if ( !err )

                TInt event = KGeneralPlaybackMsgOffset + TMPXPlaybackMessage::EPlayerChanged;

                AddExpectedEventL(event, 0, 0);

                event = KGeneralPlaybackMsgOffset + TMPXPlaybackMessage::EInitializeComplete;

                AddExpectedEventL(event, 0, 0);

                }

            }

        }

    else

        iLog->Log(_L("MMPXPlaybackUtilityInitWithRFileL - Missing file name."));

        err = KErrArgument;

    return err;

// -----------------------------------------------------------------------------

// Cmpxplaybackutilitytest::MMPXPlaybackUtilityInitStreamingWithUriL

// InitStreamingL(Uri) test method function.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt Cmpxplaybackutilitytest::MMPXPlaybackUtilityInitStreamingWithUriL( CStifItemParser& aItem )

    iLog->Log(_L("Cmpxplaybackutilitytest::MMPXPlaybackUtilityInitStreamingWithUriL"));

    TInt err = KErrNone;

    TPtrC string;

    TInt accessPoint = 1;

    if( aItem.GetNextString( string ) == KErrNone )

        TBuf<120> uri;

        uri.Append(KmpxplaybackutilityTestFilePath);

        uri.Append(string);

        iLog->Log(_L("Cmpxplaybackutilitytest::MMPXPlaybackUtilityInitStreamingWithUriL - uri = %S."), &uri);

        TRAP(err,iMPXPlaybackUtility->InitStreamingL(uri, NULL, accessPoint));

        if ( !err )

            TInt event = KGeneralPlaybackMsgOffset + TMPXPlaybackMessage::EPlayerChanged;

            AddExpectedEventL(event, 0, 0);

            event = KGeneralPlaybackMsgOffset + TMPXPlaybackMessage::EInitializeComplete;

            AddExpectedEventL(event, 0, 0);

            }

        }