audiorecorder.cpp

电话录音

// This code has been corrected by Michel David. Now the H and CPP are compatible. 
// Some includes have been added.
// Don't forget to add the line 
// LIBRARY	mediaclientaudio.lib
// In the MMP
// 
// IMPORTANT!
// CMdaAudioRecorderUtility->RecordL() needs "UserEnvironment" capability to access microphone. 
// Without the capability it won't work in 3.1-> devices. MultimediaDD-capability is NOT needed.
//
// Add UserEnvironment as CAPABILITY in .mmp file. 
// Remember to use ABLD REALLYCLEAN when fidling with capabilities.
 
#include <e32base.h>
#include <aknviewappui.h>
 
#include <Mda\Common\Resource.h>
#include <BAUTILS.H>
 
#include "AudioRecorder.h"


#define KAudioPriority   80
#define KAudioPreference 0x00060001


const TInt	KReFreshTimeOut = 1000000; // re-fresh every second
 
CAudioRecorder* CAudioRecorder::NewL(MExmapleRecStateObserver& aObserver)
    {
    CAudioRecorder* self = CAudioRecorder::NewLC(aObserver);
    CleanupStack::Pop(self);
    return self;
    }
									  
CAudioRecorder* CAudioRecorder::NewLC(MExmapleRecStateObserver& aObserver)
    {
    CAudioRecorder* self = new (ELeave) CAudioRecorder(aObserver);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }
 
CAudioRecorder::CAudioRecorder(MExmapleRecStateObserver& aObserver)
:iObserver(aObserver),iVolume(5)
    {
 
    }
 
CAudioRecorder::~CAudioRecorder()
{
	delete iExampleTimer;
 
    if(iRecorderUtility)
    {
    	iRecorderUtility->Stop();
    	iRecorderUtility->Close();
    }
    
    delete iRecorderUtility;
    delete iFormat;
	delete iCodec;
	delete iAudioDataSettings;
}
 
 
void CAudioRecorder::ConstructL()
{
	iExampleTimer = CExampleTimer::NewL(*this);
 
	ReportStateAndTime();
}
 
void CAudioRecorder::TimerExpired(TInt aError)
{
	ReportStateAndTime();
	
	if(iExampleTimer && aError != KErrCancel)	
	{
		iExampleTimer->After(KReFreshTimeOut);
	}
}
 
void CAudioRecorder::RecordL(const TDesC& aFileName)
{	
    
	iCurrentFile.iName.Copy(aFileName);
	
	if(iExampleTimer)	
	{
		iExampleTimer->Cancel();
	}
	
	if(iRecorderUtility)
    {
    	iRecorderUtility->Stop(); // stop any play/rec
    	iRecorderUtility->Close();// close previously opened file.
    }	
    
	delete iRecorderUtility;
	iRecorderUtility = NULL;
	


	
	iRecorderUtility = CMdaAudioRecorderUtility::NewL(
	        *this,
	        NULL,
	        KAudioPriority,
	        (TMdaPriorityPreference)KAudioPreference);
	
	// and free ther reserved resources.
	delete iFormat;
	iFormat = NULL;
	delete iCodec;
	iCodec = NULL;
	delete iAudioDataSettings;
	iAudioDataSettings = NULL;
	
	// if the file exists, we append sound data to it.
	if(BaflUtils::FileExists(CCoeEnv::Static()->FsSession(),aFileName))
	{
		iRecorderUtility->OpenFileL(iCurrentFile.iName);
	}
	else
	{		
		BaflUtils::EnsurePathExistsL(CCoeEnv::Static()->FsSession(),iCurrentFile.iName);
		
		// record new Wav sound file.
		iFormat = new (ELeave) TMdaWavClipFormat;
		iCodec = new (ELeave) TMdaWavCodec(); 
 
		iAudioDataSettings = new (ELeave) TMdaAudioDataSettings;
		iAudioDataSettings->iSampleRate = 8000;
		iAudioDataSettings->iChannels = 1;// mono
		iRecorderUtility->OpenL(&iCurrentFile,&iMdaWavClipFormat,NULL,NULL);
	}
	
	if(iExampleTimer)	
	{
		iExampleTimer->After(KReFreshTimeOut);
	}
	
}
 
void CAudioRecorder::StopL(void)
{

	if(iExampleTimer)
	{
		iExampleTimer->Cancel();
	}
	
    if(iRecorderUtility)
    {
    	iRecorderUtility->Stop();
    }
 
    ReportStateAndTime();
    
}
 
void CAudioRecorder::SetVolume(TInt& aVolume)
{

	if(aVolume < 1)
		aVolume = 1;
	else if(aVolume > 10)
		aVolume = 10;
	
	iVolume = aVolume;// save to internal value always
	if(iRecorderUtility) // and if utility exists, set it to it as well.
	{
		TInt Vol = ((iRecorderUtility->MaxVolume() * iVolume) / 10);
		iRecorderUtility->SetVolume(Vol);
	}
}
 
void CAudioRecorder::ReportStateAndTime(void)
{
 
	TInt CurrPosition(0),FileDuration(0);
	
	CMdaAudioClipUtility::TState CurrState(CMdaAudioClipUtility::ENotReady);
	
	if(iRecorderUtility)
	{
		CurrState =  iRecorderUtility->State();
		
		TInt64 HelpPos = iRecorderUtility->Position().Int64();	
		CurrPosition = HelpPos / 1000000;
 
		HelpPos = iRecorderUtility->RecordTimeAvailable().Int64();
		FileDuration = HelpPos / 1000000;
	}
	
	iObserver.StateUpdate(CurrState,CurrPosition,FileDuration);
	 
}
 
 
void CAudioRecorder::MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode)
{
 

	if(aObject == iRecorderUtility)
	{
		ReportStateAndTime();
		
		switch(aCurrentState)
		{
		case CMdaAudioClipUtility::EOpen:
			{
			
				if(aPreviousState == CMdaAudioClipUtility::ENotReady)
				{
					TInt Vol = ((iVolume * iRecorderUtility->MaxVolume()) / 10);
					iRecorderUtility->SetVolume(Vol);
					
					
					TRAPD(err,
						iRecorderUtility->SetGain(iRecorderUtility->MaxGain());
			    		iRecorderUtility->RecordL(););
					
				}
			}
			break;
		case CMdaAudioClipUtility::EPlaying:
            {
            
            }           
            break;		    
		case CMdaAudioClipUtility::ERecording:
            {
            
            }           
            break;		    
		case CMdaAudioClipUtility::ENotReady:
            {
            
            }           
            break;		    
		default: // no need to do anything on these states.
		    {
		    
		    }		    
			break;
		}
	}
}