/*

* Copyright (c) 2008 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:  Test Harness for VideoHelixPlaybackPlugin

*

*/

// [INCLUDE FILES] - do not remove

#include <e32svr.h>

#include <stifparser.h>

#include <stiftestinterface.h>

#include <mpxmediageneraldefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mmf/common/mmferrors.h>

#include <mpxplaybackpluginversion2.h>

#include <mpxmessagegeneraldefs.h>

#include <accpolnamevaluerecord.h>

#include <accconfigfileparser.h>

#include <acccongenericid.h>

#include <accpolnamevaluerecord.h>

#include "dlmgr_stub.h"

#include "mpxvideoregion.h"

#include "videohelixtest.h"

#include "mpxvideoaccessoryobserver_stub.h"

#include <mpxvideoplaybackdefs.h>

#include "mpxmediavideodefs.h"

#include "mpxvideo_debug.h"

#include "mpxvideoplayerutility_stub.h"

#ifdef __WINSCW__

    _LIT( KVideoTestPath, "c:\\data\\Videos\\" );

#else

    _LIT( KVideoTestPath, "f:\\testing\\data\\" );

#endif

_LIT( KOpenControllerFilename, "c:\\vhpp_openerror.txt" );

_LIT( KPrepareControllerFilename, "c:\\vhpp_prepareerror.txt" );

_LIT( KPlaybackCompleteFilename, "c:\\vhpp_playerror.txt" );

_LIT( KDlMgrFile, "c:\\vhpp_dlmgr.txt" );

_LIT( KDrmRightsFile, "c:\\vhpp_drmrights.txt" );

#define ELightsNotBlinking 1

#define ELightsBlinking 2

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

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

//  CVHPPTestClass::RunMethodL

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

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

//

TInt CVHPPTestClass::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( "Initialize", CVHPPTestClass::InitializeL ),

        ENTRY( "InitializeHandle", CVHPPTestClass::InitializeHandleL ),

        ENTRY( "InitializeLink", CVHPPTestClass::InitializeLinkL ),

        ENTRY( "InitializeSdp", CVHPPTestClass::InitializeSdpL ),

        ENTRY( "IssueGeneralCommand", CVHPPTestClass::IssueGeneralCommandL),

        ENTRY( "IssuePlaybackCommand", CVHPPTestClass::IssuePlaybackCommandL),

        ENTRY( "IssueVideoCommand", CVHPPTestClass::IssueVideoCommandL),

        ENTRY( "IssueSeekingCommand", CVHPPTestClass::IssueSeekingCommandL),

        ENTRY( "SetProperty", CVHPPTestClass::SetPropertyL),

        ENTRY( "GetProperty", CVHPPTestClass::GetPropertyL),

        ENTRY( "GetSubPlayerNames", CVHPPTestClass::GetSubPlayerNamesL),

        ENTRY( "SelectSubPlayer", CVHPPTestClass::SelectSubPlayerL),

        ENTRY( "SubPlayerName", CVHPPTestClass::SubPlayerName),

        ENTRY( "SubPlayerIndex", CVHPPTestClass::SubPlayerIndex),

        ENTRY( "CancelRequest", CVHPPTestClass::CancelRequest),

        ENTRY( "GetMedia", CVHPPTestClass::GetMediaL),

        ENTRY( "SetPlaybackComplete", CVHPPTestClass::SetPlaybackCompleteL),

        ENTRY( "SetUnexpectedMmfEvent", CVHPPTestClass::SetUnexpectedMmfEventL),

        ENTRY( "ConnectToDownload", CVHPPTestClass::ConnectToDownloadL),

        ENTRY( "PauseDownload", CVHPPTestClass::PauseDownloadL),

        ENTRY( "ResumeDownload", CVHPPTestClass::ResumeDownloadL),

        ENTRY( "CancelDownload", CVHPPTestClass::CancelDownloadL),

        ENTRY( "RetrievePdlStatus", CVHPPTestClass::RetrievePdlStatusL),

        ENTRY( "ChangeAspectRatioL", CVHPPTestClass::ChangeAspectRatioL),

        ENTRY( "AlarmOn", CVHPPTestClass::AlarmOn),

        ENTRY( "PhoneCallRejected", CVHPPTestClass::PhoneCallRejected),

        ENTRY( "VoiceCallAccepted", CVHPPTestClass::VoiceCallAccepted),

        ENTRY( "VideoCallAccepted", CVHPPTestClass::VideoCallAccepted),

        ENTRY( "PlayduringVideoCall", CVHPPTestClass::PlayduringVideoCall),

        ENTRY( "PlayduringVoiceCall", CVHPPTestClass::PlayduringVoiceCall),

        ENTRY( "EndPhoneCall", CVHPPTestClass::EndPhoneCall),

        ENTRY( "SetTvOutConnected", CVHPPTestClass::SetTvOutConnectedL ),

        ENTRY( "SetTvOutDisconnected", CVHPPTestClass::SetTvOutDisconnectedL ),

        ENTRY( "ConnectTvOut", CVHPPTestClass::ConnectTvOutL ),

        ENTRY( "DisconnectTvOut", CVHPPTestClass::DisconnectTvOutL ),

        ENTRY( "SetDrmProtected", CVHPPTestClass::SetDrmProtectedL ),

        ENTRY( "IssueSeekedToEndCommand", CVHPPTestClass::IssueSeekedToEndCommandL),

        ENTRY( "HandleVolume", CVHPPTestClass::HandleVolumeL ),

        ENTRY ("InitializeWithPositionL", CVHPPTestClass::InitializeWithPositionL),

        ENTRY ("InitializeLinkWithPositionL", CVHPPTestClass::InitializeLinkWithPositionL),

        ENTRY ("InitializeHandleWithPositionL", CVHPPTestClass::InitializeHandleWithPositionL)

        //

        //  ADD NEW ENTRIES HERE

        //

        // ENTRY( "SendPlayCommandToServer",

        //        CVHPPTestClass::SendPlayCommandToServer ),

        // [test cases entries] - Do not remove

    };

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

    return RunInternalL( KFunctions, count, aItem );

}

void

CVHPPTestClass::WriteControllerError( const TDesC& aFilename, TInt aData )

{

    MPX_ENTER_EXIT(_L("CVHPPTestClass::WriteControllerError()"),

                   _L("file = %S, data = %d"), &aFilename, aData );

    //

    //  Write to test file so the controller open fails

    //

    RFile file;

    RFs fs;

    TInt error = fs.Connect();

    TBuf8<16> tgt;

    tgt.Num( aData );

    file.Replace( fs, aFilename, EFileWrite );

    file.Write( tgt );

    file.Close();

    fs.Close();

}

void

CVHPPTestClass::CreateGeneralPlaybackCommandL( TMPXPlaybackCommand aCmd )

{

    MPX_ENTER_EXIT(_L("CVHPPTestClass::CreateGeneralPlaybackCommandL()"),

                   _L("aCmd = %d"), aCmd );

    CMPXCommand* cmd = CMPXCommand::NewL();

    CleanupStack::PushL( cmd );

    cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );

    cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId,

                                 KMPXCommandIdPlaybackGeneral );

    cmd->SetTObjectValueL<TInt>( KMPXCommandPlaybackGeneralType, aCmd );

    iPlaybackPlugin->CommandL( *cmd );

    CleanupStack::PopAndDestroy( cmd );

}

void

CVHPPTestClass::PreparePluginL()

{

    MPX_ENTER_EXIT(_L("CVHPPTestClass::PreparePluginL()"));

    //

    //  Set this class as the observer for the Plugin events

    //

    iLog->Log(_L("    SetObserver on Plugin"));

    iPlaybackPlugin->SetObserver( *this );

    //

    //  Create Playback Message

    //

    iLog->Log(_L("    Close the Plugin"));

    CreateGeneralPlaybackCommandL( EPbCmdClose );

}

TInt

CVHPPTestClass::ReadFileInitializationParameters( CStifItemParser& aItem, TDes& aFilename )

{

    MPX_ENTER_EXIT(_L("CVHPPTestClass::ReadFileInitializationParameters()"));

    TPtrC filename;

    //

    //  Read in the filename from the config file

    //

    TInt err = aItem.GetNextString( filename );

    if ( err == KErrNone )

    {

        //

        //  Build the full path to the file

        //

        aFilename.Append( KVideoTestPath );

        aFilename.Append( filename );

        err = ReadInitializationErrors( aItem );

    }

    return err;

}

TInt

CVHPPTestClass::ReadInitializationErrors( CStifItemParser& aItem )

{

    TInt err;

    TInt initError;

    TInt openError;

    TInt prepError;

    //

    //  Read in the expected init error code

    //

    err = aItem.GetNextInt( initError );

    if ( err == KErrNone && initError != KErrNone )

    {

        AddErrorEvent( initError );

    }

    else

    {

        //

        //  Read in the expected open complete error code

        //

        err = aItem.GetNextInt( openError );

        WriteControllerError( KOpenControllerFilename, openError );

        if ( err == KErrNone && openError != KErrNone )

        {

            AddErrorEvent( openError );

        }

        else

        {

            //

            //  Open Complete does not return error

            //  Read in the expected prepare complete error code

            //

            err = aItem.GetNextInt( prepError );

            WriteControllerError( KPrepareControllerFilename, prepError );

            if ( err == KErrNone && prepError != KErrNone )

            {

                AddErrorEvent( prepError );

            }

        }

    }

    return err;

}

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

//  CVHPPTestClass::InitializeL

//  Test creation of a general playback command.

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

//

TInt

CVHPPTestClass::InitializeL( CStifItemParser& aItem )

{

    MPX_ENTER_EXIT(_L("CVHPPTestClass::InitializeL()"));

    iLog->Log(_L("CVHPPTestClass::InitializeL()"));

    TInt duration;

    TInt volumeSteps;

    TInt err = aItem.GetNextInt( duration );

    if ( err == KErrNone )

    {

        //

        //  We will always get an Init Complete message out

        //

        TCallbackEvent* event = new TCallbackEvent;

        event->iEvent = EPInitialised;

        event->iData  = duration;

        event->iError = KErrNone;

        AddExpectedEvent( event );

        // 

        // read number of volume steps

        //

        err = aItem.GetNextInt( volumeSteps );

        if ( err == KErrNone )

        {        

            //

            // set volume steps

            //

            SetVolumeSteps( volumeSteps );

            TBuf<120> fullPath;    

            err = ReadFileInitializationParameters( aItem, fullPath );

            if ( err == KErrNone )

            {

                PreparePluginL();

                //

                //  Initalize the Plugin with a file name

                //

                MPX_DEBUG(_L("Initialize the Plugin:  filename = %S"), &fullPath);

                iLog->Log(_L("Initialize the Plugin:  filename = %S"), &fullPath);

                iPlaybackPlugin->InitialiseL( fullPath );

            }

        }

    }

    return err;

}

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

//  CVHPPTestClass::InitializeLinkL

//  Test creation of a general playback command.

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

//

TInt

CVHPPTestClass::InitializeLinkL( CStifItemParser& aItem )

{

    MPX_ENTER_EXIT(_L("CVHPPTestClass::InitializeLinkL()"));

    iLog->Log(_L("CVHPPTestClass::InitializeLinkL()"));

    TInt duration;

    TInt volumeSteps;

    TInt err = aItem.GetNextInt( duration );

    if ( err == KErrNone )

    {

        //

        //  We will always get an Init Complete message out

        //

        TCallbackEvent* event = new TCallbackEvent;

        event->iEvent = EPInitialised;

        event->iData  = duration;

        event->iError = KErrNone;

        AddExpectedEvent( event );

        // 

        // read number of volume steps

        //

        err = aItem.GetNextInt( volumeSteps );

        if ( err == KErrNone )

        {        

            //

            // set volume steps

            //

            SetVolumeSteps( volumeSteps );

            TPtrC  link;

            //

            //  Read in the link from the config file

            //

            TInt err = aItem.GetNextString( link );

            if ( err == KErrNone )

            {

                TInt err = ReadInitializationErrors( aItem );

                if ( err == KErrNone )

                {

                    PreparePluginL();

                    //

                    //  Extract the streaming link from the ram file and

                    //  Initalize the Plugin with the link and an access point

                    //

                    MPX_DEBUG(_L("Initialize the Plugin:  link = %S"), &link);

                    iLog->Log(_L("Initialize the Plugin:  link = %S"), &link);

                    iPlaybackPlugin->InitStreamingL( link, KNullDesC8, 11 );

                }

            }

        }

    }

    return err;

}

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

//  CVHPPTestClass::InitializeSdpL

//  Test creation of a general playback command.

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

//

TInt

CVHPPTestClass::InitializeSdpL( CStifItemParser& /*aItem*/ )

{

    MPX_ENTER_EXIT(_L("CVHPPTestClass::InitializeSdpL()"));

    iLog->Log(_L("CVHPPTestClass::InitializeSdpL()"));

    TBuf<120> fullPath;

    TInt      initError = KErrNone;

    TInt err = KErrNone;// = ReadInitializationParameters( aItem, fullPath, initError );

    if ( err == KErrNone )

    {

        PreparePluginL();

        MPX_DEBUG(_L("Initialize the Plugin:  filename = %S"), &fullPath);

        iLog->Log(_L("Initialize the Plugin:  filename = %S"), &fullPath);

        TRAPD( err,

               static_cast<CMPXPlaybackPluginVersion2*>(iPlaybackPlugin)->InitStreamingL

                                     ( fullPath, KNullDesC8, 11 );

              );

        MPX_DEBUG(_L("CVHPPTestClass::InitialisePluginL(%d)"), err);

        if ( err == initError )

        {

            MPX_DEBUG(_L("InitialiseL() returned proper error %d"), err);

            iLog->Log(_L("InitialiseL() returned proper error %d"), err);

            err = KErrNone;

        }

    }

    return err;

}

TInt

CVHPPTestClass::InitializeHandleL( CStifItemParser& aItem  )

{

    MPX_ENTER_EXIT(_L("CVHPPTestClass::InitializeHandleL()"));

    iLog->Log(_L("CVHPPTestClass::InitializeHandleL()"));

    TInt duration;

    TInt volumeSteps;

    TInt fileHandle32;

    TInt err = aItem.GetNextInt( fileHandle32 );

    if ( err == KErrNone )

    {        

#ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

        //

        // set RFile as default if the 64-bit flag is not defined

        //

        fileHandle32 = ETrue;

#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

        err = aItem.GetNextInt( duration );

        if ( err == KErrNone )

        {

            //

            //  We will always get an Init Complete message out

            //

            TCallbackEvent* event = new TCallbackEvent;

            event->iEvent = EPInitialised;

            event->iData  = duration;

            event->iError = KErrNone;

            AddExpectedEvent( event );

            // 

            // read number of volume steps

            //

            err = aItem.GetNextInt( volumeSteps );

            if ( err == KErrNone )

            {        

                //

                // set volume steps

                //

                SetVolumeSteps( volumeSteps );

                TBuf<120> fullPath;

                err = ReadFileInitializationParameters( aItem, fullPath );

                if ( err == KErrNone )

                {

                    PreparePluginL();

                    RFs fs;

                    TInt error = fs.Connect();

                    //

                    //  Open a file handle to the clip

                    //

                    if ( fileHandle32 )

                    {

                        RFile file;

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

                        iPlaybackPlugin->InitialiseL( file );

                        file.Close();

                    }

#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

                    else

                    {

                        RFile64 file64;

                        User::LeaveIfError( file64.Open( fs, fullPath, EFileRead ) );