/*
* Copyright (c) 2006-2007 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:  Implementation of streaming and playback on ASF channel url
*
*/


/* ---------------------------------------------------------------------------
*  Version history:
*  Template version:
*  <ccm_history>
*
*  Version: 1, Fri Sep 19 13:00:00 2008 by e0328782 Rohit
*  Ref:
*  Created
*
*  </ccm_history>
* ============================================================================
*/

#include <e32property.h>
#include "irpubsubkeys.h"

#include "irasfplayer.h"				// this class
#include "irctrlcommand.h"				// MIRCtrlCmdObserver
#include "irstreamsourceobserver.h"		// MIRStreamSourceObserver
#include "irdebug.h"
#include "irmetadata.h"

//Constants
_LIT8( KMimeTypeASF, "audio/x-ms-wma" );
const TInt KFour = 4;
_LIT( KIRSongTitle, "title" );
_LIT( KIRSongArtist, "artist" );
_LIT( KTrailingAsf, ".asf" );
_LIT( KTrailingWma, ".wma" );
_LIT( KTrailingWmv, ".wmv" );


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

// ---------------------------------------------------------------------------
// CIRAsfPlayer::NewL
// function returns an instance of CIRAsfPlayer
// Two phase constructor
// ---------------------------------------------------------------------------
//
EXPORT_C CIRAsfPlayer* CIRAsfPlayer::NewL(MIRStreamSourceObserver& aStreamObserver,
										  MIRCtrlCmdObserver& aCtrlCmdObserver)
	{
	IRLOG_DEBUG( "CIRAsfPlayer::NewL" );
	CIRAsfPlayer* self = CIRAsfPlayer::NewLC(aStreamObserver, aCtrlCmdObserver );
	CleanupStack::Pop(self);
	IRLOG_DEBUG( "CIRAsfPlayer::NewL - Exiting." );
	return self;
	}

// ---------------------------------------------------------------------------
// CIRAsfPlayer::NewLC
// function creates an instance of CIRAsfPlayer
// Two phase constructor
// ---------------------------------------------------------------------------
//
CIRAsfPlayer* CIRAsfPlayer::NewLC(MIRStreamSourceObserver& aStreamObserver,
								  MIRCtrlCmdObserver& aCtrlCmdObserver)
	{
	IRLOG_DEBUG( "CIRAsfPlayer::NewLC" );
	CIRAsfPlayer* self = new (ELeave) CIRAsfPlayer(aStreamObserver, aCtrlCmdObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	IRLOG_DEBUG( "CIRAsfPlayer::NewLC - Exiting." );
	return self;
	}

// ---------------------------------------------------------------------------
// CIRAsfPlayer::~CIRAsfPlayer
// Default Destructor
// ---------------------------------------------------------------------------
//
CIRAsfPlayer::~CIRAsfPlayer()
	{
	IRLOG_DEBUG( "CIRAsfPlayer::~CIRAsfPlayer" );
    if( iMdaAudioPlayer )
	    {
	    delete iMdaAudioPlayer;
	    iMdaAudioPlayer = NULL;
	    }

	if( iMetaData )
		{
		delete 	iMetaData;
		iMetaData = NULL;
		}
	iStationUri.Close();

	IRLOG_DEBUG( "CIRAsfPlayer::~CIRAsfPlayer - Exiting." );
	}

//Function for Play control

// ---------------------------------------------------------------------------
// CIRAsfPlayer::PlayL
// function to intiate the player and play the stream
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRAsfPlayer::PlayL(const TDesC& aUri)
	{
	IRRDEBUG2( "CIRAsfPlayer::PlayL - Entering aUri=%S", &aUri );

    iStationUri.Close();
    iStationUri.CreateL( aUri );

	User::LeaveIfNull( iMdaAudioPlayer );
    if( iMdaAudioPlayer )
	    {
	    iMdaAudioPlayer->Close();
    	iMdaAudioPlayer->OpenUrlL( iStationUri, KUseDefaultIap, KMimeTypeASF );
	    }

	IRLOG_DEBUG( "CIRAsfPlayer::PlayL - Exiting." );
	}

// ---------------------------------------------------------------------------
// CIRAsfPlayer::Play
// function to resume playing (AsfPlayer should already initiated using Play(url))
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRAsfPlayer::Play()
	{
	IRLOG_DEBUG( "CIRAsfPlayer::Play" );

	SetVolume( iCtrlCmdObserver.FetchVolume() );
    if( iMdaAudioPlayer )
	    {
		iMdaAudioPlayer->Play();
	    }

	IRLOG_DEBUG( "CIRAsfPlayer::Play - Exiting." );
	}

// ---------------------------------------------------------------------------
// CIRAsfPlayer::Stop
// function to which stop the player
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRAsfPlayer::Stop()
	{
	IRLOG_DEBUG( "CIRAsfPlayer::Stop" );

    if( iMdaAudioPlayer )
	    {
		iMdaAudioPlayer->Stop();
	    }

	IRLOG_DEBUG( "CIRAsfPlayer::Stop - Exiting." );
	}

										//Functions for Volume Control

// ---------------------------------------------------------------------------
// CIRAsfPlayer::SetVolume
// function to set the volume
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRAsfPlayer::SetVolume(TInt aVolume )
	{
	IRLOG_DEBUG( "CIRAsfPlayer::SetVolume" );

    if( iMdaAudioPlayer )
	    {
		iMdaAudioPlayer->SetVolume( aVolume );
	    }

	IRLOG_DEBUG( "CIRAsfPlayer::SetVolume - Exiting." );
	}

// ---------------------------------------------------------------------------
// CIRAsfPlayer::Volume
// function to returns the volume, integer level of volume is the Output
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CIRAsfPlayer::Volume() const
	{
	IRLOG_DEBUG( "CIRAsfPlayer::Volume" );

	TInt volume = 0;
    if( iMdaAudioPlayer )
	    {
		iMdaAudioPlayer->GetVolume( volume );
	    }

	return volume;
	}

// ---------------------------------------------------------------------------
// CIRAsfPlayer::MaxVolume
// function to returns the maximum volume
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CIRAsfPlayer::MaxVolume() const
	{
	IRLOG_DEBUG( "CIRAsfPlayer::MaxVolume" );

	TInt volume = 0;
    if( iMdaAudioPlayer )
	    {
		volume = iMdaAudioPlayer->MaxVolume();
	    }

	return volume;
	}

// Helper functions

// ---------------------------------------------------------------------------
// CIRAsfPlayer::DetectAsfChannel
// Function is used to detect ASF channel by its url ending in .asf/.wma/.wmv
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CIRAsfPlayer::DetectAsfChannel(const TDesC& aUri)
	{
	IRLOG_DEBUG("CIRAsfPlayer::DetectAsfChannel - Entering");
	TPtrC ptr( aUri );
	TPtrC UriTypePtr( ptr.Right(KFour) );

	TBool bAsf = UriTypePtr == KTrailingAsf || UriTypePtr == KTrailingWma
							   || UriTypePtr == KTrailingWmv;

	IRRDEBUG2("CIRAsfPlayer::DetectAsfChannel - ASF Channel detected = %d", (TInt)bAsf);
	IRLOG_DEBUG("CIRAsfPlayer::DetectAsfChannel - Exiting");
	return bAsf;
	}

// Two-phase construction

// ---------------------------------------------------------------------------
// CIRAsfPlayer::CIRAsfPlayer
// Default constructor
// ---------------------------------------------------------------------------
//
CIRAsfPlayer::CIRAsfPlayer(MIRStreamSourceObserver& aStreamObserver,
						   MIRCtrlCmdObserver& aCtrlCmdObserver):
	iMdaAudioPlayer(NULL), iMetaData(NULL),
	iCtrlCmdObserver( aCtrlCmdObserver ), iStreamObserver(aStreamObserver),
	iState( ENotReady )
	{
	IRLOG_DEBUG( "CIRAsfPlayer::CIRAsfPlayer" );
	}

// ---------------------------------------------------------------------------
// CIRAsfPlayer::ConstructL
// Two phase constructor is used to intialize data members
// Function can leave if CMdaAudioOutputStream::NewL leaves
// ---------------------------------------------------------------------------
//
void CIRAsfPlayer::ConstructL()
	{
	IRLOG_DEBUG( "CIRAsfPlayer::ConstructL" );

	iMdaAudioPlayer = CMdaAudioPlayerUtility::NewL( *this );
	User::LeaveIfNull( iMdaAudioPlayer );

	iMdaAudioPlayer->RegisterForAudioLoadingNotification( *this );

	iMetaData = CIRMetaData::NewL();
	User::LeaveIfNull( iMdaAudioPlayer );

	IRLOG_DEBUG( "CIRAsfPlayer::ConstructL - Exiting." );
	}

//Call back functions

// ---------------------------------------------------------------------------
// MMdaAudioPlayerCallback::MapcInitComplete
// Invoked with OpenUrl() success/fail result
// ---------------------------------------------------------------------------
//
void CIRAsfPlayer::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& /*aDuration*/)
	{
	IRRDEBUG2( "CIRAsfPlayer::MapcInitComplete - Entering. aError = %d", aError );
    if( KErrNone == aError )
	    {
	    iState = EReadyToPlay;
	    Play();
	    iStreamObserver.Asf_ConnectionEstablished();
    	}
	else
		{
		iState = ENotReady;
		iStreamObserver.Asf_ErrorConnecting(aError);
		}
	IRLOG_DEBUG( "CIRAsfPlayer::MapcInitComplete - Exiting" );
	}

// ---------------------------------------------------------------------------
// MMdaAudioPlayerCallback::MapcPlayComplete
// Invoked after playback of an audio sample completes success/fail
// ---------------------------------------------------------------------------
//
void CIRAsfPlayer::MapcPlayComplete(TInt aError)
	{
	IRRDEBUG2( "CIRAsfPlayer::MapcPlayComplete - Entering. aError = %d", aError );
	if( KErrNone != aError )
		{
		iState = ENotReady;
		iStreamObserver.Asf_ErrorConnecting(aError);
		}
	else
		{
		// won't hit this as playing from stream
		}
	IRLOG_DEBUG( "CIRAsfPlayer::MapcPlayComplete - Exiting" );
	}

// ---------------------------------------------------------------------------
// MAudioLoadingObserver::MaloLoadingStarted
//
// ---------------------------------------------------------------------------
//
void CIRAsfPlayer::MaloLoadingStarted()
	{
	IRLOG_DEBUG( "CIRAsfPlayer::MaloLoadingStarted - Entering" );
	TInt percentComplete = 0;

	if( iMdaAudioPlayer )
		{
		iState = EReadyToPlay;

		TRAPD( err, iMdaAudioPlayer->GetAudioLoadingProgressL( percentComplete ));
		if(err == KErrNone)
			iStreamObserver.Asf_UpdateProgress( percentComplete );
		}
	IRLOG_DEBUG( "CIRAsfPlayer::MaloLoadingStarted - Exiting" );
	}

// ---------------------------------------------------------------------------
// MAudioLoadingObserver::MaloLoadingComplete
//
// ---------------------------------------------------------------------------
//
void CIRAsfPlayer::MaloLoadingComplete()
	{
	IRLOG_DEBUG( "CIRAsfPlayer::MaloLoadingComplete - Entering" );
	TInt percentComplete = 0;

	if( iMdaAudioPlayer )
		{
		iState = EPlaying;

		TRAPD( err, iMdaAudioPlayer->GetAudioLoadingProgressL( percentComplete ));
		if(err == KErrNone)
			iStreamObserver.Asf_UpdateProgress( percentComplete );

		TRAP( err, ReadMetadataL());
		if(err != KErrNone)
			{
			IRLOG_WARNING( "CIRAsfPlayer::MaloLoadingComplete - Failed to read/publish metadata" );
			}

		// publish birtate
		TUint bitrate = 0;
		err = iMdaAudioPlayer->GetBitRate( bitrate );
		RProperty::Set( KUidActiveInternetRadioApp, KIRPSBitrate, bitrate );
		}
	IRLOG_DEBUG( "CIRAsfPlayer::MaloLoadingComplete - Exiting" );
	}

// ---------------------------------------------------------------------------
// CIRAsfPlayer::ReadMetadataL
// Reads the meta data from the CMdaAudioPlayerUtility
// ---------------------------------------------------------------------------
//
void CIRAsfPlayer::ReadMetadataL()
	{
    IRLOG_DEBUG( "CIRAsfPlayer::ReadMetadataL - Entering" );

	if(iMetaData)
		{
	    // Erases old meta data information.
	    iMetaData->SetArtistL( KNullDesC );
	    iMetaData->SetSongL( KNullDesC );
	    iMetaData->SetStreamUrlL( KNullDesC );

		// Stream Url
		iMetaData->SetStreamUrlL( iStationUri );

	    TInt nMetadata = 0;
	    TInt err = iMdaAudioPlayer->GetNumberOfMetaDataEntries( nMetadata );
	    for( TInt ctr=0; ctr < nMetadata; ++ctr )
	        {
	        CMMFMetaDataEntry* pMetadataEntry = iMdaAudioPlayer->GetMetaDataEntryL( ctr );

	        // Song Title
	        if( pMetadataEntry->Name() == KIRSongTitle )
	        	{
	        	iMetaData->SetSongL( pMetadataEntry->Value() );
	        	}
	        // Song Artist
	        else if( pMetadataEntry->Name() == KIRSongArtist )
	        	{
	        	iMetaData->SetArtistL( pMetadataEntry->Value() );
	        	}
	        }

		if( iMetaData->Song().Length() == 0 )
			{
			IRLOG_WARNING( "CIRAsfPlayer::ExtractMetaDataL - song \"title\" not found in metadata" );
			}
		if( iMetaData->Artist().Length() == 0 )
			{
			IRLOG_WARNING( "CIRAsfPlayer::ExtractMetaDataL - song \"artist\" not found in metadata" );
			}

		// Notify observer
		iStreamObserver.Asf_HandleMetaDataReceivedL( *iMetaData );

	    IRLOG_DEBUG4( "CIRAsfPlayer::ReadMetadataL - Exiting (artist=%S, song=%S, streamUrl=%S)",
	    		     &iMetaData->Artist(), &iMetaData->Song(), &iMetaData->StreamUrl() );
		}
	}