/*

* Copyright (c) 2009 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:  mpxvideoplayerappuiengine test class for STIF testing

*

*/

// Version : %version: ou1cpsw#18 %

#include "mpxvideoplayer_appuienginetester.h"

#include "mpxviewutilityimp_stub.h"

#include "mpxplaybackutilityimp_stub.h"

#include "mpxvideoplayerappui_stub.h"

#include "mpxvideoplayerappuiengine.h"

#include "mpxvideoplayerconstants.h"

#include "mpxcollectionutilityimp_stub.h"

#include <mpxplaybackmessage.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxmediageneraldefs.h>

#include <mpxcollectionmessage.h>

#include <f32file.h>

#include <videoplayeractivationmessage.h>

#include <bautils.h>

#include <vcxmyvideosdefs.h>

#include "mpxvideo_debug.h"

_LIT( KDefaultAccessPointFilename, "c:\\defaultApId.txt" );

_LIT( KQueryAccessPointFilename, "c:\\queryApId.txt" );

#define KMPXPLAYBACKPLUGINTYPEUID 0x101FFCA0

#define EMatrix 4

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

//   CMpxVideoPlayer_AppUiEngineTester::NewL

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

//

CMpxVideoPlayer_AppUiEngineTester*

CMpxVideoPlayer_AppUiEngineTester::NewL( CScriptBase* aScriptBase )

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayer_AppUiEngineTester::NewL()"));

    CMpxVideoPlayer_AppUiEngineTester* self =

        new (ELeave) CMpxVideoPlayer_AppUiEngineTester( aScriptBase );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

}

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

// CMpxVideoPlayer_AppUiEngineTester::~CMpxVideoPlayer_AppUiEngineTester

//

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

//

CMpxVideoPlayer_AppUiEngineTester::~CMpxVideoPlayer_AppUiEngineTester()

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayer_AppUiEngineTester::~CMpxVideoPlayer_AppUiEngineTester()"));

    CleanupTempFiles();

    delete iAppUiEngine;

    iAppUiEngine = NULL;

    delete iAppUi;

    iAppUi = NULL;

    if ( iViewUtility )

    {

        static_cast<CMPXViewUtility*>(iViewUtility)->RemoveStifObserver();

        iViewUtility->Close();

    }

    if ( iPlaybackUtility )

    {

        static_cast<CMPXPlaybackUtility*>(iPlaybackUtility)->RemoveStifObserverL();

        iPlaybackUtility->Close();

    }

    if ( iCollectionUtility )

    {

        iCollectionUtility->RemoveStifObserverL();

        iCollectionUtility->Close();

    }

    if ( iGenericParamList )

    {

        iGenericParamList->Reset();

        delete iGenericParamList;

    }

    iExpectedEventArray->ResetAndDestroy();

    delete iTimeoutController;

}

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

//   CMpxVideoPlayer_AppUiEngineTester::ConstructL

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

//

void CMpxVideoPlayer_AppUiEngineTester::ConstructL()

{

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

    iViewUtility = MMPXViewUtility::UtilityL();

    static_cast<CMPXViewUtility*>(iViewUtility)->AddStifObserverL( this );

    iPlaybackUtility = MMPXPlaybackUtility::UtilityL( EMPXCategoryVideo, KPbModeNewPlayer );

    static_cast<CMPXPlaybackUtility*>(iPlaybackUtility)->AddStifObserverL( this );

    iPlaybackUtility->CommandL( EPbCmdSetAutoResume, EFalse );

    iCollectionUtility = CMPXCollectionUtility::NewL( KNullUid, NULL );

    iCollectionUtility->AddStifObserverL( this );

}

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

// CMpxVideoPlayer_AppUiEngineTester::CMpxVideoPlayer_AppUiEngineTester

//

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

//

CMpxVideoPlayer_AppUiEngineTester::CMpxVideoPlayer_AppUiEngineTester( CScriptBase* aScriptBase )

    : iScriptBase( aScriptBase )

{

}

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

//   CMpxVideoPlayer_AppUiEngineTester::CreateEngineL

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

//

TInt CMpxVideoPlayer_AppUiEngineTester::CreateEngineL( CStifItemParser& aItem )

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayer_AppUiEngineTester::CreateEngineL()"));

    TBool embedded;

    User::LeaveIfError( aItem.GetNextInt( embedded ) );

    iAppUi = new (ELeave) CMpxVideoPlayerAppUi( embedded, this );

    iAppUiEngine = CMpxVideoPlayerAppUiEngine::NewL( iAppUi );

    return KErrNone;

}

TInt CMpxVideoPlayer_AppUiEngineTester::CreateGenericParametersTerminateL()

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayer_AppUiEngineTester::CreateGenericParametersTerminateL()"));

    if ( iGenericParamList )

    {

        iGenericParamList->Reset();

        delete iGenericParamList;

    }

    iGenericParamList = CAiwGenericParamList::NewL();

    TAiwVariant paramTerminate( ETrue );

    TAiwGenericParam genericParam( EGenericParamTerminate, paramTerminate );

    iGenericParamList->AppendL( genericParam );

    TCallbackEvent* event = new (ELeave) TCallbackEvent;

    event->iEvent = EAppUiCmdExit;

    AddExpectedEvent( event );

    return KErrNone;

}

void CMpxVideoPlayer_AppUiEngineTester::AddLocalFileCallbacksL( TDesC& aFileName,

                                                                TBool aUseFileHandle )

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayer_AppUiEngineTester::AddLocalFileCallbacksL()"));

    TCallbackEvent* event = new (ELeave) TCallbackEvent;

    event->iEvent = EViewUtilityPreLoadView;

    event->iUid   = KVideoPlaybackViewUid;

    AddExpectedEvent( event );

    event = new (ELeave) TCallbackEvent;

    event->iFileName = aFileName;

    if ( aUseFileHandle )

    {

        event->iEvent = EPlaybackUtilityInitFileHandle;

    }

    else

    {

        event->iEvent = EPlaybackUtilityInitFileName;

        event->iFileName = aFileName;

    }

    AddExpectedEvent( event );

}

void CMpxVideoPlayer_AppUiEngineTester::AddCollectionMediaCallbacksL()

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayer_AppUiEngineTester::AddLocalFileCallbacksL()"));

    TCallbackEvent* event = new (ELeave) TCallbackEvent;

    event->iEvent = EViewUtilityPreLoadView;

    event->iUid   = KVideoPlaybackViewUid;

    AddExpectedEvent( event );

    event = new (ELeave) TCallbackEvent;

    event->iEvent = EPlaybackUtilityInitPlaylist;

    AddExpectedEvent( event );

}

void CMpxVideoPlayer_AppUiEngineTester::AddSdpFileCallbacksL( TDesC& aFileName,

                                                              TBool aUseFileHandle,

                                                              CStifItemParser& aItem )

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayer_AppUiEngineTester::AddSdpFileCallbacksL()"));

    TInt expectedApId;

    User::LeaveIfError( aItem.GetNextInt( expectedApId ) );

    //

    //  We should get 1 callback

    //  iPlaybackUtility->InitStreamingL( iFile / aUri )

    //

    TCallbackEvent* event = new (ELeave) TCallbackEvent;

    if ( expectedApId > 0 )

    {

        event->iFileName = aFileName;

        event->iApId     = expectedApId;

        if ( aUseFileHandle )

        {

            event->iEvent = EPlaybackUtilityInitStreamingFileHandle;

        }

        else

        {

            event->iEvent = EPlaybackUtilityInitStreamingUrl;

        }

    }

    else

    {

        //

        //  When the apId is negative, an error code will be return with a Leave

        //

        event->iEvent = EFunctionLeave;

        event->iExtra = expectedApId;

    }

    AddExpectedEvent( event );

}

void CMpxVideoPlayer_AppUiEngineTester::AddRamFileCallbacksL( TDesC& /*aFileName*/,

                                                              TBool /*aUseFileHandle*/,

                                                              CStifItemParser& aItem )

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayer_AppUiEngineTester::AddRamFileCallbacksL()"));

    _LIT( KRamStreamingLink, "rtsp://stream.3gp" );

#ifdef __WINSCW__

    _LIT( KRamLocalLink, "c:\\data\\videos\\local.3gp" );

#else

    _LIT( KRamLocalLink, "f:\\testing\\data\\local.3gp" );

#endif

    TInt  expectedApId;

    TBool streamLinksExist;

    User::LeaveIfError( aItem.GetNextInt( expectedApId ) );

    User::LeaveIfError( aItem.GetNextInt( streamLinksExist ) );

    //

    //  We should get 1 callback

    //  iPlaybackUtility->InitStreamingL( iFile );

    //

    TCallbackEvent* event = new (ELeave) TCallbackEvent;

    if ( streamLinksExist )

    {

        event->iEvent    = EPlaybackUtilityInitStreamingUrl;

        event->iFileName = KRamStreamingLink;

        event->iApId     = expectedApId;

    }

    else

    {

        event->iEvent    = EPlaybackUtilityInitFileName;

        event->iFileName = KRamLocalLink;

    }

    event->iApId     = expectedApId;

    AddExpectedEvent( event );

}

void CMpxVideoPlayer_AppUiEngineTester::AddAsxFileCallbacksL( TDesC& /*aFileName*/,

                                                              TBool /*aUseFileHandle*/,

                                                              CStifItemParser& aItem )

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayer_AppUiEngineTester::AddRamFileCallbacksL()"));

    _LIT( KAsxStreamingLink, "http://10.48.2.56:443/stream.wmv" );

#ifdef __WINSCW__

    _LIT( KAsxLocalLink, "c:\\data\\videos\\local.3gp" );

#else

    _LIT( KAsxLocalLink, "f:\\testing\\data\\local.3gp" );

#endif

    TInt  expectedApId;

    TBool streamLinksExist;

    User::LeaveIfError( aItem.GetNextInt( expectedApId ) );

    User::LeaveIfError( aItem.GetNextInt( streamLinksExist ) );

    //

    //  We should get 1 callback

    //  iPlaybackUtility->InitStreamingL( iFile );

    //

    TCallbackEvent* event = new (ELeave) TCallbackEvent;

    if ( streamLinksExist )

    {

        event->iEvent    = EPlaybackUtilityInitStreamingUrl;

        event->iFileName = KAsxStreamingLink;

        event->iApId     = expectedApId;

    }

    else

    {

        event->iEvent    = EPlaybackUtilityInitFileName;

        event->iFileName = KAsxLocalLink;

    }

    event->iApId     = expectedApId;

    AddExpectedEvent( event );

}

void CMpxVideoPlayer_AppUiEngineTester::AddUrlCallbacksL( TDesC& aFileName,

                                                          CStifItemParser& aItem )

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayer_AppUiEngineTester::AddUrlCallbacksL()"));

    TInt expectedApId;

    User::LeaveIfError( aItem.GetNextInt( expectedApId ) );

    //

    //  We should get 1 callback

    //  iPlaybackUtility->InitStreamingL( aUri )

    //

    TCallbackEvent* event = new (ELeave) TCallbackEvent;

    event->iEvent    = EPlaybackUtilityInitStreamingUrl;

    event->iFileName = aFileName;

    event->iApId     = expectedApId;

    AddExpectedEvent( event );

}

TInt CMpxVideoPlayer_AppUiEngineTester::OpenFileL( CStifItemParser& aItem )

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayer_AppUiEngineTester::OpenFileL()"));

    iError = KErrNone;

    TBool useFileHandle;

    TInt fileType;

    User::LeaveIfError( aItem.GetNextInt( useFileHandle ) );

    TFileName filename = GetFileNameAndPathL( aItem );

    User::LeaveIfError( aItem.GetNextInt( fileType ) );

    //

    //  Add Callbacks

    //

    switch ( fileType )

    {

        case ELocalFile:

        {

            AddLocalFileCallbacksL( filename, useFileHandle );

            break;

        }

        case ESdpFile:

        {

            AddSdpFileCallbacksL( filename, useFileHandle, aItem );

            break;

        }

        case ERamFile:

        {

            AddRamFileCallbacksL( filename, useFileHandle, aItem );

            break;

        }

        case EUrl:

        {

            AddUrlCallbacksL( filename, aItem );

            break;

        }

        case EAsxFile:

        {

            AddAsxFileCallbacksL( filename, useFileHandle, aItem );

            break;

        }

        case EMultiLinkFile:

        default:

            break;

    }

    if ( useFileHandle )

    {

        RFs fs;

        RFile file;

        User::LeaveIfError( fs.Connect() );

        fs.ShareProtected();

        User::LeaveIfError( file.Open( fs, filename, EFileRead ) );

        MPX_TRAPD( trapErr, iAppUiEngine->OpenFileL( file, iGenericParamList ) );

        if ( trapErr != KErrNone )

        {

            TCallbackEvent* event = new (ELeave) TCallbackEvent;

            //

            //  When the apId is negative, an error code will be return with a Leave

            //

            event->iEvent = EFunctionLeave;

            event->iExtra = trapErr;

            HandleUtilityEvent( event );

        }

        file.Close();

        fs.Close();

    }

    else

    {

        iAppUiEngine->OpenFileL( filename );

    }

    EndTest();

    return iError;

}

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

//   CMpxVideoPlayer_AppUiEngineTester::OpenMediaL

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

//

TInt CMpxVideoPlayer_AppUiEngineTester::OpenMediaL( CStifItemParser& aItem )

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayer_AppUiEngineTester::OpenMediaL()"));

    iError = KErrNone;

    CMPXMedia* media = CMPXMedia::NewL();

    CleanupStack::PushL( media );

    TFileName filename = GetFileNameAndPathL( aItem );

    media->SetTextValueL( KMPXMediaGeneralUri, filename );

    media->SetTObjectValueL( KMPXMediaGeneralId, TMPXItemId( 1, 2 ) );

    RFs fs;

    User::LeaveIfError( fs.Connect() );

    CleanupClosePushL( fs );

    if ( BaflUtils::FileExists( fs, filename ) )

        {

        TCallbackEvent* event1 = new (ELeave) TCallbackEvent;

        event1->iEvent = EViewUtilityPreLoadView;

        event1->iUid   = KVideoPlaybackViewUid;

        AddExpectedEvent( event1 );

        TCallbackEvent* event2 = new (ELeave) TCallbackEvent;

        event2->iEvent = EPlaybackUtilityInitPlaylist;

        AddExpectedEvent( event2 );

        }

    CleanupStack::PopAndDestroy( &fs );

    iAppUiEngine->OpenMediaL( *media );

    CleanupStack::PopAndDestroy( media );

    EndTest();

    return iError;

}

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

//   CMpxVideoPlayer_AppUiEngineTester::SetDefaultAccessPointL

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

//

TInt CMpxVideoPlayer_AppUiEngineTester::SetDefaultAccessPointL( CStifItemParser& aItem )

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayer_AppUiEngineTester::SetDefaultAccessPointL()"));

    TInt apId;

    //

    //  Read in the filename from the config file

    //

    User::LeaveIfError( aItem.GetNextInt( apId ) );

    WriteAccessPointL( KDefaultAccessPointFilename, apId );

    return KErrNone;

}

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