--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmserv/tms/tmsserver/src/tmsrtaudiohdlr.cpp Fri Apr 16 15:29:42 2010 +0300
@@ -0,0 +1,793 @@
+/*
+ * Copyright (c) 2010 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: Audio player implementation.
+ *
+ */
+
+// INCLUDE FILES
+#include <e32std.h>
+#include <utf.h> // For converting data for TTS
+#include "tmsshared.h"
+#include "tmsutility.h"
+#include "tmsrtaudiohdlr.h"
+#include "tmsrtcontainer.h"
+#include "tmsrtaudiohdlrobsrv.h"
+
+using namespace TMS;
+
+// CONSTANTS
+const TInt KMinVolumeLevel = 1;
+const TInt KMaxVolumeLevel = 10;
+const TInt KTMSRingingRepeatsTrailPause = 1000000;
+const TInt KTMSAudioAscendingRampDuration = 3000000;
+const TInt KTMSMdaAudioToneRepeatForever = -2;
+const TInt KUTF8Multiply = 2;
+
+_LIT(KFileListRngMimeType, "application/vnd.nokia.ringing-tone");
+
+// -----------------------------------------------------------------------------
+// TMSRtAudioHdlr::TMSRtAudioHdlr
+// -----------------------------------------------------------------------------
+//
+TMSRtAudioHdlr::TMSRtAudioHdlr(TAudioDataFormat aDataFormat,
+ TMSRtAudioHdlrObsrv& aObserver, TUint aPriority, TUint aPreference,
+ TInt aType) :
+ iFormat(aDataFormat),
+ iObserver(aObserver),
+ iPriority(aPriority),
+ iPreference(aPreference),
+ iRtType(aType)
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// TMSRtAudioHdlr::ConstructL
+// -----------------------------------------------------------------------------
+//
+void TMSRtAudioHdlr::ConstructL(const TDesC& aFileName)
+ {
+ TRACE_PRN_FN_ENT;
+ if (iFormat == EFormatTone)
+ {
+ iTonePlayer = CMdaAudioToneUtility::NewL(*this);
+ iTonePlayer->PrepareToPlayFileSequence(aFileName);
+ iPlayerStatus = EToneLoading;
+ }
+ else
+ {
+ iSamplePlayer = CMdaAudioPlayerUtility::NewFilePlayerL(aFileName, *this,
+ iPriority, iPreference);
+ iPlayerStatus = EToneLoading;
+ }
+ TRACE_PRN_FN_EXT;
+ }
+
+// -----------------------------------------------------------------------------
+// TMSRtAudioHdlr::ConstructSeqL
+// -----------------------------------------------------------------------------
+//
+void TMSRtAudioHdlr::ConstructSeqL(const TDesC8& aSequence)
+ {
+ TRACE_PRN_FN_ENT;
+ iTonePlayer = CMdaAudioToneUtility::NewL(*this);
+ iSequence = aSequence.AllocL();
+ iTonePlayer->PrepareToPlayDesSequence(*iSequence);
+ iPlayerStatus = EToneLoading;
+ TRACE_PRN_FN_EXT;
+ }
+
+// -----------------------------------------------------------------------------
+// TMSRtAudioHdlr::ConstructTtsL
+// -----------------------------------------------------------------------------
+//
+void TMSRtAudioHdlr::ConstructTtsL(const TDesC& aTtsText, TUint aPriority,
+ TUint aPreference)
+ {
+ TRACE_PRN_FN_ENT;
+ delete iTtsPlayer;
+ iTtsPlayer = NULL;
+ iTtsPlayer = CMdaAudioPlayerUtility::NewL(*this, aPriority, aPreference);
+
+ delete iTtsText;
+ iTtsText = NULL;
+ // UTF-8 strings can take up to 4 bytes per character
+ iTtsText = HBufC8::NewL(aTtsText.Length() << KUTF8Multiply);
+
+ TPtr8 refText = iTtsText->Des();
+ User::LeaveIfError(CnvUtfConverter::ConvertFromUnicodeToUtf8(refText,
+ aTtsText));
+
+ // UTF-8 chars can be up to 4 bytes long, but usually
+ // take 1-2 bytes, 3 for asian chars.
+ HBufC8* oldText = iTtsText;
+ iTtsText = iTtsText->ReAlloc(iTtsText->Length());
+ if (!iTtsText)
+ {
+ // ReAlloc failed, set back to original.
+ iTtsText = oldText;
+ }
+ iTtsPlayer->OpenDesL(*iTtsText);
+ TRACE_PRN_FN_EXT;
+ }
+
+// -----------------------------------------------------------------------------
+// TMSRtAudioHdlr::NewL
+// -----------------------------------------------------------------------------
+//
+TMSRtAudioHdlr* TMSRtAudioHdlr::NewL(const TMSRtContainer& aRingingTone,
+ TUint aPriority, TUint aPreference, TMSRtAudioHdlrObsrv& aObserver,
+ TInt aType, TBool aExtSecNeeded)
+ {
+ TRACE_PRN_FN_ENT;
+ // Check file DRM property if extended security is needed.
+ if (aExtSecNeeded)
+ {
+ if (!aRingingTone.IsFileInRom() && !aRingingTone.IsFileDrmProtected())
+ {
+ // DRM extended security check permission denied
+ User::Leave(KErrPermissionDenied);
+ }
+ // DRM extended security check ok
+ }
+
+ // RNG file types have to be played with CMdaAudioToneUtility player.
+ // Other audio formats use sample player
+ TAudioDataFormat format = (aRingingTone.MimeType().CompareF(
+ KFileListRngMimeType) == KErrNone) ? EFormatTone : EFormatSample;
+
+ TMSRtAudioHdlr* self = new (ELeave) TMSRtAudioHdlr(format, aObserver,
+ aPriority, aPreference, aType);
+ CleanupStack::PushL(self);
+ self->ConstructL(aRingingTone.FileName());
+ CleanupStack::Pop(self);
+ TRACE_PRN_FN_EXT;
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// TMSRtAudioHdlr::NewL
+// -----------------------------------------------------------------------------
+//
+TMSRtAudioHdlr* TMSRtAudioHdlr::NewL(const TDesC& aFileName, TUint aPriority,
+ TUint aPreference, TMSRtAudioHdlrObsrv& aObserver, TInt aType,
+ TBool aExtSecNeeded)
+ {
+ TRACE_PRN_FN_ENT;
+ TMSRtContainer* tone = TMSRtContainer::NewL(aFileName);
+ CleanupStack::PushL(tone);
+ TMSRtAudioHdlr* player = TMSRtAudioHdlr::NewL(*tone, aPriority, aPreference,
+ aObserver, aType, aExtSecNeeded);
+ CleanupStack::PopAndDestroy(tone);
+ TRACE_PRN_FN_EXT;
+ return player;
+ }
+
+// -----------------------------------------------------------------------------
+// TMSRtAudioHdlr::NewSeqL
+// -----------------------------------------------------------------------------
+//
+TMSRtAudioHdlr* TMSRtAudioHdlr::NewSeqL(const TDesC8& aSequence,
+ TUint aPriority, TUint aPreference, TMSRtAudioHdlrObsrv& aObserver,
+ TInt aType)
+ {
+ TRACE_PRN_FN_ENT;
+ TMSRtAudioHdlr* self = new (ELeave) TMSRtAudioHdlr(EFormatTone,
+ aObserver, aPriority, aPreference, aType);
+ CleanupStack::PushL(self);
+ self->ConstructSeqL(aSequence);
+ CleanupStack::Pop(self);
+ TRACE_PRN_FN_EXT;
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// TMSRtAudioHdlr::NewTtsL
+// -----------------------------------------------------------------------------
+//
+TMSRtAudioHdlr* TMSRtAudioHdlr::NewTtsL(const TDesC& aText, TUint aPriority,
+ TUint aPreference, TMSRtAudioHdlrObsrv& aObserver, TInt aType)
+ {
+ TRACE_PRN_FN_ENT;
+ TMSRtAudioHdlr* self = new (ELeave) TMSRtAudioHdlr(EFormatTts, aObserver,
+ aPriority, aPreference, aType);
+ CleanupStack::PushL(self);
+ self->ConstructTtsL(aText, aPriority, aPreference);
+ CleanupStack::Pop(self);
+ TRACE_PRN_FN_EXT;
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// TMSRtAudioHdlr::~TMSRtAudioHdlr
+// -----------------------------------------------------------------------------
+//
+TMSRtAudioHdlr::~TMSRtAudioHdlr()
+ {
+ TRACE_PRN_FN_ENT;
+ /*if (i3DPlugin)
+ {
+ i3DPlugin->Stop();
+ }
+ delete i3DPlugin;
+ delete iAudioOutput;*/
+ delete iTonePlayer;
+ delete iSamplePlayer;
+ delete iTtsPlayer;
+ delete iSequence;
+ delete iTtsText;
+ REComSession::FinalClose();
+ TRACE_PRN_FN_EXT;
+ }
+
+// -----------------------------------------------------------------------------
+// TMSRtAudioHdlr::Play
+// -----------------------------------------------------------------------------
+//
+void TMSRtAudioHdlr::Play(TRingingType aRingType, TInt aVolume,
+ TInt aTTsToBePlayed)
+ {
+ TRACE_PRN_FN_ENT;
+ iRingType = aRingType;
+ iVolume = aVolume;
+ iTTsToBePlayed = aTTsToBePlayed;
+
+ if (iFormat == EFormatTone)
+ {
+ switch (iPlayerStatus)
+ {
+ case ETonePlaying:
+ iTonePlayer->CancelPlay();
+ DoPlay();
+ break;
+ case EToneReady:
+ iPlayerStatus = ETonePlaying;
+ DoPlay();
+ break;
+ case EToneLoading:
+ iToBePlaying = ETrue;
+ break;
+ default:
+ __ASSERT_DEBUG(EFalse,
+ User::Panic(KTMSPanic, TMS_RESULT_DOES_NOT_EXIST));
+ break;
+ }
+ }
+ else if (iFormat == EFormatTts)
+ {
+ switch (iPlayerStatus)
+ {
+ case ETonePlaying:
+ iTtsPlayer->Stop();
+ DoPlay();
+ break;
+ case EToneReady:
+ iPlayerStatus = ETonePlaying;
+ DoPlay();
+ break;
+ case EToneLoading:
+ iToBePlaying = ETrue;
+ break;
+ default:
+ __ASSERT_DEBUG(EFalse,
+ User::Panic(KTMSPanic, TMS_RESULT_DOES_NOT_EXIST));
+ break;
+ }
+ }
+ else
+ {
+ switch (iPlayerStatus)
+ {
+ case ETonePlaying:
+ StopPlaying();
+ iPlayerStatus = ETonePlaying;
+ DoPlay();
+ break;
+ case EToneReady:
+ iPlayerStatus = ETonePlaying;
+ DoPlay();
+ break;
+ case EToneLoading:
+ iToBePlaying = ETrue;
+ break;
+ default:
+ __ASSERT_DEBUG(EFalse,
+ User::Panic(KTMSPanic, TMS_RESULT_DOES_NOT_EXIST));
+ break;
+ }
+ }
+ TRACE_PRN_FN_EXT;
+ }
+
+// -----------------------------------------------------------------------------
+// TMSRtAudioHdlr::ReStartPlaying
+// -----------------------------------------------------------------------------
+//
+void TMSRtAudioHdlr::ReStartPlaying()
+ {
+ TRACE_PRN_FN_ENT;
+ if (iFormat == EFormatTone)
+ {
+ iTonePlayer->Play();
+ iPlayerStatus = ETonePlaying;
+ }
+ else if (iFormat == EFormatTts)
+ {
+ iTtsPlayer->Play();
+ iPlayerStatus = ETonePlaying;
+ }
+ else
+ {
+ iSamplePlayer->Play();
+ iPlayerStatus = ETonePlaying;
+ }
+ TRACE_PRN_FN_EXT;
+ }
+
+// -----------------------------------------------------------------------------
+// TMSRtAudioHdlr::StopPlaying
+// -----------------------------------------------------------------------------
+//
+void TMSRtAudioHdlr::StopPlaying()
+ {
+ TRACE_PRN_FN_ENT;
+ iToBePlaying = EFalse;
+
+ if (iFormat == EFormatTone)
+ {
+ if (EMdaAudioToneUtilityPrepared == iTonePlayer->State())
+ {
+ iTonePlayer->CancelPrepare();
+ }
+ else if (EMdaAudioToneUtilityPlaying == iTonePlayer->State())
+ {
+ iTonePlayer->CancelPlay();
+ }
+ }
+ else if (iFormat == EFormatTts)
+ {
+ iTtsPlayer->Stop();
+ }
+ else
+ {
+/* if (i3DPlugin)
+ {
+ i3DPlugin->Stop();
+ delete i3DPlugin;
+ i3DPlugin = NULL;
+ }
+ else
+ {*/
+ iSamplePlayer->Stop();
+/* }*/
+ }
+ iPlayerStatus = EToneReady;
+ TRACE_PRN_FN_EXT;
+ }
+
+// -----------------------------------------------------------------------------
+// TMSRtAudioHdlr::MapcInitComplete
+// -----------------------------------------------------------------------------
+//
+void TMSRtAudioHdlr::MapcInitComplete(TInt aError,
+ const TTimeIntervalMicroSeconds& /*aDuration*/)
+ {
+ TRACE_PRN_N2(
+ _L("TMS->TMSRtAudioHdlr::MapcInitComplete: player[%d], err[%d]"),
+ iRtType, aError);
+
+ __ASSERT_DEBUG((iFormat == EFormatSample) ||
+ ((iFormat == EFormatTts) && (iPlayerStatus == EToneLoading)),
+ PANIC(TMS_RESULT_INVALID_STATE));
+
+ if (aError == TMS_RESULT_SUCCESS)
+ {
+ if (iToBePlaying)
+ {
+ iPlayerStatus = ETonePlaying;
+ iToBePlaying = EFalse;
+ DoPlay();
+ }
+ else
+ {
+ iPlayerStatus = EToneReady;
+ }
+ }
+ iObserver.RtAudioHdlrEvent(ECmdRingToneOpenComplete, aError, iRtType);
+ }
+
+// -----------------------------------------------------------------------------
+// TMSRtAudioHdlr::MapcPlayComplete
+// -----------------------------------------------------------------------------
+//
+void TMSRtAudioHdlr::MapcPlayComplete(TInt aError)
+ {
+ TRACE_PRN_N2(
+ _L("TMS->TMSRtAudioHdlr::MapcPlayComplete: player[%d], err[%d]"),
+ iRtType, aError);
+
+ iPlayerStatus = EToneReady;
+
+ // Delete 3D plugin before RT player. In case of continuous ringing type,
+ // 3D plugin is destructed in StopPlaying().
+/* if (i3DPlugin)
+ {
+ i3DPlugin->Stop();
+ delete i3DPlugin;
+ i3DPlugin = NULL;
+ }*/
+ iObserver.RtAudioHdlrEvent(ECmdRingTonePlayComplete, aError, iRtType);
+ }
+
+// -----------------------------------------------------------------------------
+// TMSRtAudioHdlr::MatoPrepareComplete
+// -----------------------------------------------------------------------------
+//
+void TMSRtAudioHdlr::MatoPrepareComplete(TInt aError)
+ {
+ TRACE_PRN_N2(
+ _L("TMS->TMSRtAudioHdlr::MatoPrepareComplete: player[%d], err[%d]"),
+ iRtType, aError);
+
+ __ASSERT_DEBUG(((iFormat == EFormatTone) &&
+ (iPlayerStatus == EToneLoading)), PANIC(TMS_RESULT_INVALID_STATE));
+
+ if (aError == TMS_RESULT_SUCCESS)
+ {
+ if (iToBePlaying)
+ {
+ iPlayerStatus = ETonePlaying;
+ iToBePlaying = EFalse;
+ DoPlay();
+ }
+ else
+ {
+ iPlayerStatus = EToneReady;
+ }
+ }
+ iObserver.RtAudioHdlrEvent(ECmdRingToneOpenComplete, aError, iRtType);
+ }
+
+// -----------------------------------------------------------------------------
+// TMSRtAudioHdlr::MatoPlayComplete
+// -----------------------------------------------------------------------------
+//
+void TMSRtAudioHdlr::MatoPlayComplete(TInt aError)
+ {
+ TRACE_PRN_N2(
+ _L("TMS->TMSRtAudioHdlr::MatoPlayComplete: player[%d], err[%d]"),
+ iRtType, aError);
+
+ iObserver.RtAudioHdlrEvent(ECmdRingTonePlayComplete, aError, iRtType);
+ }
+
+// -----------------------------------------------------------------------------
+// TMSRtAudioHdlr::DoPlay
+// -----------------------------------------------------------------------------
+//
+void TMSRtAudioHdlr::DoPlay()
+ {
+ TRACE_PRN_FN_ENT;
+
+ __ASSERT_DEBUG(iPlayerStatus == ETonePlaying,
+ PANIC(TMS_RESULT_INVALID_STATE));
+
+ //TInt err(TMS_RESULT_SUCCESS);
+ SetRingingTypeProperties();
+
+ if (iFormat == EFormatTone)
+ {
+ iTonePlayer->Play();
+ }
+ else if (iFormat == EFormatTts)
+ {
+ iTtsPlayer->Play();
+ }
+ else
+ {
+#ifdef __WINS__
+ iSamplePlayer->Play();
+#else
+/*
+ //TODO: compare with phoneapp
+ TInt err = KErrNone;
+ TRAP(err, i3DPlugin = C3DRingingToneInterface::NewL(KNullUid));
+ if (!err && i3DPlugin)
+ {
+ i3DPlugin->SetAttr(E3DRTIAttrAudioPlayerUtility, iSamplePlayer);
+ TRAP(err, i3DPlugin->PlayL())
+ }
+ if (err || !i3DPlugin)
+ {
+ if (!iAudioOutput)
+ {
+ TRAP(err, iAudioOutput = CAudioOutput::NewL(*iSamplePlayer));
+ }
+ if (!err && iAudioOutput)
+ {
+ TRAP(err, iAudioOutput->SetAudioOutputL(CAudioOutput::EAll));
+ }
+ }*/
+ iSamplePlayer->Play();
+#endif //__WINS__
+ }
+
+ TRACE_PRN_FN_EXT;
+ }
+
+// -----------------------------------------------------------------------------
+// TMSRtAudioHdlr::SetRingingTypeProperties
+// -----------------------------------------------------------------------------
+//
+void TMSRtAudioHdlr::SetRingingTypeProperties()
+ {
+ TInt rampTime(0);
+ if (iFormat == EFormatTone)
+ {
+ switch (iRingType)
+ {
+ case ETypeRinging:
+ {
+ // If we have TTS activated and ringing type is "ringing", then
+ // we need to play TTS sequence again when ringtone restarts.
+ // That's why we need to set ringing type to ETypeRingingOnce,
+ // because it is the only way of knowing when ringtone playback
+ // is completed. Then we can restart it with new TTS iterations.
+ if (iTTsToBePlayed)
+ {
+ // Play only once
+ iTonePlayer->SetRepeats(0, TTimeIntervalMicroSeconds(
+ KTMSRingingRepeatsTrailPause));
+ iTonePlayer->SetVolume(ConvertVolume(iVolume));
+ }
+ else
+ {
+ iTonePlayer->SetRepeats(KTMSMdaAudioToneRepeatForever,
+ TTimeIntervalMicroSeconds(
+ KTMSRingingRepeatsTrailPause));
+ iTonePlayer->SetVolume(ConvertVolume(iVolume));
+ }
+ break;
+ }
+ case ETypeRingingOnce:
+ {
+ // Play only once
+ iTonePlayer->SetRepeats(0, TTimeIntervalMicroSeconds(
+ KTMSRingingRepeatsTrailPause));
+ iTonePlayer->SetVolume(ConvertVolume(iVolume));
+ break;
+ }
+ case ETypeAscending:
+ {
+ iTonePlayer->SetRepeats(KTMSMdaAudioToneRepeatForever,
+ TTimeIntervalMicroSeconds(
+ KTMSRingingRepeatsTrailPause));
+
+ // Special case for TTS + ascending profile. Volume and
+ // ramptime need to be different then usual
+ if (iTTsToBePlayed)
+ {
+ // RampTime is only 3 seconds and volume is 1.
+ rampTime = KTMSAudioAscendingRampDuration;
+ iTonePlayer->SetVolumeRamp(TTimeIntervalMicroSeconds(
+ rampTime));
+ iCurrentVolume = 1; //we start from the lowest volume
+ iTonePlayer->SetVolume(ConvertVolume(iCurrentVolume));
+ }
+ else
+ {
+ // RampTime: time for one step * volume level
+ rampTime = KTMSAudioAscendingRampDuration * iVolume;
+ iTonePlayer->SetVolumeRamp(TTimeIntervalMicroSeconds(
+ rampTime));
+ iCurrentVolume = 1; //we start from the lowest volume
+ iTonePlayer->SetVolume(ConvertVolume(iVolume));
+ }
+ break;
+ }
+ default:
+ //PANIC(TMS_RESULT_DOES_NOT_EXIST);
+ break;
+ }
+ //Set priority and preference
+ iTonePlayer->SetPriority(iPriority, iPreference);
+ }
+ else if (iFormat == EFormatTts)
+ {
+ switch (iRingType)
+ {
+ case ETypeRinging:
+ case ETypeAscending:
+ {
+ // Not allowed for TTS.
+ break;
+ }
+ case ETypeRingingOnce:
+ {
+ iTtsPlayer->SetRepeats(0, TTimeIntervalMicroSeconds(
+ KTMSRingingRepeatsTrailPause));
+ iTtsPlayer->SetVolume(ConvertVolume(iVolume));
+ break;
+ }
+ default:
+ {
+ __ASSERT_DEBUG(EFalse, PANIC(TMS_RESULT_DOES_NOT_EXIST));
+ break;
+ }
+ }
+ }
+ else
+ {
+ switch (iRingType)
+ {
+ case ETypeRinging:
+ {
+ // If we have TTS activated and ringing type is "ringing", then
+ // we need to play TTS sequence again when ringtone restarts.
+ // That's why we need to set ringingtype to ETypeRingingOnce,
+ // because it is the only way of knowing when ringtone playback
+ // is completed. Then we can restart it with new TTS iterations.
+ if (iTTsToBePlayed)
+ {
+ // Play only once
+ iSamplePlayer->SetRepeats(0, TTimeIntervalMicroSeconds(
+ KTMSRingingRepeatsTrailPause));
+ iSamplePlayer->SetVolume(ConvertVolume(iVolume));
+ }
+ else
+ {
+ iSamplePlayer->SetRepeats(
+ KTMSMdaAudioToneRepeatForever,
+ TTimeIntervalMicroSeconds(
+ KTMSRingingRepeatsTrailPause));
+ iSamplePlayer->SetVolume(ConvertVolume(iVolume));
+ }
+ break;
+ }
+ case ETypeRingingOnce:
+ {
+ iSamplePlayer->SetRepeats(0, TTimeIntervalMicroSeconds(
+ KTMSRingingRepeatsTrailPause));
+ iSamplePlayer->SetVolume(ConvertVolume(iVolume));
+ break;
+ }
+ case ETypeAscending:
+ {
+ iSamplePlayer->SetRepeats(KTMSMdaAudioToneRepeatForever,
+ TTimeIntervalMicroSeconds(
+ KTMSRingingRepeatsTrailPause));
+
+ // Special case for TTS + ascending profile. Volume and
+ // ramptime need to be different then usual
+ if (iTTsToBePlayed)
+ {
+ // RampTime is only 3 seconds and volume is 1.
+ rampTime = KTMSAudioAscendingRampDuration;
+ iSamplePlayer->SetVolumeRamp(TTimeIntervalMicroSeconds(
+ rampTime));
+ iCurrentVolume = 1; //we start from the lowest volume
+ iSamplePlayer->SetVolume(ConvertVolume(iCurrentVolume));
+ }
+ else
+ {
+ // RampTime: time for one step * volume level
+ rampTime = KTMSAudioAscendingRampDuration * iVolume;
+ iSamplePlayer->SetVolumeRamp(TTimeIntervalMicroSeconds(
+ rampTime));
+
+ iCurrentVolume = 1; //we start from the lowest volume
+ iSamplePlayer->SetVolume(ConvertVolume(iVolume));
+ }
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// TMSRtAudioHdlr::SetNewVolumeAndRamptime
+// -----------------------------------------------------------------------------
+//
+void TMSRtAudioHdlr::SetNewVolumeAndRamptime(TInt aVolume, TInt aRamptime)
+ {
+ // Check that volume is in a valid range.
+ TInt volume = aVolume < 1 ? 1 : aVolume;
+
+ if (iFormat == EFormatTone && iTonePlayer)
+ {
+ iTonePlayer->SetVolumeRamp(TTimeIntervalMicroSeconds(aRamptime));
+ iTonePlayer->SetVolume(ConvertVolume(volume));
+ }
+ else if (iFormat == EFormatTts && iTtsPlayer)
+ {
+ iTtsPlayer->SetVolumeRamp(TTimeIntervalMicroSeconds(aRamptime));
+ iTtsPlayer->SetVolume(ConvertVolume(volume));
+ }
+ else
+ {
+ iSamplePlayer->SetVolumeRamp(TTimeIntervalMicroSeconds(aRamptime));
+ iSamplePlayer->SetVolume(ConvertVolume(volume));
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// TMSRtAudioHdlr::ConvertVolume
+// -----------------------------------------------------------------------------
+//
+TInt TMSRtAudioHdlr::ConvertVolume(TInt aVolume)
+ {
+ TInt result(0);
+
+ if (iFormat == EFormatTone)
+ {
+ result = iTonePlayer->MaxVolume() * aVolume / KMaxVolumeLevel;
+ }
+ else if (iFormat == EFormatTts)
+ {
+ result = iTtsPlayer->MaxVolume() * aVolume / KMaxVolumeLevel;
+ }
+ else
+ {
+ result = iSamplePlayer->MaxVolume() * aVolume / KMaxVolumeLevel;
+ }
+
+ // If user selected minimum volume level set HW volume 1
+ if (aVolume == KMinVolumeLevel && result == 0)
+ {
+ result = 1;
+ }
+ return result;
+ }
+
+// -----------------------------------------------------------------------------
+// TMSRtAudioHdlr::SetTTsToBePlayed
+// -----------------------------------------------------------------------------
+//
+void TMSRtAudioHdlr::SetTTsToBePlayed(const TBool aTTsToBePlayed)
+ {
+ iTTsToBePlayed = aTTsToBePlayed;
+ }
+
+// -----------------------------------------------------------------------------
+// TMSRtAudioHdlr::MutePlaying
+// -----------------------------------------------------------------------------
+//
+void TMSRtAudioHdlr::MutePlaying()
+ {
+ if (iPlayerStatus == ETonePlaying)
+ {
+ if (iFormat == EFormatTone)
+ {
+ iTonePlayer->SetVolume(0);
+ }
+ else if (iFormat == EFormatTts)
+ {
+ iTtsPlayer->SetVolume(0);
+ }
+ else // EFormatSample
+ {
+ iSamplePlayer->SetVolume(0);
+ }
+ }
+ else
+ {
+ // Mute during EToneLoading state.
+ iToBePlaying = EFalse;
+ }
+ }
+
+// End of File