recorderadapter.cpp

play stream media file. OS: symbian s60

/*
* ============================================================================
*  Name     : Recorderadapter.cpp
*  Part of  : RecorderExample
*  Created  : 20.03.2005 by Forum Nokia
*  Version  : 1.0.0
*  Copyright: Nokia Corporation
* ============================================================================
*/

//INCLUDES
#include <eikmenup.h>
#include <eikapp.h>

#include <eikappui.h>
#include <eikenv.h>

#include <aknutils.h>

#include "recorderContainer.h"

#include "recorderadapter.h"
#include <aknnotewrappers.h> //warning note

#include <e32std.h> //tint64

// The sound file's name produced in recording mode
_LIT(KRecorderFile, "record");
_LIT(KRecorderFileEnd, ".wav");

_LIT(KAudioRecorder, "Recorder");
 

// ----------------------------------------------------
// CRecorderAdapter::CRecorderAdapter()
// C++ default constructor
// ----------------------------------------------------
CRecorderAdapter::CRecorderAdapter()
{
	iStatus = EStop;
}

// ----------------------------------------------------
// CRecorderAdapter::NewL()
// ----------------------------------------------------
CRecorderAdapter* CRecorderAdapter::NewL(CRecorderContainer* Container)
    {
    CRecorderAdapter* self = NewLC(Container);
    CleanupStack::Pop(self); 
    return self;
    }

// ----------------------------------------------------
// CRecorderAdapter::NewLC()
// ----------------------------------------------------
CRecorderAdapter* CRecorderAdapter::NewLC(CRecorderContainer* Container)
{
    CRecorderAdapter* self = new (ELeave) CRecorderAdapter();
    CleanupStack::PushL(self);
    self->ConstructL(Container);
    return self;
}


// ----------------------------------------------------
// CRecorderAdapter::ConstructL()
// Recorder is initialized
// ----------------------------------------------------
void CRecorderAdapter::ConstructL(CRecorderContainer* Container)
{
    iContainer = Container;
    
    iMdaAudioRecorderUtility = CMdaAudioRecorderUtility::NewL(*this, 0, 80, EMdaPriorityPreferenceQuality);

	//Open last recent audio file
	OpenFileL(EFalse);  
}

// ----------------------------------------------------
// CRecorderAdapter::~CRecorderAdapter()
// ----------------------------------------------------
CRecorderAdapter::~CRecorderAdapter()
{
	delete iMdaAudioRecorderUtility;    
	iMdaAudioRecorderUtility = NULL;
}

void CRecorderAdapter::UpdateMenuL(CEikMenuPane* /*aMenuPane*/)
{
}


// ----------------------------------------------------
// CRecorderAdapter::PlayL()
// Set position and start playing audio file
void CRecorderAdapter::PlayL()
{
	// Set playback position to the start of the file
    iPosition = TTimeIntervalMicroSeconds(0);
    
    PlayCurrentPositionL();
}


// ----------------------------------------------------
// CRecorderAdapter::PlayCurrentPositionL()
// Start playing after setting up player
// ----------------------------------------------------
void CRecorderAdapter::PlayCurrentPositionL()
{
    // Play through the device speaker
    iMdaAudioRecorderUtility->SetAudioDeviceMode(CMdaAudioRecorderUtility::ELocal);

    // Set maximum volume for playback
    iMdaAudioRecorderUtility->SetVolume(iMdaAudioRecorderUtility->MaxVolume() - (iMdaAudioRecorderUtility->MaxVolume() / 4));

	//Set position to last played position
	iMdaAudioRecorderUtility->SetPosition(iPosition);
	
    iMdaAudioRecorderUtility->PlayL();
    
    iStatus = EPlaying;
}


// ----------------------------------------------------
// CRecorderAdapter::GetRecorderStatus()
// Return recorder status
// ----------------------------------------------------
TRecorderAdapterStatus CRecorderAdapter::GetRecorderStatus()
{
	return iStatus;	
}

// ----------------------------------------------------
// CRecorderAdapter::StopL()
// Stop both playing and recording
// ----------------------------------------------------
void CRecorderAdapter::StopL(TRecorderAdapterStatus aStatus)
{
	iPosition = iMdaAudioRecorderUtility -> Position();
	
    iMdaAudioRecorderUtility->Stop();
    
    iStatus = aStatus;
}

// ----------------------------------------------------
// CRecorderAdapter::RecordL()
// Starts recording after setting up
// ----------------------------------------------------
void CRecorderAdapter::RecordL()
{
	iStatus = ERecording;
  
   
#ifdef __SERIES60_20__
	// New audio file can be opened in 
	// Series 60 Platform 2nd Edition, including FP1 and FP2
		
    OpenFileL(ETrue);
#else

	// Set maximum gain for recording
    iMdaAudioRecorderUtility->SetGain(iMdaAudioRecorderUtility->MaxGain());
    
    // Delete current audio sample from beginning of file
    // CropL doesn't work according forum nokia know issues
   	// iMdaAudioRecorderUtility->CropL();
   	
   	iMdaAudioRecorderUtility->SetPosition(TTimeIntervalMicroSeconds(0));
   
    iMdaAudioRecorderUtility->RecordL();
    
    iContainer ->ResetAllValues(GetDuration(), GetMaxDuration());
    
#endif
}


// ----------------------------------------------------
// CRecorderAdapter::OpenFileL()
// Open last recent file or new file with bigger running number
// ----------------------------------------------------
void CRecorderAdapter::OpenFileL(TBool newFile)
{

	TFileName aFileName;
	aFileName.Append(KRecorderFile);
	
	TFileName tFullPath;
	CompleteWithAppPath(tFullPath); // aknutils.h
		

#ifdef __SERIES60_20__

	// in Series 60 sdk 1.2 new audio files can not be open
	// with this kind of structure (OpenFileL function can not open 
	// new audio file), new audio files are open only in Series 60 
	// Platform 2nd Edition, including FP1 and FP2
 
	//Open file session
	RFs fileSession;
    User::LeaveIfError(fileSession.Connect());
    CleanupClosePushL(fileSession);
    
    //Open program's directory to dir it
    RDir directory;
    TInt rValue = directory.Open(fileSession, tFullPath, KEntryAttNormal);
    if (rValue != KErrNone)
    {
    	User::Leave(rValue);
    }
    
    CleanupClosePushL(directory);

	//Ask directory's filelist
    TEntryArray fileList;    
    rValue = directory.Read(fileList);
    
    TInt maxValue = 0;

    if ( rValue == KErrNone || rValue == KErrEof)
    {
	    //Check folder's files and find last recent audio file    
	    for (TInt i = 0; i != fileList.Count(); ++i)
	    {
	    	TEntry fileEntry = fileList[i];
	    	
	    	//Check that file is valid audiofile	    		
	    	if (!fileEntry.IsReadOnly() && 
	    		!fileEntry.IsHidden() &&
	    		!fileEntry.IsSystem() && 
	    		!fileEntry.IsDir() &&
	    		fileEntry.iName.Find(KRecorderFile) != KErrNotFound)
	    	{
	    		//Find out running number
	    		TBuf<20> fileName = fileEntry.iName;
				fileName.Delete(fileEntry.iName.Find(KRecorderFileEnd),6);
				fileName.Delete(0,6);
				fileName.Trim();
								
				TInt multiplier = 1;
				TInt count = 0;
				for (TInt i = fileName.Length() - 1; i != -1;  --i)
				{
					TChar numberchar = fileName[i];
					TInt number = numberchar.GetNumericValue();
					
					count += number * multiplier;
					multiplier = multiplier * 10;
				}
				
				//Save current number of audio files
				if (count > maxValue)
				{
					maxValue = count;
				}
	    	}
	    }
	    
	    //If user is recording, let's change filenumber to bigger
	    if (newFile)
	    	++maxValue;
	    
	    //generate filename
	    aFileName.AppendNum(maxValue);
	    aFileName.Append(KRecorderFileEnd);	   
    }
	
#else

	//series 60 sdk 1.2
	aFileName.Append(KRecorderFileEnd);

#endif
				  
    //Show new filename in label
    iContainer -> SetText(aFileName);
    
    CompleteWithAppPath(aFileName);

    // Open an existing sample file for playback or recording,
    // causes MMdaObjectStateChangeObserver::MoscoStateChangeEvent to be called
    iMdaAudioRecorderUtility->OpenFileL(aFileName);

#ifdef __SERIES60_20__
    CleanupStack::PopAndDestroy();	//directory
    CleanupStack::PopAndDestroy();	//fileSession
#endif
    
}

// ----------------------------------------------------
// CRecorderAdapter::Identify()
// Returns identify string
// ----------------------------------------------------
const TDesC& CRecorderAdapter::Identify()
{
	return KAudioRecorder;
}

// ----------------------------------------------------
// CRecorderAdapter::MoscoStateChangeEvent()
// Is called, if recorder's state change.
// ----------------------------------------------------
void CRecorderAdapter::MoscoStateChangeEvent(CBase* /*Object*/, TInt aPreviousState, TInt CurrentState, TInt aErrorCode)
{
	if (aErrorCode != KErrNone)
		{	
			#ifdef __SERIES60_20__
			//If user wants record, but errors occurs, warning note is shown
			if (iStatus == ERecording)
				{
				_LIT(text, "Recording failed!");
				CAknWarningNote* note = new (ELeave) CAknWarningNote();
				note -> ExecuteLD(text);
				}
			#endif
				
			iStatus = EStop;
		}
	//When recorder is ready and state is ERecording, recording may start
	else if (iStatus == ERecording && CurrentState == 1 && aPreviousState == 0)
		{

#ifdef __SERIES60_20__

		// Set maximum gain for recording
	    iMdaAudioRecorderUtility->SetGain(iMdaAudioRecorderUtility->MaxGain());
	   	
	   	iMdaAudioRecorderUtility->SetPosition(TTimeIntervalMicroSeconds(0));
	   
	    iMdaAudioRecorderUtility->RecordL();
	    
	    iContainer ->ResetAllValues(GetDuration(), GetMaxDuration());
	    
 #endif
	    
		}
	//If playing stops to end of the file, status changes to EStop	
	else if (iStatus == EPlaying && CurrentState == 1)
		{
				iStatus = EStop;				
		}
}
	
// ----------------------------------------------------
// CRecorderAdapter::GetDuration()
// Returns current duration in seconds.
// ----------------------------------------------------
TInt CRecorderAdapter::GetDuration()
{
	TTimeIntervalMicroSeconds returnValue;
	if (iStatus == ERecording)
		returnValue = iMdaAudioRecorderUtility -> Duration();
	else if (iStatus == EPlaying)
		returnValue = iMdaAudioRecorderUtility -> Position();
	else
		return 0;
	
	TInt64 time = returnValue.Int64();
	time = time / 1000000;
		
	return time.GetTInt();
}


// ----------------------------------------------------
// CRecorderAdapter::GetMaxDuration()
// Returns audiofile's maximun duration in seconds.
// ----------------------------------------------------
TInt CRecorderAdapter::GetMaxDuration()
{

	TTimeIntervalMicroSeconds returnValue;
	
	if (iStatus == ERecording)
		returnValue = iMdaAudioRecorderUtility -> RecordTimeAvailable();
	else if (iStatus == EPlaying || iStatus == EPause)
		returnValue = iMdaAudioRecorderUtility -> Duration();
	else
		return 0;
	
	TInt64 time = returnValue.Int64();
	time = time / 1000000;
		
	return time.GetTInt();	
}


// End of File