/*
* Copyright (c) 2003-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:  
*       SMIL Player media renderer for playing audio files
*
*/



#include <mdaaudiosampleplayer.h>
#include <AudioPreference.h>
#include <smilpresentation.h>
#include <mmf/common/mmcaf.h>

#include "SmilAudioRenderer.h"

#ifdef AUDIO_DEBUG
    #include "SmilMediaLogging.h"
#endif

// ----------------------------------------------------------------------------
// CSmilAudioRenderer::CSmilAudioRenderer
// Constructor
// ----------------------------------------------------------------------------
CSmilAudioRenderer::CSmilAudioRenderer( MSmilMedia* aMedia,
                                        DRMCommon& aDrmCommon,
                                        CDRMHelper& aDrmHelper ) : 
    CSmilMediaRendererBase( EMsgMediaAudio, aMedia, aDrmCommon, aDrmHelper ),
    iIntrinsicDuration( TSmilTime::KUnresolved ),
    iState( ENotReady ),
    iError( KErrNone ),
    iRendererAtEnd( EFalse )
    {
    }

// ----------------------------------------------------------------------------
// CSmilAudioRenderer::ConstructL
// ----------------------------------------------------------------------------
void CSmilAudioRenderer::ConstructL( RFile& aFileHandle )
    {
#ifdef AUDIO_DEBUG
    SMILUILOGGER_ENTERFN( "[SMILUI] Audio: ConstructL" );
#endif

    BaseConstructL( aFileHandle );
    User::LeaveIfError( CheckDRMRights() );
    
    User::LeaveIfError( iMediaFile.Duplicate( aFileHandle ) );
    
    iAudioPlayer = CMdaAudioPlayerUtility::NewL( *this,
                                                 KAudioPrioritySmilPlayer,
                                                 TMdaPriorityPreference( KAudioPrefSmilPlayer ) );
    iState = EOpening;
     
    TMMFileHandleSource fileHandleSource( aFileHandle, KDefaultContentObject, ContentAccess::EPeek );
    iAudioPlayer->OpenFileL( fileHandleSource );

    //start active wait
    BeginActiveWait();

#ifdef AUDIO_DEBUG
    SMILUILOGGER_WRITEF( _L("[SMILUI] Audio: iError=%d"), iError );
#endif

    User::LeaveIfError( iError );

    MMMFDRMCustomCommand* customCommand = iAudioPlayer->GetDRMCustomCommand();
    if ( customCommand )
        {
        customCommand->DisableAutomaticIntent( ETrue );            
        }

    if ( iMedia && iMedia->Presentation() )
        {
        // this is a persentage value, [0..100]
        TInt volume = iMedia->Presentation()->Volume();
        
#ifdef AUDIO_DEBUG
        SMILUILOGGER_WRITEF( _L("Audio: Presentation volume, volume=%d"), volume );
        SMILUILOGGER_WRITEF( _L("Audio: iAudioPlayer->SetVolume(), volume=%d"),
                                ( ( iAudioPlayer->MaxVolume() * volume ) / 100 ) );
#endif

        iAudioPlayer->SetVolume( ( iAudioPlayer->MaxVolume() * volume ) / 100 );    
        }
        
#ifdef AUDIO_DEBUG
    SMILUILOGGER_LEAVEFN( "[SMILUI] Audio: ConstructL" );
#endif
    }


// ----------------------------------------------------------------------------
// CSmilAudioRenderer::NewL
// ----------------------------------------------------------------------------
CSmilAudioRenderer* CSmilAudioRenderer::NewL( RFile& aFileHandle,
                                              MSmilMedia* aMedia,
                                              DRMCommon& aDrmCommon,
                                              CDRMHelper& aDrmHelper )
    {
    CSmilAudioRenderer* renderer = new(ELeave) CSmilAudioRenderer( aMedia, 
                                                                   aDrmCommon, 
                                                                   aDrmHelper );       
    CleanupStack::PushL( renderer );
    renderer->ConstructL( aFileHandle );
    CleanupStack::Pop( renderer );
    return renderer;
    }

// ----------------------------------------------------------------------------
// CSmilAudioRenderer::~CSmilAudioRenderer
// ----------------------------------------------------------------------------
CSmilAudioRenderer::~CSmilAudioRenderer()
    {
#ifdef AUDIO_DEBUG
    SMILUILOGGER_ENTERFN( "[SMILUI] Audio: destructor" );
#endif
    if ( iAudioPlayer )
        {
        iAudioPlayer->Close();
        delete iAudioPlayer;
        }
    
    iMediaFile.Close();    
    iMedia = NULL; // For LINT
    }

// ----------------------------------------------------------------------------
// CSmilAudioRenderer::IntrinsicDuration
// ----------------------------------------------------------------------------
TSmilTime CSmilAudioRenderer::IntrinsicDuration() const
    {
#ifdef AUDIO_DEBUG
    SMILUILOGGER_ENTERFN( "[SMILUI] Audio: IntrinsicDuration()" );
    SMILUILOGGER_WRITEF( _L("[SMILUI] Audio: IntrinsicDuration, dur=%d"),
                         iIntrinsicDuration.Value() );
#endif
    return iIntrinsicDuration;
    }

// ----------------------------------------------------------------------------
// CSmilAudioRenderer::PrepareMediaL
// ----------------------------------------------------------------------------
void CSmilAudioRenderer::PrepareMediaL()
    {
#ifdef AUDIO_DEBUG
    SMILUILOGGER_ENTERFN( "[SMILUI] Audio: PrepareMediaL" );
    SMILUILOGGER_WRITEF( _L("[SMILUI] Audio: iState=%d"), iState );
#endif
    
    if ( iState == ENotReady )
        {
#ifdef AUDIO_DEBUG
        SMILUILOGGER_WRITEF( _L("SMILUI: Using late preparation") );
#endif
        
        iError = KErrNone;
        
        iAudioPlayer->OpenFileL( iMediaFile );
        BeginActiveWait();
        }
       
#ifdef AUDIO_DEBUG
    SMILUILOGGER_WRITEF( _L("SMILUI: Audio, State = %d"), iState );
    SMILUILOGGER_LEAVEFN( "Audio: PrepareMediaL" );
    SMILUILOGGER_WRITEF( _L(""));
#endif
    }

// ----------------------------------------------------------------------------
// CSmilAudioRenderer::SeekMediaL
// ----------------------------------------------------------------------------
void CSmilAudioRenderer::SeekMediaL( const TSmilTime& aTime )
    {
#ifdef AUDIO_DEBUG
    SMILUILOGGER_ENTERFN( "[SMILUI] Audio: SeekMediaL" );
    SMILUILOGGER_WRITEF( _L("[SMILUI] Audio: SeekMediaL, time=%d, iState=%d"),
                         aTime.Value(), iState );
#endif
    iAudioPlayer->SetPosition( aTime.ToMicroSeconds() );

    if( aTime == 0 && 
        iRendererAtEnd && 
        iState == EPlaying )
        {
#ifdef AUDIO_DEBUG
        SMILUILOGGER_WRITE( "[SMILUI] Audio: iAudioPlayer->Play() in SeekMediaL()" );
#endif
        iAudioPlayer->Play();
        iRendererAtEnd = EFalse;
        }
    }

// ----------------------------------------------------------------------------
// CSmilAudioRenderer::ShowMediaL
// ----------------------------------------------------------------------------
void CSmilAudioRenderer::ShowMediaL()
    {
#ifdef AUDIO_DEBUG
    SMILUILOGGER_ENTERFN( "[SMILUI] Audio: ShowMedia" );
    SMILUILOGGER_WRITEF( _L("[SMILUI] Audio: iState=%d"), iState );
#endif
    if( iState == EOpen ||
        iState == EHidden )
        {       
#ifdef AUDIO_DEBUG
        SMILUILOGGER_WRITE( "[SMILUI] Audio: iAudioPlayer->Play() in ShowMedia" );
#endif
        ConsumeDRMRightsL();
        if ( iMedia->Presentation()->State() == CSmilPresentation::EPlaying )
            {
            iAudioPlayer->Play();
            iState = EPlaying;
            }
        else
            {
            iState = EPaused;
            }
        }
    }

// ----------------------------------------------------------------------------
// CSmilAudioRenderer::HideMedia
// ----------------------------------------------------------------------------
void CSmilAudioRenderer::HideMedia()
    {
#ifdef AUDIO_DEBUG
    SMILUILOGGER_ENTERFN( "[SMILUI] Audio: HideMedia" );
    SMILUILOGGER_WRITEF( _L("[SMILUI] Audio: iState=%d"), iState );
#endif
    if( iState == EPlaying ||
        iState == EPaused )
        {
#ifdef AUDIO_DEBUG
        SMILUILOGGER_WRITE( "[SMILUI] Audio: iAudioPlayer->Stop()" );
#endif
        iAudioPlayer->Stop();
        iState = EHidden;
        }
    else
        {
#ifdef AUDIO_DEBUG
        SMILUILOGGER_WRITE( "[SMILUI] Audio: Not EPlaying/EPaused -> No Stop()!" );
#endif
        }
    }

// ----------------------------------------------------------------------------
// CSmilAudioRenderer::FreezeMedia
// ----------------------------------------------------------------------------
void CSmilAudioRenderer::FreezeMedia()
    {
#ifdef AUDIO_DEBUG
    SMILUILOGGER_ENTERFN( "[SMILUI] Audio: FreezeMedia" );
    SMILUILOGGER_WRITEF( _L("[SMILUI] Audio: iState=%d"), iState );
#endif
    if ( iState == EPlaying )
        {
#ifdef AUDIO_DEBUG
        SMILUILOGGER_WRITE( "[SMILUI] Audio: iAudioPlayer->Pause()" );
#endif
        TInt err = iAudioPlayer->Pause();
        if ( !err )
            {
            iState = EPaused;
            }
        }          
#ifdef AUDIO_DEBUG
    SMILUILOGGER_LEAVEFN( "[SMILUI] Audio: FreezeMedia" );
#endif
    }

// ----------------------------------------------------------------------------
// CSmilAudioRenderer::ResumeMedia
// ---------------------------------------------------------------------------
void CSmilAudioRenderer::ResumeMedia()
    {
#ifdef AUDIO_DEBUG
    SMILUILOGGER_ENTERFN( "[SMILUI] Audio: ResumeMedia" );
    SMILUILOGGER_WRITEF( _L("[SMILUI] Audio: iState=%d"), iState );
#endif
    if( iState == EPaused )
        {
#ifdef AUDIO_DEBUG
    SMILUILOGGER_WRITE( "[SMILUI] Audio: iAudioPlayer->Play() in ResumeMedia" );
#endif 
        iAudioPlayer->Play();
        iState = EPlaying;
        }
#ifdef AUDIO_DEBUG
    SMILUILOGGER_LEAVEFN( "[SMILUI] Audio: ResumeMedia" );
#endif

    }

// ----------------------------------------------------------------------------
// CSmilAudioRenderer::SetVolume
// ----------------------------------------------------------------------------
void CSmilAudioRenderer::SetVolume( TInt aVolume )
    {
#ifdef AUDIO_DEBUG
    SMILUILOGGER_WRITEF( _L("[SMILUI] Audio: SetVolume, volume=%d"), aVolume );
    SMILUILOGGER_WRITEF( _L("[SMILUI] Audio: iAudioPlayer->SetVolume(), volume=%d"),
                            ( ( iAudioPlayer->MaxVolume() * aVolume ) / 100 ) );
#endif
    // Presentation uses range [0..100]
    iAudioPlayer->SetVolume( ( iAudioPlayer->MaxVolume() * aVolume ) / 100 ); 
    }

// ----------------------------------------------------------------------------
// CSmilAudioRenderer::MapcInitComplete
// ----------------------------------------------------------------------------
void CSmilAudioRenderer::MapcInitComplete(
                            TInt aError,
                            const TTimeIntervalMicroSeconds& aDuration )
    {
#ifdef AUDIO_DEBUG
    SMILUILOGGER_ENTERFN( "[SMILUI] Audio: MapcInitComplete" );
    SMILUILOGGER_WRITEF( _L("[SMILUI] Audio: error=%d"), aError );
    SMILUILOGGER_WRITEF( _L("[SMILUI] Audio: iState=%d"), iState );
#endif

    if ( aError )
        {
        iError = aError;
        iState = ENotReady;                
        }
    else
        {
        iState = EOpen;
        iIntrinsicDuration = TSmilTime::FromMicroSeconds( aDuration );            

#ifdef AUDIO_DEBUG
        SMILUILOGGER_WRITE( "[SMILUI] Audio: iMedia->RendererDurationChangedL()" );
#endif
        TRAPD( error, iMedia->RendererDurationChangedL() );
        if ( error != KErrNone )
            {
#ifdef AUDIO_DEBUG
            SMILUILOGGER_WRITEF( _L("[SMILUI] Audio: RendererDurationChangedL=%d"), error );
#endif
            iError = error;
            iState = ENotReady;
            }
        }

    EndActiveWait();

#ifdef AUDIO_DEBUG
    SMILUILOGGER_LEAVEFN( "[SMILUI] Audio: MapcInitComplete" );
#endif
    }

// ----------------------------------------------------------------------------
// CSmilAudioRenderer::MapcPlayComplete
// ----------------------------------------------------------------------------
void CSmilAudioRenderer::MapcPlayComplete( TInt aError )
    {
#ifdef AUDIO_DEBUG
    SMILUILOGGER_ENTERFN( "[SMILUI] Audio: MapcPlayComplete()" );
    SMILUILOGGER_WRITEF( _L("[SMILUI] Audio: MapcPlayComplete, error=%d"),
                         aError );
    SMILUILOGGER_WRITEF( _L("[SMILUI] Audio: iState=%d"), iState );
#endif
    if ( aError != KErrNone )
        {
        iError = aError;
        //if error goto end
        iRendererAtEnd = ETrue;
        TRAPD( error, iMedia->RendererAtEndL() );
        if ( error != KErrNone )
            {
            iError = error;
            }
        }
    else
        {

#ifdef AUDIO_DEBUG
        SMILUILOGGER_WRITE( "[SMILUI] Audio: iMedia->RendererAtEndL()" );
#endif
        TRAPD( error, iMedia->RendererAtEndL() );
        if( !error )
            {
            iRendererAtEnd = ETrue;
            }
        }
#ifdef AUDIO_DEBUG
    SMILUILOGGER_LEAVEFN( "[SMILUI] Audio: MapcPlayComplete" );
#endif
    }

// End of File