/*
* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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:  Controller class for handling browser requests to play video   
*
*/


// INCLUDE FILES
#include <AudioPreference.h>        // For priority/pref values
#include <mmf/common/mmferrors.h>

#include "BavpLogger.h"
#include "BavpControllerAudio.h"
#include "BavpView.h"

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

// -----------------------------------------------------------------------------
// CBavpControllerAudio::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
CBavpControllerAudio* CBavpControllerAudio::NewL( MBavpView* aView,
                                                  TUint aAccessPtId,
                                                  TBavpMediaType aMediaType,
                                                  const TDesC& aFileName )
    {
    CBavpControllerAudio* self = new( ELeave ) CBavpControllerAudio( aView, aAccessPtId );

    Log( EFalse, _L("CBavpControllerAudio::NewL this="), (TInt)self );

    CleanupStack::PushL( self );
    self->ConstructL( aMediaType, aFileName );
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CBavpControllerAudio::~CBavpControllerAudio()
// Destructor
// -----------------------------------------------------------------------------
CBavpControllerAudio::~CBavpControllerAudio()
    {
    Log( EFalse, _L("CBavpControllerAudio::~CBavpControllerAudio") );

    // If currently playing, call Stop before you close and delete
    if ( iCurrentState == EBavpPlaying && iAudioPlayer != NULL)
        {
        iAudioPlayer->Stop();
        }
    if ( iAudioPlayer )
        {
        iAudioPlayer->Close();
        delete iAudioPlayer;
        }

    iFs.Close();
    }

// -----------------------------------------------------------------------------
// CBavpControllerAudio::CBavpControllerAudio
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
CBavpControllerAudio::CBavpControllerAudio( MBavpView* aView,
                                            TUint aAccessPtId )
    : CBavpController( aView, aAccessPtId )
    {
    }

// -----------------------------------------------------------------------------
// CBavpControllerAudio::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
void CBavpControllerAudio::ConstructL( TBavpMediaType aMediaType,
                                       const TDesC& aFileName )
    {
    // Construct the BavpController base class
    BaseConstructL( aMediaType, aFileName );

    // Create Audio Player Client:
    iAudioPlayer = CMdaAudioPlayerUtility::NewL( *this, KAudioPriorityRealOnePlayer,
                        TMdaPriorityPreference( KAudioPrefRealOneLocalPlayback ) );
    
    // Connect to file server:
    User::LeaveIfError( iFs.Connect() );
    }

// -----------------------------------------------------------------------------
// CBavpControllerAudio::OpenAudioUrlL
// Open the audio url link
// -----------------------------------------------------------------------------
void CBavpControllerAudio::OpenAudioUrlL()
    {
    Log( EFalse, _L("CBavpControllerAudio::OpenUrlL() ") );

    // Note: Play() is called from MapcInitComplete()
    iAudioPlayer->OpenUrlL( *iClipInfo->iUrl, iAccessPtId, KNullDesC8 );
    }

// -----------------------------------------------------------------------------
// CBavpControllerAudio::OpenAudioFileL
// Open the audio file
// -----------------------------------------------------------------------------
void CBavpControllerAudio::OpenAudioFileL()
    {
    Log( EFalse, _L("CBavpControllerAudio::OpenFileL() ") );

    // Note: Play() is called from MapcInitComplete()
    iAudioPlayer->OpenFileL( *iClipInfo->iFileName );
    }

// -----------------------------------------------------------------------------
// CBavpControllerAudio::PlayAudioVideoL
// Handles request to open and play an audio or video file
// TDesC& aFilename: Name of audio file, or video file, or URL link
// -----------------------------------------------------------------------------
void CBavpControllerAudio::PlayAudioVideoL()
    {
    Log( EFalse, _L("CBavpControllerAudio::OpenAndPlayL() ") );

    // If currently playing, call Stop before you attempt to open and play
    if ( iCurrentState == EBavpPlaying )
        {
        Stop();
        }

    OpenAudioFileL();
    }

// -----------------------------------------------------------------------------
// CBavpControllerAudio::Stop
// Stops audio from playing, if playing.
// -----------------------------------------------------------------------------
void CBavpControllerAudio::Stop()
    {
    Log( EFalse, _L("CBavpControllerAudio::Stop") );

    iAudioPlayer->Stop();
    iClipInfo->iPosition = 0;
    iAudioPlayer->SetPosition( iClipInfo->iPosition );
    iCurrentState = EBavpStopped;

    iBavpView->UpdateView();
    }

// -----------------------------------------------------------------------------
// CBavpControllerAudio::Play
// Non leaving method to play audio
// -----------------------------------------------------------------------------
void CBavpControllerAudio::Play()
    {
    // To keep LeaveScan from complaining everwhere, we use this non leaving
    // method
    TRAP_IGNORE( PlayL() );
    }
    
// -----------------------------------------------------------------------------
// CBavpControllerAudio::PlayL
// Plays audio
// -----------------------------------------------------------------------------
void CBavpControllerAudio::PlayL()
    {
    Log( EFalse, _L("CBavpControllerAudio::PlayL") );
    
    SetPlayerVolume( iCurrentVolume );

    // Handle multiple media object case
    if ( iBavpControllerArray.Count() > 1 && IsAnotherControllerPlaying() )
        {
        if ( iLastCommand == EBavpCmdPlay )
            {
            // Another controller is playing, and the user wants to play
            // this media object. Pause (or stop) all of the others and
            // play this one.
            PauseOtherControllersPlaying();
            }
        }

    iAudioPlayer->SetPosition( iClipInfo->iPosition );
    iAudioPlayer->Play();
    iCurrentState = EBavpPlaying;

    iBavpView->UpdateView();
    }

// -----------------------------------------------------------------------------
// CBavpControllerAudio::Pause
// Non leaving method to pause playing audio
// -----------------------------------------------------------------------------
void CBavpControllerAudio::Pause()
    {
    // To keep LeaveScan from complaining everwhere, we use this non leaving
    // method
    TRAP_IGNORE( PauseL() );
    }
    
// -----------------------------------------------------------------------------
// CBavpControllerAudio::PauseL
// Pauses video while playing, if playing.
// -----------------------------------------------------------------------------
void CBavpControllerAudio::PauseL()
    {
    Log( EFalse, _L("CBavpControllerAudio::PauseL") );

    if ( IsClipSeekable() && 
        (iCurrentState == EBavpPlaying || iCurrentState == EBavpPaused))
        {
        // Save clip position, in case we want to resume playing
        iAudioPlayer->GetPosition(iClipInfo->iPosition);
        iAudioPlayer->Pause();
        iCurrentState = EBavpPaused;
        }
    else
        {
        // Not seekable content, i.e. Live stream
        iAudioPlayer->Stop();
        iClipInfo->iPosition = 0;
        iCurrentState = EBavpStopped;
        }

    iBavpView->UpdateView();
    }

// -----------------------------------------------------------------------------
// CBavpControllerAudio::FastForwardL
// Fast forwards the audio
// -----------------------------------------------------------------------------
void CBavpControllerAudio::FastForwardL()
    {
    }
    
// -----------------------------------------------------------------------------
// CBavpControllerAudio::RewindL
// Rewinds the audio
// -----------------------------------------------------------------------------
void CBavpControllerAudio::RewindL()
    {
    }

// -----------------------------------------------------------------------------
// CBavpControllerAudio::SetPlayerVolume
// Calculate the player volume from the CR volume (aka BavpController
// volume value) and sets it
// -----------------------------------------------------------------------------
void CBavpControllerAudio::SetPlayerVolume( TInt aVolume )
    {
    TInt playerVolume( 0 );
    if ( iPlayerInitialized )
        {
        TInt maxVolume = iAudioPlayer->MaxVolume();
        if (aVolume < 0)
          {
          playerVolume = 0;
          }
        else if (aVolume > maxVolume)
          {
          playerVolume = maxVolume;
          }
        else 
          {
          // The CR volume is 0-10, convert to Audio player volume 0-100
          playerVolume = ( aVolume * iPlayerMaxVolume ) / KCRVolumeMax;     
          }
    
        // Set Video player volume
        iAudioPlayer->SetVolume( playerVolume );
      }
    }

// -----------------------------------------------------------------------------
// CBavpControllerAudio::GetPlayerVolume
// Calculate the player volume value and sets the playback volume for the audio 
// track of the video clip.
// -----------------------------------------------------------------------------
TInt CBavpControllerAudio::GetPlayerVolume()
    {
    TInt playerVolume( 0 );
    TInt CRVolume( 0 );
    
    if ( iPlayerInitialized )
        {
        // Audio player returns 0-100 
        iAudioPlayer->GetVolume( playerVolume );

        // Convert to CR volume 0-10
        CRVolume = ( playerVolume * KCRVolumeMax ) / iPlayerMaxVolume;
        }

    return CRVolume;
    }

// --------------------------------------------------------------------------
// CBavpControllerAudio::HandleError
// Handle error codes. We can receive errors from the MMF Video Player
// and its MMF callbacks (mvpuoPlayComplete, etc).
// The MMF errors are for handling content issues, such as decoding content
// and network access.
// NOTES:
// MMF errors start at -12000, see /epoc32/include/mmf/common/MMFErrors.h
// MMF also returns -1 (KErrNotFound) and few other system-wide errors
// -----------------------------------------------------------------------------
void CBavpControllerAudio::HandleError( TInt aError )
    {
    Log( EFalse, _L("In CBavpControllerAudioo::HandleError(): err="), aError );
    
    switch ( aError )
        {
        case KErrMMVideoDevice:
        case KErrMMAudioDevice:
            // We get this when the controllers can only support
            // playing one media at a time.
            HandleMultiInstanceError();
            break;

        default:
            iCurrentState = EBavpBadContent;
            iBavpView->UpdateView();
            break;
        }
    }
    
// -----------------------------------------------------------------------------
// CBavpControllerAudio::MapcInitComplete
// Required due to MMdaAudioPlayerCallback derivation.
// Called by client to indicate initialization has completed and device is ready
// to play.
// -----------------------------------------------------------------------------
void CBavpControllerAudio::MapcInitComplete( TInt aError,
                                const TTimeIntervalMicroSeconds& /*aDuration */ )
    {
    Log( EFalse, _L("MapcInitComplete aError="), aError );

    // Check for error
    if ( aError != KErrNone )
        {
        HandleError( aError );
        return;
        }

    // Audio player is initialized, so we can interact with it, volume,
    iPlayerInitialized = ETrue;
    
    iClipInfo->iDurationInSeconds = iAudioPlayer->Duration();
    iClipInfo->iPosition = 0;
    iAudioPlayer->SetPosition( iClipInfo->iPosition );
    
    // Get the max player volume, so we can scale volume
    iClipInfo->iMaxVolume = iAudioPlayer->MaxVolume();
    iPlayerMaxVolume = iClipInfo->iMaxVolume;

    // Handle multiple media object case
    if ( iBavpControllerArray.Count() > 1 && IsAnotherControllerPlaying() )
        {
        if ( iLastCommand == EBavpCmdUnknown )
            {
            // Another controller is playing, and this controller was
            // initializing. Because we can only play one media object at a
            // time, stop this media and let the first one
            // initialized continue to play.
            Stop();
            }
        else if ( iCurrentState == EBavpPlaying && iLastCommand == EBavpCmdPlay )
            {
            // Another controller is playing, and the user wants to play
            // another media object. Pause (or stop) all of the others and
            // play this one.
            PauseOtherControllersPlaying();
            Play();
            }
        }
    // Handle the single media object case
    else
        {
        Play();        
        }

    // Stop the buffering animation and play the audio only animation
    iBavpView->UpdateView();
    }

// -----------------------------------------------------------------------------
// CBavpControllerAudio::MapcPlayComplete
// Required due to MMdaAudioPlayerCallback derivation.
// Called by client to indicate audio file has completed or has stopped playing.
// -----------------------------------------------------------------------------
void CBavpControllerAudio::MapcPlayComplete( TInt aError )
    {
    Log( EFalse, _L("MapcPlayComplete aError="), aError );
    
    if ( iInfiniteLoopFlag )
        {
        // If infinite flag set: play audio again and again...
        iClipInfo->iPosition = 0;
        Play();
        }
    else if ( ( iLoopCount - 1 ) > 0 )
        {
        // If loop count: play, decrement loop count, play again...
        iClipInfo->iPosition = 0;
        Play();
        iLoopCount-- ;
        }
    else
        {
        // We're done looping, or just done playing the audio
        iCurrentState = EBavpPlayComplete;
        iClipInfo->iPosition = 0;
        iLoopCount = iInitLoopCount;

        iBavpView->UpdateView();
        }
    }
    
// -----------------------------------------------------------------------------
// CBavpControllerAudio::getPositionL
// To get the current position of the clip
// -----------------------------------------------------------------------------
    
 TTimeIntervalMicroSeconds CBavpControllerAudio::getPositionL() 
    {
        if ( iAudioPlayer )
        {
            TTimeIntervalMicroSeconds pos;
            iAudioPlayer->GetPosition( pos );
            return pos;
        }
        return NULL;
    }
    
 // -----------------------------------------------------------------------------
// CBavpControllerAudio::setPositionL
// To set the position of the clip
// -----------------------------------------------------------------------------
    
  void CBavpControllerAudio::setPositionL( TTimeIntervalMicroSeconds val )    
    {
        if ( iAudioPlayer )
        {

            if ( !IsClipSeekable() && !IsClipLocalMedia() )
            {
                return;
            }
            
            TBool didWePause = EFalse;
            // If playing, pause it (PauseL stops the PositionUpdater)
            if ( iCurrentState == EBavpPlaying )
            {
                PauseL();
                didWePause = ETrue;
            }
            
            if ( (val > iClipInfo->iDurationInSeconds ) || (val < 0) ) 
            {
                val = 0;    
            }
                
            iAudioPlayer->SetPosition(val);
            iClipInfo->iPosition = val;
            if ( didWePause )
            {
                PlayL();
            }
        }
    }


//  End of File