// Copyright (c) 2006-2009 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:
//
// INCLUDES
#include <mmf/server/sounddevice.h>
#include "sounddevicebody.h"
/*
* Default Constructor.
*/
CMMFDevSound::CMMFDevSound()
{
}
/*
* Destructor.
*/
EXPORT_C CMMFDevSound::~CMMFDevSound()
{
delete iBody;
}
/*
* CMMFDevSound::NewL
*
* Constructs and returns a pointer to a new CMMFDevSound object.
*/
EXPORT_C CMMFDevSound* CMMFDevSound::NewL()
{
CMMFDevSound* self = new (ELeave) CMMFDevSound;
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(self);
return self;
}
/*
* CMMFDevSound::ConstructL
*
* Second phase constructor.
*/
void CMMFDevSound::ConstructL()
{
iBody = CBody::NewL();
}
/*
* CMMFDevSound::InitializeL
*
* Initializes CMMFDevSound object. On completion of Initialization will
* call InitializeComplete() on aDevSoundObserver.
*
* @param aDevSoundObserver. A reference to the DevSound Observer instance.
* @param aMode. A mode for which this object will be used.
*/
EXPORT_C void CMMFDevSound::InitializeL(MDevSoundObserver& aDevSoundObserver,TMMFState aMode)
{
iBody->InitializeL(aDevSoundObserver,aMode);
}
/*
* CMMFDevSound::InitializeL
*
* Initializes CMMFDevSound object with hardware device aHWDev. On completion
* of Initialization will call InitializeComplete() on aDevSoundObserver.
*
* Method is deprecated from OS release 9.5
*
* @param aDevSoundObserver. A reference to the DevSound Observer instance.
* @param aHWDev. CMMFHwDevice implementation identifier.
* @param aMode. A mode for which this object will be used.
*/
EXPORT_C void CMMFDevSound::InitializeL(
MDevSoundObserver& /*aDevSoundObserver*/,
TUid /*aHWDev*/,
TMMFState /*aMode*/)
{
User::Leave(KErrNotSupported);
}
/*
* CMMFDevSound::InitializeL
*
* Initializes CMMFDevSound object with hardware device with hardware
* device's FourCC code. On completion of Initialization will call
* InitializeComplete() on aDevSoundObserver.
*
* @param aDevSoundObserver. A reference to the DevSound Observer instance.
* @param aDesiredFourCC. CMMFHwDevice implementation FourCC.
* @param aMode. A mode for which this object will be used.
*/
EXPORT_C void CMMFDevSound::InitializeL(
MDevSoundObserver& aDevSoundObserver,
TFourCC aDesiredFourCC,
TMMFState aMode)
{
iBody->InitializeL(aDevSoundObserver, aDesiredFourCC, aMode);
}
/*
* CMMFDevSound::Capabilities
*
* Returns supported Audio settings.
*
* @return TMMFCapabilities device settings.
*/
EXPORT_C TMMFCapabilities CMMFDevSound::Capabilities()
{
return iBody->Capabilities();
}
/*
* CMMFDevSound::Config
*
* Returns current audio settings.
*
* @return TMMFCapabilities device settings.
*/
EXPORT_C TMMFCapabilities CMMFDevSound::Config() const
{
return iBody->Config();
}
/*
* CMMFDevSound::SetConfigL
*
* ConfigureS CMMFDevSound object with the settings in aConfig.
*
* Use this to set sampling rate, Encoding and Mono/Stereo.
*
* @param aConfig. CMMFDevSound configuration settings.
*/
EXPORT_C void CMMFDevSound::SetConfigL(const TMMFCapabilities& aConfig)
{
iBody->SetConfigL(aConfig);
}
/*
* CMMFDevSound::MaxVolume
*
* Returns an integer representing the maximum volume.
*
* This is the maximum volume which can be passed to CMMFDevSound::SetVolume.
*
* @return TInt
* The maximum volume. This value is platform dependent but is always
* greater than or equal to one.
*/
EXPORT_C TInt CMMFDevSound::MaxVolume()
{
return iBody->MaxVolume();
}
/*
* CMMFDevSound::Volume
*
* Returns an integer representing current volume level.
*
* @return TInt
* Current volume level.
*/
EXPORT_C TInt CMMFDevSound::Volume()
{
return iBody->Volume();
}
/*
* CMMFDevSound::SetVolume
*
* Changes current volume level to the specified value.
*
* The volume can be changed before or during playback and is effective
* immediately.
*
* @param TInt
* The volume setting. This can be any value between zero and the
* value returned by the call to CMMFDevSound::MaxVolume(). If the
* volume is out of range, it is automatically set to the minimum or
* maximum level closest to the value being passed in. Setting a zero
* value mutes the sound.
*/
EXPORT_C void CMMFDevSound::SetVolume(TInt aVolume)
{
iBody->SetVolume(aVolume);
}
/*
* CMMFDevSound::MaxGain
*
* Returns an integer representing the maximum microphone gain.
*
* This is the maximum value which can be passed to CMMFDevSound::SetGain.
*
* @return TInt
* The maximum gain. This value is platform dependent but is always
* greater than or equal to one.
*/
EXPORT_C TInt CMMFDevSound::MaxGain()
{
return iBody->MaxGain();
}
/*
* CMMFDevSound::Gain
*
* Returns an integer representing current gain.
*
* @return TInt
* The current gain level.
*/
EXPORT_C TInt CMMFDevSound::Gain()
{
return iBody->Gain();
}
/*
* CMMFDevSound::SetGain
*
* Changes current recording gain to a specified value.
*
* The gain can be changed before or during recording and is effective
* immediately.
*
* @param aGain. This can be any value between zero and the
* value returned by the call to CMMFDevSound::MaxGain(). If the
* gain is out of range, it is automatically set to minimum or maximum
* value closest to the value that is being passed.
* Setting a zero value mutes the microphone.
*/
EXPORT_C void CMMFDevSound::SetGain(TInt aGain)
{
iBody->SetGain(aGain);
}
/*
* CMMFDevSound::GetPlayBalanceL
*
* Returns the speaker balance set for playing.
*
* @param aLeftPercentage. On return contains the left speaker volume percentage.
* @param aRightPercentage. On return contains the left speaker volume percentage.
*/
EXPORT_C void CMMFDevSound::GetPlayBalanceL(TInt& aLeftPercentage,TInt& aRightPercentage)
{
iBody->GetPlayBalanceL(aLeftPercentage, aRightPercentage);
}
/*
* CMMFDevSound::SetPlayBalanceL
*
* Sets the speaker balance for playing.
*
* The speaker balance can be changed before or during playback and is
* effective immediately.
*
* @param aLeftPercentage. Left speaker volume perecentage. This can be any value between
* zero and 100. Setting a zero value mutes the sound on the left
* speaker.
* @param aRightPercentage. Right speaker volume perecentage. This can be any value between
* zero and 100. Setting a zero value mutes the sound on the right
* speaker.
*/
EXPORT_C void CMMFDevSound::SetPlayBalanceL(TInt aLeftPercentage, TInt aRightPercentage)
{
iBody->SetPlayBalanceL(aLeftPercentage, aRightPercentage);
}
/*
* CMMFDevSound::GetRecordBalanceL
*
* Returns the microphone gain balance set for recording.
*
* @param aLeftPercentage. On return contains the left microphone gain percentage.
* @param aRightPercentage. On return contains the right microphone gain percentage.
*/
EXPORT_C void CMMFDevSound::GetRecordBalanceL(TInt& aLeftPercentage, TInt& aRightPercentage)
{
iBody->GetRecordBalanceL(aLeftPercentage, aRightPercentage);
}
/*
* CMMFDevSound::SetRecordBalanceL
*
* Sets the microphone gain balance for recording.
*
* The microphone gain balance can be changed before or during recording and
* is effective immediately.
*
* @param aLeftPercentage. Left microphone gain precentage. This can be any value between zero
* and 100. Setting a zero value mutes the gain on the left microphone.
* @param aRightPercentage. Right microphone gain precentage. This can be any value between zero
* and 100. Setting a zero value mutes the gain on the right microphone
*/
EXPORT_C void CMMFDevSound::SetRecordBalanceL(TInt aLeftPercentage,TInt aRightPercentage)
{
iBody->SetRecordBalanceL(aLeftPercentage, aRightPercentage);
}
/*
* CMMFDevSound::PlayInitL
*
* Initializes audio device and starts the playback. Before playback can be
* started, its current client's access priority is first verified by the
* audio policy. In case of an error during the policy initialization, the
* PlayError() method will be called on the observer with KErrAccessDenied
* error code, otherwise BufferToBeFilled() method will be called with a
* buffer reference. After filling the buffer with the data, the client
* should call PlayData() to start playback.
*
* The amount of data that can be played is specified in
* CMMFBuffer::RequestSize(). Any data that is read into the buffer beyond
* this size will be ignored.
*
*/
EXPORT_C void CMMFDevSound::PlayInitL()
{
iBody->PlayInitL();
}
/*
* CMMFDevSound::RecordInitL
*
* Initializes audio device and starts the recording. Before recording can be
* started, its current client's access priority is first verified by the
* audio policy. In case of an error during the policy initialization, the
* RecordError() method will be called on the observer with KErrAccessDenied
* error code, otherwise BufferToBeEmptied() method will be called with a
* buffer reference. This buffer contains recorded or encoded data. After
* processing the data in the buffer, the client should call RecordData()
* to continue recording process.
*
* The amount of data that is available is specified in
* CMMFBuffer::RequestSize().
*
*/
EXPORT_C void CMMFDevSound::RecordInitL()
{
iBody->RecordInitL();
}
/*
* CMMFDevSound::PlayData
*
* Plays data in the buffer. The client should fill the buffer with a stream
* of sampled audio data before calling this method. The observer gets the
* reference to the buffer along with BufferToBeFilled() callback. When
* playing of the audio sample is complete, with success or not, the
* PlayError() method is called on the observer.
*/
EXPORT_C void CMMFDevSound::PlayData()
{
iBody->PlayData();
}
/*
* CMMFDevSound::RecordData
*
* Records audio data. Once the buffer is filled with recorded sampled audio
* data, the observer gets reference to the buffer along with
* BufferToBeEmptied() callback. After processing of the buffer (copying over
* to a different buffer or writing to a file) the client should call this
* method again to continue recording process.
*/
EXPORT_C void CMMFDevSound::RecordData()
{
iBody->RecordData();
}
/*
* CMMFDevSound::Stop
*
* Stops the ongoing operation (Play, Record, TonePlay)
*/
EXPORT_C void CMMFDevSound::Stop()
{
iBody->Stop();
}
/*
* CMMFDevSound::Pause
*
* Temporarily suspends the ongoing operation (Play, Record, TonePlay)
*/
EXPORT_C void CMMFDevSound::Pause()
{
iBody->Pause();
}
/*
* CMMFDevSound::SamplesRecorded
*
* Returns the number of recorded samples up to this point.
*
* @return TInt
* Value representing recorded samples.
*/
EXPORT_C TInt CMMFDevSound::SamplesRecorded()
{
return iBody->SamplesRecorded();
}
/*
* CMMFDevSound::SamplesPlayed
*
* Returns the number of played samples up to this point.
*
* @return TInt
* Value representing played samples.
*/
EXPORT_C TInt CMMFDevSound::SamplesPlayed()
{
return iBody->SamplesPlayed();
}
/*
* CMMFDevSound::PlayToneL
*
* Initializes audio device and starts playing a single tone according with
* the specified frequency and duration attributes.
*
* @param aFrequency. Frequency at with the tone will be played.
* @param aDuration. The period over which the tone will be played. A zero value causes
* no tone to be played.
*/
EXPORT_C void CMMFDevSound::PlayToneL(TInt aFrequency,const TTimeIntervalMicroSeconds& aDuration)
{
iBody->PlayToneL(aFrequency, aDuration);
}
/*
* CMMFDevSound::PlayDualToneL
*
* Initializes audio device and starts playing a dual tone.
* The tone consists of two sine waves of different frequencies summed
* together. Both frequencies and the duration are specified in the passed
* in attributes.
*
* @param aFrequencyOne. Value representing first frequency of the dual tone.
*
* @param aFrequencyTwo. Value representing second frequency of the dual tone.
*
* @param aDuration. The period over which the tone will be played. A zero value causes
* no tone to be played.
*/
EXPORT_C void CMMFDevSound::PlayDualToneL(
TInt aFrequencyOne,
TInt aFrequencyTwo,
const TTimeIntervalMicroSeconds& aDuration)
{
iBody->PlayDualToneL(aFrequencyOne, aFrequencyTwo, aDuration);
}
/*
* CMMFDevSound::PlayDTMFStringL
*
* Initializes audio device and starts playing DTMF string.
*
* @param aDTMFString. DTMF sequence in a descriptor.
*/
EXPORT_C void CMMFDevSound::PlayDTMFStringL(const TDesC& aDTMFString)
{
iBody->PlayDTMFStringL(aDTMFString);
}
/*
* CMMFDevSound::PlayToneSequenceL
*
* Initializes audio device and starts playing tone sequence.
*
* @param aData. Tone sequence in a descriptor.
*/
EXPORT_C void CMMFDevSound::PlayToneSequenceL(const TDesC8& aData)
{
iBody->PlayToneSequenceL(aData);
}
/*
* CMMFDevSound::PlayFixedSequenceL
*
* Initializes audio device and starts playing the specified tone sequence.
*
* Method is deprecated from OS release 9.5
*
* @param aSequenceNumber. The index identifying the specific pre-defined tone sequence. The
* index values are relative to zero. This can be any value between
* zero and the value returned by the call to
* CMdaAudioPlayerUtility::FixedSequenceCount() - 1. The function
* raises a panic if sequence number is out of range.
*/
EXPORT_C void CMMFDevSound::PlayFixedSequenceL(TInt /*aSequenceNumber*/)
{
User::Leave(KErrNotSupported);
}
/*
* CMMFDevSound::SetToneRepeats
*
* Defines the number of times the audio is to be repeated during the tone
* playback operation.
*
* A period of silence can follow each playing of tone. The tone playing can
* be repeated indefinitely.
*
* @param aRepeatCount. The number of times the tone, together with the trailing silence,
* is to be repeated. If this is set to KMdaRepeatForever, then the
* tone, together with the trailing silence, is repeated indefinitely
* or until Stop() is called. If this is set to zero, then the tone is
* not repeated. Supported only during the tone playing.
* @param aRepeatTrailingSilence. The duration of the trailing silence.
*/
EXPORT_C void CMMFDevSound::SetToneRepeats(TInt aRepeatCount,const TTimeIntervalMicroSeconds& aRepeatTrailingSilence)
{
iBody->SetToneRepeats(aRepeatCount, aRepeatTrailingSilence);
}
/*
* CMMFDevSound::SetDTMFLengths
*
* Defines the duration of 'tone on/tone off' and 'tone pause' to be used
* during the DTMF playback.
*
* Supported only during tone playing.
*
* @param aToneOnLength. The period over which the tone will be played. If this is set to
* zero, then the tone is not played.
*
* @param aToneOffLength. The period over which 'no tone' will be played.
*
* @param aPauseLength. The period over which the tone playing will be paused.
*/
EXPORT_C void CMMFDevSound::SetDTMFLengths(
TTimeIntervalMicroSeconds32& aToneOnLength,
TTimeIntervalMicroSeconds32& aToneOffLength,
TTimeIntervalMicroSeconds32& aPauseLength)
{
iBody->SetDTMFLengths(aToneOnLength, aToneOffLength, aPauseLength);
}
/*
* CMMFDevSound::SetVolumeRamp
*
* Defines the period over which the volume level will rise smoothly from
* mute to the normal volume level.
*
* @param aRampDuration. The period over which the volume is to rise. A zero value causes
* the tone sample to be played at the normal level for the full duration of the
* playback. A value, which is longer than the duration
* of the tone sample, will result in the sample never reaching its
* normal volume level.
*/
EXPORT_C void CMMFDevSound::SetVolumeRamp(const TTimeIntervalMicroSeconds& aRampDuration)
{
iBody->SetVolumeRamp(aRampDuration);
}
/*
* CMMFDevSound::SetPrioritySettings
*
* Defines the priority settings that should be used for this instance.
*
* @param aPrioritySettings. A structure representing client's priority, priority
* preference and the state.
*/
EXPORT_C void CMMFDevSound::SetPrioritySettings(const TMMFPrioritySettings& aPrioritySettings)
{
iBody->SetPrioritySettings(aPrioritySettings);
}
/*
* CMMFDevSound::CustomInterface
*
* Sends request to the DevSound Server to start custom interface specified
* by the TUid attribute.
*
* @param aInterface. Unique ID of the custom interface
*
* @return TAny*
* Pointer to the custom interface object.
*/
EXPORT_C TAny* CMMFDevSound::CustomInterface(TUid aInterface)
{
return iBody->CustomInterface(aInterface);
}
/*
* CMMFDevSound::FixedSequenceCount
*
* Returns the number of available pre-defined tone sequences.
*
* Method is deprecated from OS release 9.5
*
* This is the number of fixed sequence supported by the DevSound by default.
*
* @return TInt
* The fixed sequence count. This value is implementation dependent
* but is always greater than or equal to zero.
*/
EXPORT_C TInt CMMFDevSound::FixedSequenceCount()
{
return 0;
}
/*
* CMMFDevSound::FixedSequenceName
*
* Returns the name assigned to a specific pre-defined tone sequence.
*
* Method is deprecated from OS release 9.5
*
* @param aSequenceNumber. The index identifying the specific pre-defined tone sequence.
* Index values are relative to zero. This can be any value between
* zero and the value returned by the call to
* CMdaAudioPlayerUtility::FixedSequenceCount() - 1. The function
* raises a panic if sequence number is out of range.
*
* @return TDesC&
* A reference to a descriptor containing fixed sequence name
* indexed by aSequenceNumber.
*/
EXPORT_C const TDesC& CMMFDevSound::FixedSequenceName(TInt /*aSequenceNumber*/)
{
return KNullDesC;
}
/*
* CMMFDevSound::GetSupportedInputDataTypesL
*
* Returns a list of supported input data types that can be sent to the
* DevSound for playing audio.
*
* @param aSupportedDataTypes. An array of supported data types.
* @param aPrioritySettings. Structure containing priority settings.
*/
EXPORT_C void CMMFDevSound::GetSupportedInputDataTypesL(RArray<TFourCC>& aSupportedDataTypes,const TMMFPrioritySettings& aPrioritySettings) const
{
iBody->GetSupportedInputDataTypesL(aSupportedDataTypes,
aPrioritySettings);
}
/*
* CMMFDevSound::GetSupportedOutputDataTypesL
*
* Returns a list of supported output data types that can be received from
* the DevSound for recording audio.
*
* @param aSupportedDataTypes. An array of supported data types.
* @param aPrioritySettings. Structure containing priority settings.
*/
EXPORT_C void CMMFDevSound::GetSupportedOutputDataTypesL(RArray<TFourCC>& aSupportedDataTypes,const TMMFPrioritySettings& aPrioritySettings) const
{
iBody->GetSupportedOutputDataTypesL(aSupportedDataTypes,aPrioritySettings);
}
/********************************************************************************
* Non Exported public functions ends here *
********************************************************************************/
/******************************************************************************
* Function Name: E32Dll
*
* Description: Entry point for applications.
*
******************************************************************************/
enum TDllReason {};
EXPORT_C TInt E32Dll(TDllReason /*aReason*/)
{
return KErrNone;
}
// CMMFDevSoundEventHandler::NewL() has been declared in export table
// but since it is the only class method to be so, and .h is in source
// it is not actually usable. Just declare the following to keep linker happy
// Need dummy abstract type - this is not the real class
class RMMFAudioPolicyProxy;
class CMMFDevSoundEventHandler : public CActive
{
public:
IMPORT_C static CMMFDevSoundEventHandler* NewL(RMMFAudioPolicyProxy*);
private:
CMMFDevSoundEventHandler();
};
EXPORT_C CMMFDevSoundEventHandler* CMMFDevSoundEventHandler::NewL(RMMFAudioPolicyProxy*)
{
_LIT(KModule, "DevSound");
User::Panic(KModule, 1000);
return NULL;
}
// default constructor - keep compilers happy
CMMFDevSoundEventHandler::CMMFDevSoundEventHandler():
CActive(EPriorityStandard)
{
}
// End of File