/*
* Copyright (c) 2007-2008 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: The music control for the slideshow
*
*/
// CLASS HEADER
#include "shwmusiccontrol.h"
// EXTERNAL INCLUDES
#include <f32file.h> // RFs
#include <mpxplaybackutility.h> // MMPXPlaybackUtility
#include <mpxplaybackframeworkdefs.h> // TMPXPlaybackProperty, EPbRepeatOne
#include <mpxplaybackmessage.h> // TMPXPlaybackMessage
#include <mpxmessagegeneraldefs.h>
// INTERNAL INCLUDES
#include "shwevent.h"
#include "shwslideshowenginepanic.h"
#include <glxlog.h>
#include <glxtracer.h>
// -----------------------------------------------------------------------------
// C++ Constructor. save a few bits of ROM by inlining it.
// -----------------------------------------------------------------------------
inline CShwMusicControl::CShwMusicControl(
MShwMusicObserver& aMusicObsvr,
const TDesC& aFilePath )
: iFilePath( aFilePath ),
iMusicObsvr( aMusicObsvr ),
iMaxVolume( KErrNotFound ),
iCurrentVolume( KErrNotFound ),
iState( EMusicOff )
{
// No implementation required
}
// -----------------------------------------------------------------------------
// NewL. Static construction
// -----------------------------------------------------------------------------
CShwMusicControl* CShwMusicControl::NewL(
MShwMusicObserver& aMusicObsvr, const TDesC& aFilePath )
{
TRACER(" CShwMusicControl::NewL");
GLX_LOG_INFO( "CShwMusicControl::NewL" );
CShwMusicControl* self =
new( ELeave ) CShwMusicControl( aMusicObsvr, aFilePath );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
// -----------------------------------------------------------------------------
// Destructor.
// -----------------------------------------------------------------------------
CShwMusicControl::~CShwMusicControl()
{
TRACER(" CShwMusicControl::~CShwMusicControl");
GLX_LOG_INFO( "CShwMusicControl::~CShwMusicControl" );
if( iPlaybackUtility )
{
//The Code Scanner Error is not corrected here in the case of
//calling a leaving function in the Non Leaving Function
//We need to write a seperate Function for this.
//but will reduce not reduce any error.
iPlaybackUtility->RemoveObserverL(*this);
// Tell player to close the music playback
TRAP_IGNORE( iPlaybackUtility->CommandL( EPbCmdClose ) );
// Don't destroy, close releases resources.
iPlaybackUtility->Close();
}
}
// -----------------------------------------------------------------------------
// ConstructL.
// -----------------------------------------------------------------------------
void CShwMusicControl::ConstructL()
{
TRACER("CShwMusicControl::ConstructL");
GLX_LOG_INFO("CShwMusicControl::ConstructL");
// need to specify the mode and observer, without these we get a crash
iPlaybackUtility = MMPXPlaybackUtility::NewL( KPbModeNewPlayer, this );
// music playback is sacrificed if MPX fails
TRAPD( err, InitPlayerL() );
if( err == KErrNone )
{
iState = EMusicOn;
}
}
// ---------------------------------------------------------------------------
// Initialize the player with File Path
// ---------------------------------------------------------------------------
void CShwMusicControl::InitPlayerL()
{
TRACER("CShwMusicControl::InitPlayerL");
GLX_LOG_INFO( "CShwMusicControl::InitPlayerL" );
RFs fs;
User::LeaveIfError( fs.Connect() );
CleanupClosePushL( fs );
User::LeaveIfError( fs.ShareProtected() );
RFile file;
// try to open the file
TInt error = file.Open(
fs,
iFilePath,
EFileRead | EFileShareReadersOrWriters );
// was there an error
if( KErrNone != error )
{
GLX_LOG_INFO1(
"CShwMusicControl error in track %d", error );
// let the observer know there was an error
iMusicObsvr.ErrorWithTrackL( error );
User::Leave( error );
}
CleanupClosePushL( file );
iPlaybackUtility->InitL( file );
CleanupStack::PopAndDestroy( &file );
CleanupStack::PopAndDestroy( &fs );
// The track should loop
iPlaybackUtility->SetL( EPbPropertyRepeatMode, EPbRepeatOne );
}
// -----------------------------------------------------------------------------
// VolumeL
// Retrieve the volume values
// -----------------------------------------------------------------------------
void CShwMusicControl::VolumeL()
{
TRACER("CShwMusicControl::VolumeL");
GLX_LOG_INFO( "CShwMusicControl::VolumeL" );
// Retrieve the volume - Volume indicator is shown upon slideshow start and
// when the volume is changed
if (iMaxVolume == KErrNotFound)
{
iPlaybackUtility->ValueL( *this, EPbPropertyMaxVolume );
}
iPlaybackUtility->ValueL( *this, EPbPropertyVolume );
}
// -----------------------------------------------------------------------------
// NotifyL.
// -----------------------------------------------------------------------------
void CShwMusicControl::NotifyL( MShwEvent* aEvent )
{
TRACER("CShwMusicControl::NotifyL");
GLX_LOG_INFO( "CShwMusicControl::NotifyL" );
// only handle events if music initialisation succeeded
if( iState == EMusicOn )
{
// reset state flag
iSwitchingMusicOn = EFalse;
// music playback is sacrificed if MPX fails
TRAPD( errr, HandleEventL( aEvent ) );
// if we had an error while switching music back on, tell observer
// that music is off
if( ( errr != KErrNone )&&
( iSwitchingMusicOn ) )
{
iMusicObsvr.MusicOff();
}
}
}
// ---------------------------------------------------------------------------
// From class MMPXPlaybackCallback.
// Handle the change of status of playback engine
// ---------------------------------------------------------------------------
void CShwMusicControl::HandlePropertyL( TMPXPlaybackProperty aProperty,
TInt aValue,
TInt aError )
{
TRACER("CShwMusicControl::HandlePropertyL");
GLX_LOG_INFO( "CShwMusicControl::HandlePropertyL" );
// leave if there was an error
User::LeaveIfError( aError );
// handle max volume and volume, ignore other properties
if( EPbPropertyMaxVolume == aProperty )
{
iMaxVolume = aValue;
}
else if( EPbPropertyVolume == aProperty )
{
// set the current volume
iCurrentVolume = aValue;
// call observer only when max volume is also known
// iMaxVolume and iCurrentVolume are initialized to KErrNotFound
if( iMaxVolume != KErrNotFound )
{
iMusicObsvr.MusicVolumeL( iCurrentVolume, iMaxVolume );
}
}
}
// -----------------------------------------------------------------------------
// From MMPXPlaybackCallback
// Method is called continously until aComplete=ETrue, signifying that
// it is done and there will be no more callbacks
// Only new items are passed each time
// -----------------------------------------------------------------------------
void CShwMusicControl::HandleSubPlayerNamesL(
TUid /*aPlayer*/, const MDesCArray* /*aSubPlayers*/,
TBool /*aComplete*/, TInt /*aError*/ )
{
}
// ---------------------------------------------------------------------------
// From class MMPXPlaybackCallback.
// Call back of media request
// ---------------------------------------------------------------------------
void CShwMusicControl::HandleMediaL(
const CMPXMedia& /*aProperties*/, TInt /*aError*/ )
{
}
// ---------------------------------------------------------------------------
// From class MMPXPlaybackObserver
// Handle playback message - required for debugging state of MPX
// Player component
// ---------------------------------------------------------------------------
void CShwMusicControl::HandlePlaybackMessageL(
const TMPXPlaybackMessage& /*aMessage*/ )
{
}
// ---------------------------------------------------------------------------
// From MMPXPlaybackObserver
// ---------------------------------------------------------------------------
void CShwMusicControl::HandlePlaybackMessage(const CMPXMessage& aMsg)
{
TRACER("CShwMusicControl::HandlePlaybackMessage");
GLX_LOG_ENTRY_EXIT( "CShwMusicControl::HandlePlaybackMessageL()" );
switch(*aMsg.Value<TMPXPlaybackMessage::TEvent>( KMPXMessageGeneralEvent ))
{
case TMPXPlaybackMessage::EInitializeComplete:
{
GLX_LOG_INFO( "TMPXPlaybackMessage::EInitializeComplete" );
// at here, can play the track
iCanPlay = ETrue;
//execute the cached "play" command
if ( iPlayCached )
{
GLX_LOG_INFO( "iPlayCached" );
// Play the track
//The Code Scanner Error is not corrected here in the case of
//calling a leaving function in the Non Leaving Function
//We need to write a seperate Function for this.
//but will reduce only one error.
TRAP_IGNORE(iPlaybackUtility->CommandL( EPbCmdPlay ) );
iMusicObsvr.MusicOnL();
// need to call volume ourself to show the
// volume indicator in start
VolumeL();
iPlayCached = EFalse;
}
break;
}
default:
{
GLX_LOG_INFO( "CShwMusicControl::HandlePlaybackMessage: Default" );
break;
}
}
}
// -----------------------------------------------------------------------------
// HandleEventL.
// -----------------------------------------------------------------------------
void CShwMusicControl::HandleEventL( MShwEvent* aEvent )
{
TRACER("CShwMusicControl::HandleEventL( MShwEvent* aEvent )");
GLX_LOG_INFO( "CShwTimerControl::HandleEventL" );
// we got an event, was it start
if( dynamic_cast< TShwEventStart* >( aEvent ) )
{
GLX_LOG_INFO( "CShwMusicControl::NotifyL - TShwEventStart" );
// set state flag
iSwitchingMusicOn = ETrue;
// iCanPlay is True when Player is Initialized.
if ( iCanPlay )
{
GLX_LOG_INFO( "inside ICanPlay" );
// Play the track
TRAP_IGNORE(iPlaybackUtility->CommandL( EPbCmdPlay ) );
iMusicObsvr.MusicOnL();
// need to call volume ourself to show the
// volume indicator in start
VolumeL();
}
else
{
GLX_LOG_INFO( "inside Else: ICanPlay" );
// initialization is not finished ,and cache the "play" command
iPlayCached = ETrue;
}
}
else if( dynamic_cast< TShwEventPause* >( aEvent ) )
{
GLX_LOG_INFO( "CShwMusicControl::NotifyL - TShwEventPause" );
// pause playback
iPlaybackUtility->CommandL( EPbCmdPause );
// let the observer know
iMusicObsvr.MusicOff();
}
else if( dynamic_cast< TShwEventResume* >( aEvent ) )
{
GLX_LOG_INFO( "CShwMusicControl::NotifyL - TShwEventResume" );
// set state flag
iSwitchingMusicOn = ETrue;
// resume
iPlaybackUtility->CommandL( EPbCmdPlay );
// let the observer know
iMusicObsvr.MusicOnL();
}
else if( dynamic_cast< TShwEventVolumeDown* >( aEvent ) )
{
GLX_LOG_INFO( "CShwMusicControl::NotifyL - TShwEventVolumeDown" );
iPlaybackUtility->CommandL( EPbCmdDecreaseVolume );
VolumeL();
}
else if( dynamic_cast< TShwEventVolumeUp* >( aEvent ) )
{
GLX_LOG_INFO( "CShwMusicControl::NotifyL - TShwEventVolumeUp" );
iPlaybackUtility->CommandL( EPbCmdIncreaseVolume );
VolumeL();
}
else if( dynamic_cast< TShwEventToggleControlUi* >( aEvent ) )
{
GLX_LOG_INFO( "CShwMusicControl::NotifyL - TShwEventToggleControlUi" );
// Have to impliment if need comes
}
}