/*

* Copyright (c) 2005 - 2006 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:  SVG Implementation source file

 *

*/

#if !defined(__E32BASE_H__)

#include <e32base.h>

#endif

#include <AudioPreference.h> // For priority/pref values

#include "SVGAudioElementImpl.h"

#include "SVGDocumentImpl.h"

#include "SVGEngineImpl.h"

#include "SVGSchemaData.h"

#include "SVGTimeContainer.h"

_LIT(KAudioAMR, "audio/amr");

_LIT(KAudioAWB, "audio/amr-wb");

_LIT(KAudioMP3, "audio/mpeg");

_LIT(KAudioMP4, "audio/mp4");

_LIT(KAudio3GP, "audio/3gp");

_LIT(KAudio3G2, "audio/3g2");

_LIT(KAudioAAC, "audio/aac");

_LIT(KAudioMID, "audio/midi");

_LIT(KAudioMID2, "audio/sp-midi");

_LIT(KAudioRMF, "audio/rmf");

_LIT(KAudioRMF2, "audio/x-rmf");

_LIT(KAudioRMF3, "audio/x-beatnik-rmf");

_LIT(KAudioMXMF, "audio/mobile-xmf");

_LIT(KAudioWMA, "audio/x-ms-wma");

_LIT(KAttrAudioType,  "type" );

_LIT(KXlinkHref,  "xlink:href" );

_LIT(KDur,"dur");

_LIT(KMedia,"media");

_LIT(KAudioLevelStr,  "audio-level");

_LIT(KVolumeStr,  "volume");

// audio-level property by default is  100%

const TInt KAudioLevelDefaultPercent = 100;

const  TInt KMillisecondsPerMicrosecond = 1000;

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

// Create new element of audioelementimpl

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

CSvgAudioElementImpl* CSvgAudioElementImpl::NewL(  const TUint8 aElemID,

                                                  CSvgDocumentImpl* aDoc )

    {

    CSvgAudioElementImpl*   self    = new ( ELeave )

                                      CSvgAudioElementImpl( aDoc );

    CleanupStack::PushL( self );

    self->ConstructL(  aElemID, aDoc );

    CleanupStack::Pop();

    return self;

    }

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

// Create new element of audioelementimpl

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

CSvgAudioElementImpl* CSvgAudioElementImpl::NewLC(  const TUint8 aElemID,

                                                   CSvgDocumentImpl* aDoc )

    {

    CSvgAudioElementImpl*   self    = new ( ELeave )

                                      CSvgAudioElementImpl( aDoc );

    CleanupStack::PushL( self );

    self->ConstructL(  aElemID,aDoc );

    return self;

    }

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

// Create new element of audioelementimpl

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

void CSvgAudioElementImpl::ConstructL(  const TUint8 aElemID,

                                       CSvgDocumentImpl* /* aDoc */ )

    {

    iPercentLevelVolume = KAudioLevelDefaultPercent;

	CSvgMediaElementBase::ConstructL( aElemID );

	iStoredPos = 0;

    }

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

// Destructor for Audioelement

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

CSvgAudioElementImpl::~CSvgAudioElementImpl()

    {

	if ( iAudioPlayer )

        {

        iAudioPlayer->Stop();

   	    delete iAudioPlayer;

   	    iAudioPlayer = NULL;

        }

    if( iUri)

        {

        delete iUri;

        iUri= NULL;

        }

    }

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

// Sets attributes of audio element

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

TInt CSvgAudioElementImpl::SetAttributeL( const TDesC& aName,

                                          const TDesC& aValue )

    {

    if (!iTargetSet)

        {

	    iTargetElement = ( CSvgElementImpl * ) ParentNode();// default is parent element

		if (iTargetElement)

			{

    	    iTargetSet = ETrue;

			}

        }

    if(aName == KDur && aValue != KMedia)

        {

    	iDurMedia = EFalse;

        }

    if( aName == KXlinkHref)

        {

        this->SetXlinkAttributeL(aName,aValue);

        iUri = aValue.AllocL();        

        }

    if ( aName == KAttrAudioType )

        {

        HBufC16* tempValue = aValue.Alloc();

        TPtr16 lowercaseValue = tempValue->Des();

        lowercaseValue.LowerCase();

        if ( !( (lowercaseValue == KAudioAMR) ||

            (lowercaseValue == KAudioAWB)  ||

            (lowercaseValue == KAudioMP3)  ||

            (lowercaseValue == KAudioMP4)  ||

            (lowercaseValue == KAudio3GP)  ||

            (lowercaseValue == KAudio3G2)  ||

            (lowercaseValue == KAudioAAC)  ||

            (lowercaseValue == KAudioMID)  ||

            (lowercaseValue == KAudioMID2) ||

            (lowercaseValue == KAudioRMF)  ||

            (lowercaseValue == KAudioRMF2) ||

            (lowercaseValue == KAudioRMF3) ||

            (lowercaseValue == KAudioMXMF) ||

            (lowercaseValue == KAudioWMA) ))

                {

                iAudioStatus = EPlayerProhibit;

                }

        delete tempValue;

        }

    else if  (( aName ==  KAudioLevelStr)  || ( aName ==  KVolumeStr ))

        {

        TLex value  ( aValue );

        TReal32 volume;

        if( value.Val( volume, '.' ) == KErrNone)

            {

            iVolume = volume < 0 ? 0 : volume;

            iVolume = volume > 1 ? 1 : volume;

            }

        return KErrNone;

        }

    return CSvgMediaElementBase::SetAttributeL( aName, aValue );

    }

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

// Sets attributes of audio element

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

TInt  CSvgAudioElementImpl::SetAttributeDesL( const TInt aNameId,

											   const TDesC& aValue )

	{

	return CSvgElementImpl::SetAttributeDesL( aNameId, aValue );

    }

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

// Sets attributes of audio element

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

TInt CSvgAudioElementImpl::SetAttributeFloatL( const TInt aNameId,

                                               TFloatFixPt aValue )

    {

	return CSvgMediaElementBase::SetAttributeFloatL(aNameId,aValue);

    }

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

// Gets attributes of audio element

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

TInt CSvgAudioElementImpl::GetAttributeFloat(const TInt aNameId,

                                                TFloatFixPt& aValue )

    {

	return CSvgMediaElementBase::GetAttributeFloat(aNameId,aValue);

    }

// perform a deep clone of this object

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

// Deep Copy of the parent

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

MXmlElement* CSvgAudioElementImpl::CloneL(MXmlElement* aParentElement)

    {

    CSvgAudioElementImpl* newElement = CSvgAudioElementImpl::NewL(

        this->ElemID(), ((CSvgDocumentImpl*)iOwnerDocument) );

    CleanupStack::PushL(newElement);

    newElement->iParentNode = aParentElement;

    // copy everything over

    this->CopyL(newElement);

    CleanupStack::Pop();

    return newElement;

    }

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

// From MSvgEventReceiver

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

TBool CSvgAudioElementImpl::ReceiveEventL( MSvgEvent* aEvent )

    {

    return CSvgMediaElementBase::ReceiveEventProcL( aEvent, this );

    }

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

// CSvgAudioElementImpl::InitAnimationL

// From CSvgMediaElementBase

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

void CSvgAudioElementImpl::InitAnimationL()

    {

    CSvgMediaElementBase::InitAnimationL();

    }

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

// CSvgAudioElementImpl::ResetAnimationL

// From CSvgMediaElementBase

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

void CSvgAudioElementImpl::ResetAnimationL()

    {

	if (( iAnimStatus == KAnimActive ) ||

		( iAnimStatus == KAnimFinished) ||

		( iAnimStatus == KAnimEnd))

		{

		if (( iAudioStatus == EPlayerStatePlaying ) ||

		( iAudioStatus == EPlayerStateComplete ))

    		{

    		// Save the audio start offset

            iAudioStartOffset = 

                ( ( CSvgDocumentImpl* )iOwnerDocument)->CurrentTime();

            iStoredPos = 0;    

    		// if previously audio is still playing, and asked to play again...

        	iAudioPlayer->Stop();

            //For  Negative Begin

        	if ( iNegativeBeginTime < 0)

    	        {

    	            const TInt64 aInterval = iNegativeBeginTime * -KMillisecondsPerMicrosecond;

    	            TTimeIntervalMicroSeconds aTime(aInterval);        

    	            iAudioPlayer->SetPosition(aTime);

    	            iStoredPos = aTime;

    	        }

            //For  Negative Begin

        	iAudioPlayer->Play();

        	iAudioStatus = EPlayerStatePlaying;

    		}

		}

    }

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

// CSvgAudioElementImpl::Reset

// From CSvgMediaElementBase

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

void CSvgAudioElementImpl::Reset( MSvgEvent* aEvent )

	{

	iIsUserSeek = ETrue;

    iStoredPos = 0;

	// call the animation base function.

	TSvgTimerEvent* timerEvent  = ( TSvgTimerEvent* ) aEvent;

	if((TInt32)timerEvent->Time() < iAbsoluteBeginTime)

		{

		// let it come to initial position.

		//((CSvgDocumentImpl*)iOwnerDocument)->iInitialDrawFlag = ETrue;

		ReInitializeAnimation();

		return;

		}

	TRAPD(error,CSvgAnimationBase::ResetL( aEvent, this));

    if (error != KErrNone)

        {

        // error processing not processed

        return;

        }

	}  

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

// Call AnimaProcL

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

TBool CSvgAudioElementImpl::DoAnimProcL(MSvgEvent* aEvent)

    {

    return this->AnimProcL((MSvgTimerEvent*)aEvent);

    }

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

// From MsvgAnimationBase

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

TBool CSvgAudioElementImpl::AnimProcL( MSvgTimerEvent* /*aEvent*/ )

    {

#ifdef _DEBUG    

   	RDebug::Print(_L("%d %d"), iAnimStatus, IsAnimating());

#endif   	

    if ( iAudioStatus == EPlayerProhibit )

        return EFalse;

    if ( /*iAnimTime->DurationTime() == KTimeIndefinite ||*/ iAnimTime->DurationTime() == 0 )

        {

         return EFalse;

        }

    if ( !iAudioPlayer )

        {

    	iAudioPlayer = CMdaAudioPlayerUtility::NewL(*this);

        RDebug::Print(_L("SvgtAudioElem: Player created"));

        }

    if ( iAudioStatus != EPlayerStateIdle && !iAudioPlayer )

        {

        // Error case, when player is initialised but

        // iAudioPlayer pointer is NULL.

        return EFalse;

        }

    if( iAnimStatus != KAnimActive )

        {

        if ( iAudioStatus == EPlayerStatePlaying )

    		{

    		iStoredPos = 0;

        	iAudioPlayer->Stop();

        	iAudioStatus = EPlayerStateStop;

        	return EFalse;

    		}

        }

    else //iAnimStatus == KAnimActive

        {

        if ( !iHadBegun )

            {

            iHadBegun = ETrue;

            // Save the time the audio element starts

            iAudioStartOffset = 

                ( ( CSvgDocumentImpl* )iOwnerDocument)->CurrentTime();

            // this is a restart from begin list.

            if ((iAudioStatus != EPlayerStateIdle) &&

            	(iAudioStatus != EPlayerStatePlayInit))

            	{

		    	iStoredPos = 0;

		    	iAudioPlayer->Stop();

		    	iAudioPlayer->Play();

		    	iAudioStatus = EPlayerStatePlaying;

            	}

            return ETrue;

         }

        if ( iAudioStatus == EPlayerStateIdle ) // stopped

        {

        // Indicate to the time container that audio element 

        // is not ready

        ( ( CSvgDocumentImpl* )

            iOwnerDocument )->TimeContainer()->TimedEntityNotReady( 

            this );

        // Save the audio start offset

        iAudioStartOffset = 

            ( ( CSvgDocumentImpl* )iOwnerDocument)->CurrentTime();

        TPtrC href = Href();

        #ifdef _DEBUG            

        RDebug::Print(_L("CSvgAudioElementImpl::NewFilePlayerL is to be called"));

        RDebug::RawPrint(href);

        #endif           	           	

        //Check and load file here

        RFs  session;

        CSvgErrorImpl* SvgError  =  CSvgErrorImpl::NewL();

        CSvgDocumentImpl::OpenSession( session,  *SvgError  );

        RFile fileHandle;

        CSvgDocumentImpl* document = (CSvgDocumentImpl*)OwnerDocument();

        CSvgEngineImpl* engine  = document->Engine();

        MSvgRequestObserver* lRequestObserver = NULL;

        TInt lFetchStatus = KErrNone;

        if(engine!= NULL)

            {

            lRequestObserver =  engine->iRequestObserver;

            }

        else

            {

            return EFalse;

            }

        if(lRequestObserver != NULL)

            {

            lFetchStatus = lRequestObserver->FetchImage( *iUri, session, fileHandle );

            }

        else

            {

            return EFalse;

            }

        if(lFetchStatus == KErrNone)

         {

         iAudioPlayer->OpenFileL(fileHandle);

         }

           else

             {

             return EFalse;

             }

        if(SvgError) 

         {

         delete SvgError;

         }

        session.Close();

        iAudioStatus = EPlayerStatePlayInit;  	

        #ifdef _DEBUG       		

        RDebug::Print(_L("SvgtAudioElem: File opened"));

        #endif           	

        return ETrue;

        }

        if( iAudioStatus == EPlayerStateStop && iTcCommandState != ESvgTEPausedState)

        {

        		iAudioStartOffset = 

                ( ( CSvgDocumentImpl* )iOwnerDocument)->CurrentTime();

            // if previously audio is still playing, and asked to play again...

        	iAudioPlayer->Play();

        	iAudioStatus = EPlayerStatePlaying;

            }

        }

        return ETrue;

    }

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

// Set the volume of the Audio Player to the specified level

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

void CSvgAudioElementImpl::SetVolume(TInt aPercentage)

    {

    if(

    iAudioPlayer && 

    (iAudioStatus != EPlayerStateIdle && iAudioStatus != EPlayerStatePlayInit && iAudioStatus != EPlayerProhibit)

    )

        {

        TInt lVolLevel = 0;

        // Check if within limits

        if  ( aPercentage > 0  && aPercentage <= 100 )

            {

#ifdef __WINSCW__            

            const TReal32 KMaxAudioVolumeLevels = 65535;

#else

            const TReal32 KMaxAudioVolumeLevels = iAudioPlayer->MaxVolume();

#endif   

            // Calculating the volume based on system volume & element volume

            TReal32 lRealLevel = ((TReal32)aPercentage/100.0) * KMaxAudioVolumeLevels * iVolume;

            lVolLevel = lRealLevel;

            }

        iAudioPlayer->SetVolume(lVolLevel);

        }

    iPercentLevelVolume = aPercentage;

    }

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

// From CMdaAudioPlayerUtility

// Callback from Audio Player indicating the audio has finished initalisation

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

void CSvgAudioElementImpl::MapcInitComplete(TInt aError,

                const TTimeIntervalMicroSeconds& aDuration)

	{

	if ( aError == KErrNone )

	    {

       	if(iDurMedia)

          	{

            TTimeIntervalMicroSeconds durInMicroS;

            durInMicroS   = aDuration;

            TInt32 durInMilliS;

            durInMilliS  =  durInMicroS.Int64()  /  KMillisecondsPerMicrosecond;

            iAnimTime->SetDurationTime(durInMilliS);

            //In ReInitialize function of AnimTimeController

            // the duration is reinitialized from Org Duration

            iAnimTime->SetOrgDurationTime(durInMilliS);

           	}

#ifdef _DEBUG           	

    	RDebug::Print(_L("CSvgAudioElementImpl::MapcInitComplete :-> Open audio file OK!"));

#endif    	

    	iMediaDuration = aDuration;

        TInt lVolLevel = 0;

        // Check if within limits

        if  ( iPercentLevelVolume > 0  && iPercentLevelVolume <= 100 )

            {

#ifdef __WINSCW__            

            const TReal32 KMaxAudioVolumeLevels = 65535;

#else

            const TReal32 KMaxAudioVolumeLevels = iAudioPlayer->MaxVolume();

#endif            

            // Calculating the volume based on system volume & element volume

            TReal32 lRealLevel = ((TReal32)iPercentLevelVolume/100.0) * KMaxAudioVolumeLevels * iVolume;

            lVolLevel = lRealLevel;

            }

        iAudioPlayer->SetVolume(lVolLevel);

        // If the pause command was issued do not play, the resume should set 

        // it playing

        if(iTcCommandState == ESvgTEPlayingState)

            {

#ifdef _DEBUG            

            RDebug::Print(_L("To play"));