×
Namespaces

Variants
Actions

播放音频文件

From Nokia Developer Wiki
Jump to: navigation, search
Article Metadata

文章
huwell 在 06 Oct 2008 创建
最后由 hamishwillee 在 15 Dec 2011 编辑

Contents

详细描述

一般来说音频文件可以通过CMdaAudioRecorderUtility或CMdaAudioPlayerUtility来播放。这里CPlayerUtility演示了如何通过CMdaAudioPlayerUtility来播放文件。它需要MMdaAudioPlayerCallback接口,并要由调用类完成。这个接口有两个方法MapcInitComplete()——当文件打开完成后执行,只有在这个函数调用之后我们才开始播放音频。


MapcPlayComplete方法当播放完成后调用。你可以重新调用以便循环播放。


如果你想播放文件中的buffer数据,可以用NewDesPlayerL来取代NewFilePlayerL方法。


CAudioPlayer演示了如何使用CMdaAudioRecorderUtility。它需要完成MMdaObjectStateChangeObserver,可用来更新文件播放的不同状态。当我们调用接口方法,设置播放对象状态为EOpen时文件就可以开始播放了。注意当音频播放完毕后也设置为EOpen这样你可以检查前一个状态。


下列代码需要完成自己的回调接口,以便更新播放状态。此状态可以根据播放器状态设置也可以使用timer完成播放过程的状态更新。

AudioPlayer.cpp

#include <Mda\Common\Resource.h>
#include <BAUTILS.H>
 
 
 
CAudioPlayer* CAudioPlayer::NewL(MExmaplePlayRecStateObserver& aObserver)
{
CAudioPlayer* self = CAudioPlayer::NewLC(aObserver);
CleanupStack::Pop(self);
return self;
}
 
 
CAudioPlayer* CAudioPlayer::NewLC(MExmaplePlayRecStateObserver& aObserver)
{
CAudioPlayer* self = new (ELeave) CAudioPlayer(aObserver);
CleanupStack::PushL(self);
self->ConstructL();
return self;
}
 
 
CAudioPlayer::CAudioPlayer(MExmaplePlayRecStateObserver& aObserver)
:iObserver(aObserver),iVolume(5)
{
 
}
 
 
CAudioPlayer::~CAudioPlayer()
{
delete iExampleTimer;
 
if(iPlayerUtility)
{
iPlayerUtility->Stop();
iPlayerUtility->Close();
}
 
delete iPlayerUtility;
}
 
void CAudioPlayer::ConstructL()
{
iExampleTimer = CExampleTimer::NewL(CActive::EPriorityStandard,*this);
 
ReportStateAndTime();
}
 
void CAudioPlayer::TimerExpired(TAny* /*aTimer*/,TInt aError)
{
// update states first.
ReportStateAndTime();
 
if(iExampleTimer && aError != KErrCancel)
{
iExampleTimer->After(KReFreshTimeOut);
}
}
 
 
void CAudioPlayer::PlayL(const TDesC& aFileName)
{
iCurrentFile.iName.Copy(aFileName);
 
if(iExampleTimer)
{
iExampleTimer->Cancel();
}
 
if(iPlayerUtility)
{
iPlayerUtility->Stop(); // stop any play/rec
iPlayerUtility->Close();// close previously opened file.
}
 
delete iPlayerUtility; // and then we can delete it.
iPlayerUtility = NULL;
iPlayerUtility = CMdaAudioRecorderUtility::NewL(*this);
iPlayerUtility->OpenFileL(iCurrentFile.iName);
 
if(iExampleTimer)
{
iExampleTimer->After(KReFreshTimeOut);
}
}
 
void CAudioPlayer::StopL(void)
{
if(iExampleTimer)
{
iExampleTimer->Cancel();
}
 
if(iPlayerUtility)
{
iPlayerUtility->Stop();
}
 
ReportStateAndTime();
}
 
void CAudioPlayer::SetVolume(TInt& aVolume)
{
if(aVolume < 1)
aVolume = 1;
else if(aVolume > 10)
aVolume = 10;
 
iVolume = aVolume;// save to internal value always
if(iPlayerUtility) // and if utility exists, set it to it as well.
{
TInt Vol = ((iPlayerUtility->MaxVolume() * iVolume) / 10);
iPlayerUtility->SetVolume(Vol);
}
}
 
 
void CAudioPlayer::ReportStateAndTime(void)
{
TInt CurrPosition(0),FileDuration(0);
 
CMdaAudioClipUtility::TState CurrState(CMdaAudioClipUtility::ENotReady);
 
if(iPlayerUtility)
{
CurrState = iPlayerUtility->State();
 
TInt64 HelpPos = iPlayerUtility->Position().Int64();
// micro seconds, thus lets make it seconds for UIs
CurrPosition = HelpPos / 1000000;
 
// and with playing its the file duration.
HelpPos = iPlayerUtility->Duration().Int64();
FileDuration = HelpPos / 1000000;
}
 
// update valus to the UI
iObserver.StateUpdate(CurrState,CurrPosition,FileDuration);
}
 
 
void CAudioPlayer::MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt /*aErrorCode*/)
{
if(aObject == iPlayerUtility)
{
ReportStateAndTime();
 
switch(aCurrentState)
{
case CMdaAudioClipUtility::EOpen:
{
// only when first opening files.
// also called with aCurrentState == EOpen, when
// playing or recording finishes.
if(aPreviousState == CMdaAudioClipUtility::ENotReady)
{
TInt Vol = ((iVolume * iPlayerUtility->MaxVolume()) / 10);
iPlayerUtility->SetVolume(Vol);
 
TRAPD(err,iPlayerUtility->PlayL(););
}
}
break;
case CMdaAudioClipUtility::EPlaying:
case CMdaAudioClipUtility::ERecording:
case CMdaAudioClipUtility::ENotReady:
default: // no need to do anything on these states.
break;
}
}
}

AudioPlayer.h

#include <MdaAudioSampleEditor.h>
#include <Mda\Client\Utility.h>
#include "CExampleTimer.h"
 
const TInt KReFreshTimeOut = 1000000; // re-fresh every second
//
class MExmaplePlayStateObserver
{
public:
virtual void StateUpdate(CMdaAudioClipUtility::TState aState, TInt aPosition, TInt aDuration)=0;
};
 
 
class CAudioPlayer : public CBase, public MMdaObjectStateChangeObserver,MExampleTimerNotify
{
public:
static CAudioPlayer* NewL(MExmaplePlayStateObserver& aObserver);
static CAudioPlayer* NewLC(MExmaplePlayStateObserver& aObserver);
~CAudioPlayer();
public: // public functions
void PlayL(const TDesC& aFileName);
void StopL(void);
void SetVolume(TInt& aVolume);
protected: // from MMdaObjectStateChangeObserver & MExampleTimerNotify
void MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode);
void TimerExpired(TAny* aTimer,TInt aError);
private:// interna functions
void ReportStateAndTime(void);
void ConstructL();
CAudioPlayer(MExmaplePlayStateObserver& aObserver);
private:
MExmaplePlayStateObserver& iObserver;
CMdaAudioRecorderUtility* iPlayerUtility;
TInt iVolume;
TMdaFileClipLocation iCurrentFile;
CExampleTimer* iExampleTimer;
};

PlayUtility.cpp

#include <MdaAudioTonePlayer.h>
#include <eikmenup.h>
 
 
CPlayerUtility* CPlayerUtility::NewL(const TDesC& aFileName)
{
CPlayerUtility* self = NewLC(aFileName);
CleanupStack::Pop(self);
return self;
}
 
CPlayerUtility* CPlayerUtility::NewLC(const TDesC& aFileName)
{
CPlayerUtility* self = new (ELeave) CPlayerUtility();
CleanupStack::PushL(self);
self->ConstructL(aFileName);
return self;
}
 
CPlayerUtility::~CPlayerUtility()
{
if(iPlayUtility)
{
iPlayUtility->Stop();
iPlayUtility->Close();
}
 
delete iPlayUtility;
}
 
CPlayerUtility::CPlayerUtility()
{
}
 
void CPlayerUtility::ConstructL(const TDesC& aFileName)
{
iPlayUtility = CMdaAudioPlayerUtility::NewFilePlayerL(aFileName, *this);
iPlaying = iPrepared = EFalse;
}
 
void CPlayerUtility::Play()
{
iPlayUtility->Play();
iPlaying = ETrue;
}
 
void CPlayerUtility::Stop()
{
iPlayUtility->Stop();
iPlaying = EFalse;
}
 
 
void CPlayerUtility::MapcPlayComplete(TInt /*aError*/)
{
iPlaying = EFalse;
}
 
void CPlayerUtility::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& /*aDuration*/)
{
if(aError == KErrNone)
{
iPrepared = ETrue;
iPlayUtility->SetVolume(iPlayUtility->MaxVolume());
}
}


PlayUtility.h

#include <e32std.h>
#include <MdaAudioSamplePlayer.h>
 
class CPlayerUtility : public CBase, public MMdaAudioPlayerCallback
{
public:
static CPlayerUtility* NewL(const TDesC& aFileName);
static CPlayerUtility* NewLC(const TDesC& aFileName);
~CPlayerUtility();
private:
CPlayerUtility();
void ConstructL(const TDesC& aFileName);
public:
void Play();
void Stop();
public: // from MMdaAudioToneObserver
void MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& aDuration);
void MapcPlayComplete(TInt aError);
private:
CMdaAudioPlayerUtility* iPlayUtility;
TBool iPlaying,iPrepared;
};
This page was last modified on 15 December 2011, at 09:15.
54 page views in the last 30 days.
×