/*

* Copyright (c) 2005 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:  XML-Parser used to parse motion patterns.

*

*/

// INCLUDE FILES

#include "C3DAudioXMLParser.h"

#include "tdaudioconstants.h"	// K3DAudioRepositoryUid

#include <f32file.h>			// RFs

#include <s32mem.h>				// RBufWriteStream

#include <centralrepository.h>	// CRepository

#include "RingingTone3DPluginDebug.h"

#include <ProfileInternal.hrh> // for TProfile3DToneEffect and TProfile3DToneEcho

#include <pathinfo.h>

#include <driveinfo.h>

#include <data_caging_path_literals.hrh>

//CONSTANTS

const TInt32 KRingingTone3DAudioEComPluginUID = 0x10208ADF;

// 3DTone pattern dir

_LIT( K3DTonesDir, "3DTones" );

// 3DTone pattern files

_LIT( KPatternCircle,     "1circular.xml" );

_LIT( KPatternFlyBy,      "2flyby.xml" );

_LIT( KPatternZigZag,     "3zigzag.xml" );

_LIT( KPatternRandomWalk, "4meander.xml" );

_LIT( KPatternChaos,      "5random.xml" );

// Elements

_LIT8( KInitElement, "initialization");

_LIT8( KPositionElement, "position" );

_LIT8( KUpdateElement, "update" );

_LIT8( KVelocityElement, "velocity" );

_LIT8( KLoopElement, "loop" );

// Attribute names.

_LIT8( KPatternName, "name" );

_LIT8( KPatternReverb, "reverb" );

_LIT8( KPatternDoppler, "doppler" );

_LIT8( KXCoordinate, "x" );

_LIT8( KYCoordinate, "y" );

_LIT8( KZCoordinate, "z" );

_LIT8( KDTime, "dTime" );

_LIT8( KScalarVelocity, "scalar" );

_LIT8( KLoopCount, "count" );

// Attribute values

_LIT8( KReverbPresetOne, "Livingroom" );

_LIT8( KReverbPresetTwo, "Cave" );

_LIT8( KReverbPresetThree, "Stone Corridor" );

_LIT8( KReverbPresetFour, "Forest" );

_LIT8( KReverbPresetFive, "Sewerpipe" );

_LIT8( KReverbPresetSix, "Underwater" );

_LIT8( KBooleanTrue, "true" );

/******************************************************************************

 * class C3DAudioXMLParser

 ******************************************************************************/

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

// C3DAudioXMLParser::NewL

// Two-phased constructor.

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

//		

C3DAudioXMLParser* C3DAudioXMLParser::NewL()

	{

	C3DAudioXMLParser* self = C3DAudioXMLParser::NewLC();

    CleanupStack::Pop( self );

    return self;

	}

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

// C3DAudioXMLParser::NewLC

// Two-phased constructor. Leaves pointer on cleanup stack.

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

//		

C3DAudioXMLParser* C3DAudioXMLParser::NewLC()

	{

	C3DAudioXMLParser * self = new ( ELeave ) C3DAudioXMLParser();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;	

	}

// Destructor

C3DAudioXMLParser::~C3DAudioXMLParser()

	{

	delete iParser;

	delete iParsedPattern;

   	iFsSession.Close();

	}

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

// C3DAudioXMLParser::C3DAudioXMLParser

// C++ default constructor can NOT contain any code, that

// might leave.

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

//		

C3DAudioXMLParser::C3DAudioXMLParser():

	iParser( NULL ),

	iParsedPattern( NULL )

	{

	}

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

// C3DAudioXMLParser::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void C3DAudioXMLParser::ConstructL()

    {

    _LIT8( KParserMimeType, "text/xml" );

	iPatternId = KErrNotFound;

	iParser = Xml::CParser::NewL( KParserMimeType, *this );

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

    }	

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

// C3DAudioXMLParser::Count

//

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

//		

TInt C3DAudioXMLParser::CountL()

    {

    User::LeaveIfNull( iParsedPattern );

    const RArray<T3DScriptUpdate>& script = iParsedPattern->Script();

    return script.Count();

    }

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

// C3DAudioXMLParser::PositionL

//

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

//		

const T3DPosition& C3DAudioXMLParser::PositionL( TInt aIndex )

    {

    User::LeaveIfNull( iParsedPattern );

    const RArray<T3DScriptUpdate>& script = iParsedPattern->Script();

    if ( aIndex < 0 || aIndex >= script.Count() )

        {

        User::Leave( KErrArgument );

        }

    return script[ aIndex ].iPosition;

    }

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

// C3DAudioXMLParser::VelocityL

//

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

//		

const T3DVelocity& C3DAudioXMLParser::VelocityL( TInt aIndex )

    {

    User::LeaveIfNull( iParsedPattern );

    const RArray<T3DScriptUpdate>& script = iParsedPattern->Script();

    if ( aIndex < 0 || aIndex >= script.Count() )

        {

        User::Leave( KErrArgument );

        }

    return script[ aIndex ].iVelocity;

    }

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

// C3DAudioXMLParser::TimeL

//

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

//		

const TInt& C3DAudioXMLParser::TimeL( TInt aIndex )

    {

    User::LeaveIfNull( iParsedPattern );    

    const RArray<T3DScriptUpdate>& script = iParsedPattern->Script();

    if ( aIndex < 0 || aIndex >= script.Count() )

        {

        User::Leave( KErrArgument );

        }

    return script[ aIndex ].iDTime;

    }

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

// C3DAudioXMLParser::Attribute

//

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

//		

TInt C3DAudioXMLParser::Attribute( TInt aKey )

    {

    TInt num = KErrNotFound;

    switch ( aKey )

        {

        case EKeyPatternId:

            {

            num = iPatternId;

            break;

            }

        case EKeyDopplerUsed:

            {

            num = iParsedPattern->DopplerAvailable();

            break;

            }

        case EKeyVelocity:

            {

            num = KMotionPatternDefaultVelocity;

            break;

            }

        default:

            {

            break;    

            }

        }

    return num;

    }

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

// C3DAudioXMLParser::ParseL

//

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

//		

void C3DAudioXMLParser::ParseL( TInt aPatternId )

	{

	FLOG( _L("C3DAudioXMLParser::ParseL START") );

	if ( ReadFromPatternCacheL( aPatternId ) )

	    {

#ifdef _DEBUG

        // parsed pattern data found in cache (publish and subcribe)

        FlogPatternL( aPatternId );

#endif

	    }

	else

	    {

    	GetPatternFullPathL( iFullPath, aPatternId );

	    ParseL( iFullPath );

	    WriteToPatternCacheL( aPatternId );

	    FLOG( _L("pattern '%S' parsed and written to cache"), &iFullPath );

	    }

	iPatternId = aPatternId;

#ifdef _DEBUG                         

    AssertParseDataL( aPatternId );

#endif

	FLOG( _L("C3DAudioXMLParser::ParseL END") );

	}

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

// C3DAudioXMLParser::ParseL

//

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

//		

void C3DAudioXMLParser::ParseL( const TDesC& aFileName )

	{

	delete iParsedPattern;

    iParsedPattern = NULL;

	iParsedPattern = C3DAudioPattern::NewL();

	//

	// read xml-format pattern file into descriptor

	//

	CBufFlat* buf = ReadPatternFileL( aFileName );

	CleanupStack::PushL( buf );

	//

	// parse xml-format pattern into C3DAudioPattern

	//

	TPtr8 ptr = buf->Ptr( 0 );

    iParser->ParseL( ptr );

    iParser->ParseEndL();

    RArray<T3DScriptUpdate> script = iParsedPattern->Script();

	if ( script.Count() == 0 )

	    {

        User::Leave( KErrNotFound );

	    }

   	CleanupStack::PopAndDestroy( buf );

	}

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

// C3DAudioXMLParser::ReadFromPatternCacheL

//

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

//		

TBool C3DAudioXMLParser::ReadFromPatternCacheL( TInt aPatternId )

	{

   	C3DPatternPS* pubSub = C3DPatternPS::NewLC( KRingingTone3DAudioEComPluginUID );

    TInt patternId = pubSub->IntL( C3DPatternPS::EKeyPatternId );

    if ( patternId == aPatternId )

        {

        // buffer for 3D pattern data

        CBufFlat* buf = pubSub->DataLC();

        // readstream to construct the pattern.

        RBufReadStream readstream( *buf );

        CleanupClosePushL( readstream );

        // create C3DAudioPattern for accessing 3D ringing tone data 

        delete iParsedPattern;

        iParsedPattern = NULL;

        iParsedPattern = C3DAudioPattern::NewL( readstream );

	    CleanupStack::PopAndDestroy( &readstream );

	    CleanupStack::PopAndDestroy( buf );

        }

	CleanupStack::PopAndDestroy( pubSub );

	if ( patternId == aPatternId )

	    {

	    return ETrue;

	    }

	return EFalse;

	}

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

// C3DAudioXMLParser::WriteToPatternCacheL

//

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

//		

void C3DAudioXMLParser::WriteToPatternCacheL( TInt aPatternId )

	{

    const TInt KGranularity = 1024;

   	C3DPatternPS* pubSub = C3DPatternPS::NewLC( KRingingTone3DAudioEComPluginUID );

    //

    // write binary-format (parsed) pattern data into descriptor

    //

    CBufFlat* buf = CBufFlat::NewL( KGranularity );

    CleanupStack::PushL( buf );

    RBufWriteStream writestream( *buf );

    CleanupClosePushL( writestream );

    iParsedPattern->ExternalizeL( writestream );

   	writestream.CommitL();

	CleanupStack::PopAndDestroy( &writestream );

#ifdef _DEBUG

    TInt oldPatternId = pubSub->IntL( C3DPatternPS::EKeyPatternId );

    FlogPatternsL( oldPatternId, aPatternId );

#endif    

    //

    // write pattern data and attributes into public and subscribe

    //

    pubSub->SetIntL( C3DPatternPS::EKeyPatternId, KErrNotFound );

	pubSub->SetIntL( C3DPatternPS::EKeyDopplerUsed, iParsedPattern->DopplerAvailable() );

	pubSub->SetIntL( C3DPatternPS::EKeyVelocity, KMotionPatternDefaultVelocity );

	pubSub->SetDataL( buf->Ptr( 0 ) );

	pubSub->SetIntL( C3DPatternPS::EKeyPatternId, aPatternId );

	CleanupStack::PopAndDestroy( buf );

	CleanupStack::PopAndDestroy( pubSub );

	}

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

// C3DAudioXMLParser::OnStartDocumentL

// Leave if error, otherwise nothing to do.

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

//	

void C3DAudioXMLParser::OnStartDocumentL( 

	const Xml::RDocumentParameters& /*aDocParam*/, 

	TInt aErrorCode )

	{

	// Leave if error occurred.

	User::LeaveIfError( aErrorCode );

	}

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

// C3DAudioXMLParser::OnEndDocumentL

// Leave if error, otherwise nothing to do.

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

//		

void C3DAudioXMLParser::OnEndDocumentL( 

	TInt aErrorCode )

	{

	// Leave if error occurred.

	User::LeaveIfError( aErrorCode );

	}

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

// C3DAudioXMLParser::OnStartElementL

// Proceed depending on the element.

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

//		

void C3DAudioXMLParser::OnStartElementL( 

	const Xml::RTagInfo& aElement, 

	const Xml::RAttributeArray& aAttributes, 

	TInt aErrorCode )

	{

	// Leave if error occurred.

	User::LeaveIfError( aErrorCode );

	CopyL( iElementName, aElement.LocalName().DesC() );

	// Proceed depending of the element.

	if ( iElementName.CompareC( KUpdateElement ) == 0 )

		{

		ProcessUpdateAttributesL( aAttributes );

		iLastTag = EUpdate;

		}

	else if ( iElementName.CompareC( KPositionElement ) == 0 )

		{

		// Do not take position in initialization in account.

		if ( iLastTag == EUpdate )

			{

			ProcessPositionAttributesL( aAttributes );

			}

		}

	else if ( iElementName.CompareC( KVelocityElement ) == 0 )

		{

		// Do not take velocity in initialization in account.

		if ( iLastTag == EUpdate )

			{

			ProcessVelocityAttributesL( aAttributes );	

			}

		}

	else if ( iElementName.CompareC( KInitElement ) == 0 )

		{

		// pasi

		// Create new motion pattern and process the attributes of it.

		delete iParsedPattern;

    	iParsedPattern = NULL;

		iParsedPattern = C3DAudioPattern::NewL();

		ProcessInitAttributesL( aAttributes );

		iLastTag = EInitialization;

		}

	else if ( iElementName.CompareC( KLoopElement ) == 0 )

		{

		ProcessLoopAttributesL( aAttributes );

		}

	}

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

// C3DAudioXMLParser::OnEndElementL

// Proceed for elements that need processing.

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

//		

void C3DAudioXMLParser::OnEndElementL( const Xml::RTagInfo& aElement, TInt aErrorCode )

	{

	// Leave if error occurred.

	User::LeaveIfError( aErrorCode );

	CopyL( iElementName, aElement.LocalName().DesC() );

	if ( iElementName.CompareC( KUpdateElement ) == 0 )

		{

		// Update-element ended, add the update to script.

		iParsedPattern->AddUpdateL( iCurrentUpdate );

		}

	else if ( iElementName.CompareC( KLoopElement ) == 0 )

		{

		// Loop-element ended, end the loop.

		iParsedPattern->EndLoop();

		}

	}

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

// C3DAudioXMLParser::OnContentL

// Leave if error, otherwise nothing to do.

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

//		

void C3DAudioXMLParser::OnContentL( const TDesC8& /*aBytes*/, TInt aErrorCode )

	{

	// Leave if error occurred.

	User::LeaveIfError( aErrorCode );