playeradapter.cpp

symbian平台

/*
* ==============================================================================
*  Name        : PlayerAdapter.cpp
*  Part of     : Sound Application
*  Description : Implementation of the player adapter
*  Version     : 1
*
*  Copyright (c) 2006, Nokia Corporation All rights reserved. Redistribution
*  and use in source and binary forms, with or without modification, are
*  permitted provided that the following conditions are met: Redistributions
*  of source code must retain the above copyright notice, this list of
*  conditions and the following disclaimer. Redistributions in binary form
*  must reproduce the above copyright notice, this list of conditions and the
*  following disclaimer in the documentation and/or other materials provided
*  with the distribution. Neither the name of the Nokia Corporation nor the
*  names of its contributors may be used to endorse or promote products
*  derived from this software without specific prior written permission. THIS
*  SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
*  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
*  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
*  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
*  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
*  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
*  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
*  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
*  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
*  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
*  POSSIBILITY OF SUCH DAMAGE.
* ==============================================================================
*/

// INCLUDE FILES
#include <eikmenup.h>
#include <eikapp.h>
#include <AknGlobalNote.h>

#include "S60InternetRadio.pan"
#include "S60InternetRadio.hrh"
#include "PlayerAdapter.h"
#include "S60InternetRadioAppUi.h"

// CONSTANTS
// Identifying string for this audio adapter
_LIT(KFilePlayer, "File Player");

_LIT(KPASeparator, " - ");
_LIT(KPABitrateFormat, "BitRate: %dkb/s");

_LIT(KPALocalPlayback, "Local Playback");
_LIT(KPAPaused, "Paused");
_LIT(KPAStopped, "Stopped");
_LIT(KPAFileOpened, "File Opened");
_LIT(KPAPlayInitErrorFormat, "Playinit Error=%d");
_LIT(KPAPlayErrorFormat, "Play Error=%d");

_LIT(KPAUnknownTitle, "Title: Unkown");
_LIT(KPAUnknownArtist, "Artist: Unknown");
_LIT(KPAUnknownGenre, "Genre: Unknown");

const TInt KPlayerAdapterDefaultVolumeLevel(2);


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

// -----------------------------------------------------------------------------
// CPlayerAdapter::CPlayerAdapter
// C++ default constructor can NOT contain any code, that might leave.
// -----------------------------------------------------------------------------
//
CPlayerAdapter::CPlayerAdapter(
	MAdapterObserver& aObserver)
	: iState(ENotReady),
      iObserver(aObserver)
    {
    }

// -----------------------------------------------------------------------------
// CPlayerAdapter::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CPlayerAdapter* CPlayerAdapter::NewL(
	const TDesC& aFileName,
	MAdapterObserver& aObserver )
    {
    CPlayerAdapter* self = NewLC(aFileName, aObserver);
    CleanupStack::Pop(self);
    return self;
    }

// -----------------------------------------------------------------------------
// CPlayerAdapter::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CPlayerAdapter* CPlayerAdapter::NewLC(
	const TDesC& aFileName,
	MAdapterObserver& aObserver )
    {
    CPlayerAdapter* self = new (ELeave) CPlayerAdapter(aObserver);
    CleanupStack::PushL(self);
    self->ConstructL(aFileName);
    return self;
    }

// -----------------------------------------------------------------------------
// CPlayerAdapter::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CPlayerAdapter::ConstructL(
	const TDesC& aFileName )
    {

    // Create an audio player utility instance for playing sample data from a file,
    // causes MMdaAudioPlayerCallback::MapcInitComplete to be called
    if ( aFileName != KNullDesC )
    	{
    	iMdaAudioPlayerUtility = CMdaAudioPlayerUtility::NewFilePlayerL(aFileName, *this);
		}
    }


CPlayerAdapter::~CPlayerAdapter()
    {
    delete iMdaAudioPlayerUtility;
    iMdaAudioPlayerUtility = NULL;
    }

// -----------------------------------------------------------------------------
// CPlayerAdapter::UpdateMenuL
// Update the menu depending on the state of the play utility.
// -----------------------------------------------------------------------------
//
void CPlayerAdapter::UpdateMenuL(
	CEikMenuPane* aMenuPane )
    {
    aMenuPane->SetItemDimmed(ES60InternetRadioCmdPlay,   ETrue);
    aMenuPane->SetItemDimmed(ES60InternetRadioCmdStop,   ETrue);
    aMenuPane->SetItemDimmed(ES60InternetRadioCmdChange, ETrue);
    aMenuPane->SetItemDimmed(ES60InternetRadioCmdFileSelect, ETrue);

    switch ( iState )
        {
		case ENotReady:
			aMenuPane->SetItemDimmed(ES60InternetRadioCmdChange, EFalse);
			aMenuPane->SetItemDimmed(ES60InternetRadioCmdFileSelect, EFalse);
			break;
		case EReadyToPlay:
			aMenuPane->SetItemDimmed(ES60InternetRadioCmdPlay, EFalse);
			aMenuPane->SetItemDimmed(ES60InternetRadioCmdChange, EFalse);
			aMenuPane->SetItemDimmed(ES60InternetRadioCmdFileSelect, EFalse);
			break;
		case EPlaying:
			aMenuPane->SetItemDimmed(ES60InternetRadioCmdStop, EFalse);
			break;
		default:
			User::Panic(KPlayerAdapter, KS60InternetRadioPanicInvalidMdaState);
			break;
        }
    }

// -----------------------------------------------------------------------------
// CPlayerAdapter::PlayL
// Starts the playback.
// -----------------------------------------------------------------------------
//
void CPlayerAdapter::PlayL()
    {
	if ( iState == EReadyToPlay )
		{
		iMdaAudioPlayerUtility->Play();
		iState = EPlaying;

		iTempMetadata.Copy(KPALocalPlayback);
		iObserver.SetMetadata(KMetadataServer, iTempMetadata, ETrue);
		ShowMetadata();
		}
	}

// -----------------------------------------------------------------------------
// CPlayerAdapter::RecordL
// This is not supported in the play adapter.
// -----------------------------------------------------------------------------
//
void CPlayerAdapter::RecordL()
    {
	User::Leave(KErrNotSupported);
    }


// -----------------------------------------------------------------------------
// CPlayerAdapter::PauseL
// Pauses the playback
// -----------------------------------------------------------------------------
//
void CPlayerAdapter::PauseL()
    {
	if ( iState == EPlaying )
		{
		iMdaAudioPlayerUtility->Pause();
		iState = EReadyToPlay;

		iTempMetadata.Copy(KPAPaused);
		iObserver.SetMetadata(KMetadataArtistTitle, iTempMetadata, ETrue);
		}
	}

// -----------------------------------------------------------------------------
// CPlayerAdapter::StopL
// Stops the playback
// -----------------------------------------------------------------------------
//
void CPlayerAdapter::StopL()
    {

	iMdaAudioPlayerUtility->Stop();
	iState = EReadyToPlay;

	iTempMetadata.Copy(KPAStopped);
	iObserver.SetMetadata(KMetadataArtistTitle, iTempMetadata, ETrue);
	}

// -----------------------------------------------------------------------------
// CPlayerAdapter::Identify
// Use to identify this adapter.
// -----------------------------------------------------------------------------
//
const TDesC& CPlayerAdapter::Identify() const
    {
    return KFilePlayer;
    }

// -----------------------------------------------------------------------------
// CPlayerAdapter::AddExtraMenu
// Use to add extra menu. This implementation doesn't have any items to add.
// -----------------------------------------------------------------------------
//
void CPlayerAdapter::AddExtraMenu(
	CEikMenuPane* /*aMenuPane*/)
	{
	}

// -----------------------------------------------------------------------------
// CPlayerAdapter::HandleCommandL
// -----------------------------------------------------------------------------
//
TBool CPlayerAdapter::HandleCommandL(
	TInt /*aCommand*/ )
	{
	return EFalse;
	}

// -----------------------------------------------------------------------------
// CPlayerAdapter::SupportMetadata
// No metadata supported.
// -----------------------------------------------------------------------------
//
TInt CPlayerAdapter::SupportMetadata() const
	{
	return iNrMetadata;
	}

// -----------------------------------------------------------------------------
// CPlayerAdapter::TogglePlayPause
// Toggles play and pause.
// -----------------------------------------------------------------------------
//
void CPlayerAdapter::TogglePlayPause()
	{
	if ( iState == EReadyToPlay )
		{
		PlayL();
		}
	else if ( iState == EPlaying )
		{
		PauseL();
		}
	}

// -----------------------------------------------------------------------------
// CPlayerAdapter::SetVolume
// Sets the volume level
// -----------------------------------------------------------------------------
//
void CPlayerAdapter::SetVolume(
	TInt aVolume )
	{
	if ( iMdaAudioPlayerUtility )
		{
		iMdaAudioPlayerUtility->SetVolume((TInt)(aVolume/iVolFactor));
		}
	}

// -----------------------------------------------------------------------------
// CPlayerAdapter::GetVolume
// Get the current volume level
// -----------------------------------------------------------------------------
//
TInt CPlayerAdapter::Volume()
	{
	TInt volume = KPlayerAdapterDefaultVolumeLevel;
	if ( iMdaAudioPlayerUtility && iState != ENotReady)
		{
		if( !iVolFactor )
			{
			TInt maxVol = iMdaAudioPlayerUtility->MaxVolume();

			iVolFactor=10.0/maxVol;
			}
		iMdaAudioPlayerUtility->GetVolume(volume);
		volume = (TInt)(iVolFactor*volume);
		};
	return volume;
	}

// -----------------------------------------------------------------------------
// CPlayerAdapter::GetMetadata
// Send metdata to the client for display
// -----------------------------------------------------------------------------
//
void CPlayerAdapter::ShowMetadata()
	{
	if ( iNrMetadata )
		{
		TUint bitrate = 0;
	    iMdaAudioPlayerUtility->GetBitRate(bitrate);
	   	iTempMetadata.Copy(iMetaDataGenre);
		iObserver.SetMetadata(KMetadataGenre, iTempMetadata, ETrue);
	   	iTempMetadata.Format(KPABitrateFormat, bitrate/1000);
		iObserver.SetMetadata(KMetadataTechDetails, iTempMetadata, ETrue);
		iTempMetadata.Copy(iMetaDataArtist);
		iTempMetadata.Append(KPASeparator);
		iTempMetadata.Append(iMetaDataTitle);
		iObserver.SetMetadata(KMetadataArtistTitle, iTempMetadata, ETrue);
		}
	}

// -----------------------------------------------------------------------------
// CPlayerAdapter::GetMetadata
// Get and display metadata
// -----------------------------------------------------------------------------
//
void CPlayerAdapter::GetMetadata()
	{
    if (iState == EReadyToPlay)
		{
		CMMFMetaDataEntry* md = NULL;
		TBool titleMdFound = EFalse;
		TBool artistMdFound = EFalse;
		TBool genreMdFound = EFalse;
		iMetaDataTitle.Copy(KPAUnknownTitle);
		iMetaDataArtist.Copy(KPAUnknownArtist);
		iMetaDataGenre.Copy(KPAUnknownGenre);
		TInt count = 0;
		TInt err;
		iMdaAudioPlayerUtility->GetNumberOfMetaDataEntries(count);
		/*
		if ( count > 0 )
			{
			for ( TInt i = 0; i < count; i++ )
				{
				TRAP(err, md = iMdaAudioPlayerUtility->GetMetaDataEntryL(i));
				if ( err )
					{
					continue;
					}
				if ( md->Name().Find(KMMFMetaEntrySongTitle) != KErrNotFound )
					{
					iMetaDataTitle.Copy(md->Value().Ptr(), md->Value().Length() < iMetaDataTitle.MaxLength() ?
					md->Value().Length() : iMetaDataTitle.MaxLength());
					iMetaDataTitle.Trim();
					titleMdFound = ETrue;
					}
				else if ( md->Name().Find(KMMFMetaEntryArtist) != KErrNotFound )
					{
					iMetaDataArtist.Copy(md->Value().Ptr(), md->Value().Length() < iMetaDataArtist.MaxLength() ?
					md->Value().Length() : iMetaDataArtist.MaxLength());
					iMetaDataArtist.Trim();
					artistMdFound = ETrue;
					}
				else if ( md->Name().Find(KMMFMetaEntryGenre) != KErrNotFound )
					{
					iMetaDataGenre.Copy(md->Value().Ptr(), md->Value().Length() < iMetaDataGenre.MaxLength() ?
					md->Value().Length() : iMetaDataGenre.MaxLength());
					iMetaDataGenre.Trim();
					genreMdFound = ETrue;
					}
				delete md;
				if ( titleMdFound && artistMdFound && genreMdFound )
					break;
				}

			}
		*/
		iNrMetadata = 4; // Number of metadata we want to display even if more was available.
		iObserver.ResetMetadata();
		}
	}



// -----------------------------------------------------------------------------
// CPlayerAdapter::MapcInitComplete
// Call by the utility when playback initialization is completed.
// -----------------------------------------------------------------------------
//
void CPlayerAdapter::MapcInitComplete(
	TInt aError,
	const TTimeIntervalMicroSeconds& /*aDuration*/ )
    {
    iState = aError ? ENotReady : EReadyToPlay;
    if ( aError )
    	{
    	TBuf<20> text;
    	text.Format(KPAPlayInitErrorFormat, aError);

    	CAknGlobalNote *note = NULL;
    	TRAP_IGNORE(
 	   		{
			note = CAknGlobalNote::NewL();
    		note->ShowNoteL(EAknGlobalErrorNote ,text);
    		});
    	delete note;
    	}
    else
	    {
	    iMdaAudioPlayerUtility->SetVolume(iMdaAudioPlayerUtility->MaxVolume()/2);
  		GetMetadata();
  		iTempMetadata.Copy(KPAFileOpened);
		iObserver.SetMetadata(0, iTempMetadata, ETrue);
	    }
    }

// -----------------------------------------------------------------------------
// CPlayerAdapter::MapcPlayComplete
// Call by the utility when playback has completed successfully or otherwise.
// -----------------------------------------------------------------------------
//
void CPlayerAdapter::MapcPlayComplete(
	TInt aError )
    {
    iState = aError ? ENotReady : EReadyToPlay;
    if ( aError )
    	{
    	TBuf<20> text;
    	text.Format(KPAPlayErrorFormat, aError);
    	CAknGlobalNote *note = NULL;
    	TRAP_IGNORE(
 	   		{
			note = CAknGlobalNote::NewL();
    		note->ShowNoteL(EAknGlobalErrorNote ,text);
    		});
    	delete note;
    	}
    }

// End of File