/*
* 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:  videoplaylistutility test class for STIF testing
*
*/

// Version : %version: 2 %

#include <f32file.h>
#include <mediarecognizer.h>
#include <mpxmediaarray.h>
#include <mpxmediacontainerdefs.h>
#include <mpxmediageneralextdefs.h>

#include "videoplaylistutilitytester.h"
#include "videoplaylistutility.h"


// -------------------------------------------------------------------------------------------------
//   CVideoPlaylistUtility_Tester::NewL
// -------------------------------------------------------------------------------------------------
//
CVideoPlaylistUtility_Tester* CVideoPlaylistUtility_Tester::NewL()
{
    CVideoPlaylistUtility_Tester* self = new (ELeave) CVideoPlaylistUtility_Tester;
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
}

// -----------------------------------------------------------------------------
// CVideoPlaylistUtility_Tester::~CVideoPlaylistUtility_Tester
//
// -----------------------------------------------------------------------------
//
CVideoPlaylistUtility_Tester::~CVideoPlaylistUtility_Tester()
{
    delete iPlaylistUtility;
    iPlaylistUtility = NULL;

}

// -------------------------------------------------------------------------------------------------
//   CVideoPlaylistUtility_Tester::ConstructL
// -------------------------------------------------------------------------------------------------
//
void CVideoPlaylistUtility_Tester::ConstructL()
{
}

// -----------------------------------------------------------------------------
// CVideoPlaylistUtility_Tester::CVideoPlaylistUtility_Tester
//
// -----------------------------------------------------------------------------
//
CVideoPlaylistUtility_Tester::CVideoPlaylistUtility_Tester()
{
}

// -------------------------------------------------------------------------------------------------
//   CVideoPlaylistUtility_Tester::CreateEngineL
// -------------------------------------------------------------------------------------------------
//
TInt CVideoPlaylistUtility_Tester::CreatePlaylistUtilityL( CStifItemParser& /*aItem*/ )
{
    iPlaylistUtility = CVideoPlaylistUtility::NewL();

    return KErrNone;
}


// -------------------------------------------------------------------------------------------------
//   CVideoPlaylistUtility_Tester::GetFileInfoL
// -------------------------------------------------------------------------------------------------
//
TInt CVideoPlaylistUtility_Tester::GetFileInfoL( CStifItemParser& aItem )
{
    CMediaRecognizer::TMediaType mediaType = CMediaRecognizer::ELocalRamFile;
    TInt error = KErrNone;

    TBool useFileHandle;
    TInt  media;
    TBool expectedSingleLink;
    TBool expectedLocalFile;
    TBool singleLink;
    TBool localFile;

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

    TFileName filename = GetFileNameAndPathL( aItem );

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


    // Get the mediaType
    switch ( media )
    {
        case ERamFile:
        {
            mediaType = CMediaRecognizer::ELocalRamFile;
            break;
        }
        case EAsxFile:
        {
            mediaType = CMediaRecognizer::ELocalAsxFile;
            break;
        }
    }

    if ( useFileHandle )
    {
        RFs fs;
        RFile file;

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

        fs.ShareProtected();

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

        iPlaylistUtility->GetFileInfoL( file, mediaType, singleLink, localFile );

        file.Close();
        fs.Close();
    }
    else
    {
        iPlaylistUtility->GetFileInfoL( filename, mediaType, singleLink, localFile );
    }

    // Read the expected result
    User::LeaveIfError( aItem.GetNextInt( expectedSingleLink ) );
    User::LeaveIfError( aItem.GetNextInt( expectedLocalFile ) );

    if ( expectedSingleLink != singleLink || expectedLocalFile != localFile )
    {
        error = KErrGeneral;
    }

    return error;
}


// -------------------------------------------------------------------------------------------------
//   CVideoPlaylistUtility_Tester::GetLinkL
// -------------------------------------------------------------------------------------------------
//
TInt CVideoPlaylistUtility_Tester::GetLinkL( CStifItemParser& aItem )
{
    TInt error = KErrNone;

    _LIT( KRamStreamingLink, "rtsp://stream.3gp" );
    _LIT( KAsxStreamingLink, "http://10.48.2.56:443/stream.wmv" );

#ifdef __WINSCW__
    _LIT( KRamLocalLink, "c:\\data\\videos\\local.3gp" );
#else
    _LIT( KRamLocalLink, "e:\\testing\\data\\local.3gp" );
#endif

    TInt linkType;
    TPtrC link;

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

    link.Set(iPlaylistUtility->GetLinkLC());

    // Get the linkType
    switch ( linkType )
    {
        case ERamFileStreaming:
        {
            if ( link.CompareF(KRamStreamingLink) )
            {
                error = KErrArgument;
            }
            break;
        }
        case ERamFileLocal:
        {
            if ( link.CompareF(KRamLocalLink) )
            {
                error = KErrArgument;
            }
            break;
        }
        case EAsxFileStreaming:
        {
            if ( link.CompareF(KAsxStreamingLink) )
            {
                error = KErrArgument;
            }
            break;
        }

    }

    CleanupStack::PopAndDestroy();
    return error;
}


// -------------------------------------------------------------------------------------------------
//   CVideoPlaylistUtility_Tester::GetPlaylistL
// -------------------------------------------------------------------------------------------------
//
TInt CVideoPlaylistUtility_Tester::GetPlaylistL( CStifItemParser& aItem )
{
    TInt error = KErrNone;
    TInt linkCount;
    TInt expectedCount;

    TInt accessPointId;
    TInt embeddedInfo;

    User::LeaveIfError( aItem.GetNextInt( accessPointId ) );
    User::LeaveIfError( aItem.GetNextInt( expectedCount ) );
    User::LeaveIfError( aItem.GetNextInt( embeddedInfo ) );

    CMPXMedia* playlist = iPlaylistUtility->GetPlayListL(accessPointId);

    linkCount = playlist->ValueTObjectL<TInt>(KMPXMediaArrayCount);

    if ( linkCount != expectedCount )
    {
       error = KErrArgument;
    }

    // Get the mediaType
    switch ( embeddedInfo )
    {
        case EEmbeddedSeekInfo:
        {
            CMPXMediaArray* mediaArray = 
                    playlist->Value<CMPXMediaArray>(KMPXMediaArrayContents);
            
            for ( TInt i = 0; i < mediaArray->Count(); i++ )
            {
                CMPXMedia* media = mediaArray->AtL( i );
                if ( !(media->IsSupported( KMPXMediaGeneralExtVideoSeekable )) )
                 {
                      // The test clip has all the links set to non seek                     }
                      error = KErrArgument;  
                      break;                      
                 }
            }
            break;
        }
        case ENoEmbeddedInfo:
        {
            CMPXMediaArray* mediaArray = 
                    playlist->Value<CMPXMediaArray>(KMPXMediaArrayContents);
            
            for ( TInt i = 0; i < mediaArray->Count(); i++ )
            {
                CMPXMedia* media = mediaArray->AtL( i );
                if ((media->IsSupported( KMPXMediaGeneralExtVideoSeekable )) )
                 {
                      // The test clip has all the links set to non seek                     }
                      error = KErrArgument;  
                      break;                      
                 }
            }
            break;
        }
        default:
        {
            break;
        }
    }
        
        
    delete playlist;
    return error;
}

// -------------------------------------------------------------------------------------------------
//   CVideoPlaylistUtility_Tester::IsSeekableL
// -------------------------------------------------------------------------------------------------
//
TInt CVideoPlaylistUtility_Tester::IsSeekableL( CStifItemParser& aItem )
{
    TInt error = KErrNone;
    TBool seekable;

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

    if ( seekable != iPlaylistUtility->IsSeekable())
    {
        error = KErrArgument;
    }

    return error;
}


TFileName CVideoPlaylistUtility_Tester::GetFileNameAndPathL( CStifItemParser& aItem )
{
    TPtrC filename;

#ifdef __WINSCW__
    _LIT( KVideoTestPath, "c:\\data\\Videos\\" );
#else
    _LIT( KVideoTestPath, "e:\\testing\\data\\" );
#endif

    User::LeaveIfError( aItem.GetNextString( filename ) );

    TFileName fullPath;

    fullPath.Append( KVideoTestPath );

    fullPath.Append( filename );

    return fullPath;
}

// EOF