MCL/sf/app/phone: comparison phoneapp/phoneuiview/src/cphoneaudioplayer.cpp

equal deleted inserted replaced

-:24062c24fe38
+:2a26698d78ba
 #include "cphoneaudioplayer.h"
 #include "cphoneringingtone.h"
 #include "mphoneaudioplayerobserver.h"
 #include "phoneconstants.h"
-#include "phonelogger.h"
+#include "phoneuiviewtrace.h"
 #include "phoneui.pan"
 // CONSTANTS
 //
 void CPhoneAudioPlayer::ConstructL(
 const TDesC& aFileName,
 CMdaServer* aMdaServer )
 {
-__LOGMETHODSTARTEND( EPhoneUIView, "CPhoneAudioPlayer::ConstructL()" );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::ConstructL() <" );
 if ( iFormat == EFormatTone )
 {
 iTonePlayer = CMdaAudioToneUtility::NewL( *this, aMdaServer );
 iTonePlayer->PrepareToPlayFileSequence( aFileName );
 iPlayerStatus = EToneLoading;
 }
 else
 {
 //audio sample player
-__PHONELOG3(
+PHONEUIVIEW_PRINTF3(
-EBasic,
-EPhoneUIView,
 "CPhoneAudioPlayer::ConstructL - aFileName(%S), iPriority(%d), iPreference(%d)",
 &aFileName,
 iPriority,
 iPreference );
 iSamplePlayer = CMdaAudioPlayerUtility::NewFilePlayerL(
 aFileName,
 *this,
 iPriority,
 static_cast< TMdaPriorityPreference >( iPreference ),
 aMdaServer );
 iPlayerStatus = EToneLoading;
 }
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::ConstructL() >" );
 }
 // -----------------------------------------------------------------------------
 // CPhoneAudioPlayer::ConstructSeqL
 // -----------------------------------------------------------------------------
 //
 void CPhoneAudioPlayer::ConstructSeqL(
 const TDesC8& aSequence,
 CMdaServer* aMdaServer )
 {
-__LOGMETHODSTARTEND( EPhoneUIView, "CPhoneAudioPlayer::ConstructSeqL()" );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::ConstructSeqL() <" );
 iTonePlayer = CMdaAudioToneUtility::NewL( *this, aMdaServer );
 iSequence = aSequence.AllocL();
 iTonePlayer->PrepareToPlayDesSequence( *iSequence );
 iPlayerStatus = EToneLoading;
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::ConstructSeqL() >" );
 }
 // -----------------------------------------------------------------------------
 // CPhoneAudioPlayer::ConstructTtsL
 // -----------------------------------------------------------------------------
 void CPhoneAudioPlayer::ConstructTtsL(
 const TDesC& aTtsText,
 TInt aPriority,
 TUint aPreference )
 {
-__LOGMETHODSTARTEND( EPhoneUIView, "CPhoneAudioPlayer::ConstructTtsL()" );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::ConstructTtsL() <" );
 delete iTtsPlayer; // if any
 iTtsPlayer = NULL;
 iTtsPlayer =
 CMdaAudioPlayerUtility::NewL(
 *this, aPriority,
 static_cast< TMdaPriorityPreference >( aPreference ) );
 delete iTtsText;  // if any
 iTtsText = NULL;
 // UTF-8 strings can take up to 4 bytes per character
 iTtsText = HBufC8::NewL( aTtsText.Length() << KTimesToMultiply );
 TPtr8 refText = iTtsText->Des();
 User::LeaveIfError(
 CnvUtfConverter::ConvertFromUnicodeToUtf8( refText, aTtsText ) );
 // UTF-8 chars can be up to 4 bytes long, but usually
 if ( !iTtsText )
 {
 // ReAlloc failed, set back to original.
 iTtsText = oldText;
 }
 iTtsPlayer->OpenDesL( *iTtsText );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::ConstructTtsL() >" );
 }
 // -----------------------------------------------------------------------------
 // CPhoneAudioPlayer::New
 // -----------------------------------------------------------------------------
 MPhoneAudioPlayerObserver& aObserver,
 TInt aId,
 CMdaServer* aMdaServer,
 TBool aExtSecNeeded )
 {
-__LOGMETHODSTARTEND( EPhoneUIView, "CPhoneAudioPlayer::New()" );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::New() <" );
 CPhoneAudioPlayer* self = NULL;
 TRAPD( err, self = CPhoneAudioPlayer::NewL(
 aRingingTone,
 aPriority,
 aPreference,
 aExtSecNeeded ) );
 if ( err != KErrNone )
 {
 return NULL;
 }
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::New() >" );
 return self;
 }
 // -----------------------------------------------------------------------------
 // CPhoneAudioPlayer::NewL
 MPhoneAudioPlayerObserver& aObserver,
 TInt aId,
 CMdaServer* aMdaServer,
 TBool aExtSecNeeded )
 {
-__LOGMETHODSTARTEND( EPhoneUIView, "CPhoneAudioPlayer::NewL()" );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::NewL() <" );
-__PHONELOG1( EBasic, EPhoneUIView, "CPhoneAudioPlayer::NewL - aExtSecNeeded(%d)",
+PHONEUIVIEW_PRINTF( "CPhoneAudioPlayer::NewL - aExtSecNeeded(%d)",
 aExtSecNeeded );
 // Check the file DRM property if extend secure is needed.
 if ( aExtSecNeeded )
 {
 if ( !aRingingTone.IsFileInRom() &&
 !aRingingTone.IsFileDrmProtected() )
 {
-__PHONELOG( EBasic, EPhoneUIView, "CPhoneAudioPlayer::NewL - DRM extend security check permission denied" );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::NewL - DRM extend security check permission denied" );
 User::Leave( KErrPermissionDenied );
 }
-__PHONELOG( EBasic, EPhoneUIView, "CPhoneAudioPlayer::NewL - DRM extend security check ok" );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::NewL - DRM extend security check ok" );
 }
-	// RNG file types have to be played with CMdaAudioToneUtility player.
+// RNG file types have to be played with CMdaAudioToneUtility player.
-	// Otherwise use sample player
+// Otherwise use sample player
 TAudioDataFormat format =
 ( aRingingTone.MimeType().CompareF( KFileListRngMimeType ) == KErrNone )
 ? EFormatTone :EFormatSample;
 CPhoneAudioPlayer* self =
 format,
 aObserver,
 aPriority,
 aPreference,
 aId );
 CleanupStack::PushL( self );
 self->ConstructL( aRingingTone.FileName(), aMdaServer );
 CleanupStack::Pop( self );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::NewL() >" );
 return self;
 }
 // -----------------------------------------------------------------------------
 // CPhoneAudioPlayer::NewL
 MPhoneAudioPlayerObserver& aObserver,
 TInt aId,
 CMdaServer* aMdaServer,
 TBool aExtSecNeeded )
 {
-__LOGMETHODSTARTEND( EPhoneUIView, "CPhoneAudioPlayer::NewL()" );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::NewL() <" );
 CPhoneRingingTone* tone = CPhoneRingingTone::NewL( aFileName );
 CleanupStack::PushL( tone );
 CPhoneAudioPlayer* player = CPhoneAudioPlayer::NewL( *tone,
 aPriority,
 aId,
 aMdaServer,
 aExtSecNeeded );
 CleanupStack::PopAndDestroy( tone );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::NewL() >");
 return player;
 }
 // -----------------------------------------------------------------------------
 // CPhoneAudioPlayer::NewSeqL
 // -----------------------------------------------------------------------------
 TUint aPreference,
 MPhoneAudioPlayerObserver& aObserver,
 TInt aId,
 CMdaServer* aMdaServer )
 {
-__LOGMETHODSTARTEND( EPhoneUIView, "CPhoneAudioPlayer::NewSeqL()" );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::NewSeqL() <" );
 CPhoneAudioPlayer* self =
 new (ELeave) CPhoneAudioPlayer(
 EFormatTone,
 aObserver,
 aPriority,
 aPreference,
 aId );
 CleanupStack::PushL( self );
 self->ConstructSeqL( aSequence, aMdaServer  );
 CleanupStack::Pop( self );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::NewSeqL() >" );
 return self;
 }
 // -----------------------------------------------------------------------------
 // CPhoneAudioPlayer::NewTtsL
 TInt aPriority,
 TUint aPreference,
 MPhoneAudioPlayerObserver& aObserver,
 TInt aId )
 {
-__LOGMETHODSTARTEND( EPhoneUIView, "CPhoneAudioPlayer::NewTtsL()" );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::NewTtsL() <" );
 CPhoneAudioPlayer* self =
 new (ELeave) CPhoneAudioPlayer(
 EFormatTts,
 aObserver,
 aPriority,
 aPreference,
 aId );
 CleanupStack::PushL( self );
 self->ConstructTtsL( aText, aPriority, aPreference );
 CleanupStack::Pop( self );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::NewTtsL() >" );
 return self;
 }
 // -----------------------------------------------------------------------------
 // CPhoneAudioPlayer::~CPhoneAudioPlayer
 // -----------------------------------------------------------------------------
 //
 CPhoneAudioPlayer::~CPhoneAudioPlayer()
 {
 if ( iAudioOutput )
 {
-	delete iAudioOutput;
+delete iAudioOutput;
 }
 if ( iTonePlayer )
 {
 delete iTonePlayer;
 }
 if ( i3DPlugin )
 {
 i3DPlugin->Stop();
 delete i3DPlugin;
 }
 // ECom cleanup
 REComSession::FinalClose();
 if ( iSamplePlayer )
 {
 delete iSamplePlayer;
 }
 if ( iTtsPlayer )
 {
 delete iTtsPlayer;
 }
 if ( iSequence )
 {
 delete iSequence;
 }
 if ( iTtsText )
 {
 delete iTtsText;
 }
 }
 // -----------------------------------------------------------------------------
 // CPhoneAudioPlayer::Play
 // -----------------------------------------------------------------------------
 //
 void CPhoneAudioPlayer::Play( TRingingType aRingType, TInt aVolume, TInt aTTsToBePlayed )
 {
-__LOGMETHODSTARTEND( EPhoneUIView, "CPhoneAudioPlayer::Play()" );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::Play() <" );
-__PHONELOG2(
+PHONEUIVIEW_PRINTF2(
-EBasic,
-EPhoneUIView,
 "CPhoneAudioPlayer::Play - iFormat(%d), iPlayerStatus(%d)",
 iFormat,
 iPlayerStatus );
-__PHONELOG3(
+PHONEUIVIEW_PRINTF3(
-EBasic,
-EPhoneUIView,
 "CPhoneAudioPlayer::Play - aRingType(%d), aVolume(%d), aTTsToBePlayed(%d)",
 aRingType,
 aVolume,
 aTTsToBePlayed );
 iRingType = aRingType;
 iVolume = aVolume;
 iTTsToBePlayed = aTTsToBePlayed;
 if ( iFormat == EFormatTone )
 {
 switch ( iPlayerStatus )
 {
 case ETonePlaying:
 iToBePlaying = ETrue;
 break;
 default:
 __ASSERT_DEBUG( EFalse,
+Panic( EPhoneViewCaseNotHandled ) );
-Panic( EPhoneViewCaseNotHandled ) );
 }
 }
 else if ( iFormat == EFormatTts )
 {
 switch ( iPlayerStatus )
 iToBePlaying = ETrue;
 break;
 default:
 __ASSERT_DEBUG( EFalse,
 Panic( EPhoneViewCaseNotHandled ) );
 }
 }
-}
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::Play() >" );
+}
 // -----------------------------------------------------------------------------
 // CPhoneAudioPlayer::ReStartPlaying
 // -----------------------------------------------------------------------------
 //
 void CPhoneAudioPlayer::ReStartPlaying()
 {
-__LOGMETHODSTARTEND( EPhoneUIView, "CPhoneAudioPlayer::ReStartPlaying()" );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::ReStartPlaying() <" );
-__PHONELOG3(
+PHONEUIVIEW_PRINTF3(
-EBasic,
-EPhoneUIView,
 "CPhoneAudioPlayer::ReStartPlaying - iFormat(%d), iRingType(%d), iVolume(%d)",
 iFormat,
 iRingType,
 iVolume );
 if ( iFormat == EFormatTone )
 {
 iTonePlayer->Play();
 iPlayerStatus = ETonePlaying;
 }
 else if ( iFormat == EFormatTts )
 {
 iTtsPlayer->Play();
 iPlayerStatus = ETonePlaying;
 }
 else
 {
 iSamplePlayer->Play();
 iPlayerStatus = ETonePlaying;
 }
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::ReStartPlaying() >" );
 }
 // -----------------------------------------------------------------------------
 // CPhoneAudioPlayer::StopPlaying
 // -----------------------------------------------------------------------------
 //
 void CPhoneAudioPlayer::StopPlaying()
 {
-__LOGMETHODSTARTEND( EPhoneUIView, "CPhoneAudioPlayer::StopPlaying()" );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::StopPlaying() <" );
 iToBePlaying = EFalse;
 if ( iFormat == EFormatTone )
 {
 if ( EMdaAudioToneUtilityPrepared == iTonePlayer->State() )
 {
 iTonePlayer->CancelPrepare();
 delete i3DPlugin;
 i3DPlugin = NULL;
 }
 else
 {
 iSamplePlayer->Stop();
 }
 }
 iPlayerStatus = EToneReady;
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::StopPlaying() >" );
 }
 // -----------------------------------------------------------------------------
 // CPhoneAudioPlayer::MapcInitComplete
 // -----------------------------------------------------------------------------
 //
 void CPhoneAudioPlayer::MapcInitComplete(
 TInt aError,
 const TTimeIntervalMicroSeconds& /*aDuration*/ )
 {
-__LOGMETHODSTARTEND( EPhoneUIView, "CPhoneAudioPlayer::MapcInitComplete()" );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::MapcInitComplete() <" );
-__PHONELOG1( EBasic, EPhoneUIView, "CPhoneAudioPlayer::MapcInitComplete - aError(%d)",
+PHONEUIVIEW_PRINTF( "CPhoneAudioPlayer::MapcInitComplete - aError(%d)",
 aError );
 __ASSERT_DEBUG( ( ( iFormat == EFormatSample ) || ( iFormat == EFormatTts ) ) &&
 ( iPlayerStatus == EToneLoading ), Panic( EPhoneViewGeneralError ) );
 if ( aError == KErrNone )
 {
 {
 iObserver.HandleAudioPlayerError(
 MPhoneAudioPlayerObserver::EAudioPlayerInitializingFailure,
 aError, iId );
 }
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::MapcInitComplete() >" );
 }
 // -----------------------------------------------------------------------------
 // CPhoneAudioPlayer::MapcPlayComplete
 // -----------------------------------------------------------------------------
 //
 void CPhoneAudioPlayer::MapcPlayComplete( TInt aError )
 {
-__LOGMETHODSTARTEND( EPhoneUIView, "CPhoneAudioPlayer::MapcPlayComplete()" );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::MapcPlayComplete() <" );
-__PHONELOG2( EBasic, EPhoneUIView, "CPhoneAudioPlayer::MapcPlayComplete - iFormat(%d), aError(%d)",
+PHONEUIVIEW_PRINTF2( "CPhoneAudioPlayer::MapcPlayComplete - iFormat(%d), aError(%d)",
 iFormat, aError );
 iPlayerStatus = EToneReady;
 //Destruct 3D plugin before player itself gets destructed.
 //In case of continuous ringing type, stopplaying() handles
 //3d plugin destruction
 if ( i3DPlugin )
 {
 i3DPlugin->Stop();
 delete i3DPlugin;
 i3DPlugin = NULL;
 }
 if ( aError != KErrNone )
 {
 iObserver.HandleAudioPlayerError(
 }
 else
 {
 iObserver.HandlePlayingComplete( iId );
 }
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::MapcPlayComplete() >" );
 }
 // -----------------------------------------------------------------------------
 // CPhoneAudioPlayer::MatoPrepareComplete
 // -----------------------------------------------------------------------------
 //
 void CPhoneAudioPlayer::MatoPrepareComplete( TInt aError )
 {
-__LOGMETHODSTARTEND( EPhoneUIView, "CPhoneAudioPlayer::MatoPrepareComplete()" );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::MatoPrepareComplete() <" );
-__PHONELOG1( EBasic, EPhoneUIView, "CPhoneAudioPlayer::MatoPrepareComplete - aError(%d)",
+PHONEUIVIEW_PRINTF( "CPhoneAudioPlayer::MatoPrepareComplete - aError(%d)",
 aError );
-	__ASSERT_DEBUG( ( iFormat == EFormatTone ) && ( iPlayerStatus == EToneLoading ),
+__ASSERT_DEBUG( ( iFormat == EFormatTone ) && ( iPlayerStatus == EToneLoading ),
 Panic( EPhoneViewGeneralError ) );
 if ( aError == KErrNone )
 {
 if ( iToBePlaying )
 {
 {
 iObserver.HandleAudioPlayerError(
 MPhoneAudioPlayerObserver::EAudioPlayerInitializingFailure,
 aError, iId );
 }
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::MatoPrepareComplete() >" );
 }
 // -----------------------------------------------------------------------------
 // CPhoneAudioPlayer::MatoPlayComplete
 // -----------------------------------------------------------------------------
 //
 void CPhoneAudioPlayer::MatoPlayComplete(TInt aError)
 {
-__LOGMETHODSTARTEND( EPhoneUIView, "CPhoneAudioPlayer::MatoPlayComplete()" );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::MatoPlayComplete() <" );
-__PHONELOG1( EBasic, EPhoneUIView, "CPhoneAudioPlayer::MatoPlayComplete - aError(%d)",
+PHONEUIVIEW_PRINTF( "CPhoneAudioPlayer::MatoPlayComplete - aError(%d)",
 aError );
 if ( aError != KErrNone )
 {
 iObserver.HandleAudioPlayerError(
 MPhoneAudioPlayerObserver::EAudioPlayerPlayingFailure,
 }
 else
 {
 iObserver.HandlePlayingComplete( iId );
 }
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::MatoPlayComplete() >" );
 }
 // -----------------------------------------------------------------------------
 // CPhoneAudioPlayer::DoPlay
 // -----------------------------------------------------------------------------
 //
 void CPhoneAudioPlayer::DoPlay()
 {
-__LOGMETHODSTARTEND( EPhoneUIView, "CPhoneAudioPlayer::DoPlay()" );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::DoPlay() <" );
 __ASSERT_DEBUG( iPlayerStatus == ETonePlaying,
 Panic( EPhoneViewGeneralError ) );
 SetRingingTypeProperties();
 TInt err(KErrNone);
 if ( iFormat == EFormatTone )
 {
 iTonePlayer->Play();
 }
 else if ( iFormat == EFormatTts )
 {
 iTtsPlayer->Play();
 }
 else
 {
 TRAP( err,i3DPlugin = C3DRingingToneInterface::NewL( KNullUid ) );
 if ( !err && i3DPlugin )
 {
 }
 if ( err || !i3DPlugin )
 {
 if ( !iAudioOutput )
 {
-__PHONELOG( EBasic, EPhoneUIView, "CPhoneAudioPlayer::DoPlay c aud ");
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::DoPlay c aud ");
 TRAP (err, iAudioOutput = CAudioOutput::NewL( *iSamplePlayer ) );
 if ( err )
 {
-__PHONELOG1(EBasic, EPhoneUIView,
+PHONEUIVIEW_PRINTF( "CPhoneAudioPlayer::DoPlay iAudioOutput.err ", err );
-"P.AudPlayer.DoPlay.iAudioOutput.err ", err );
+}
-}
 }
 if ( !err && iAudioOutput )
 {
-__PHONELOG( EBasic, EPhoneUIView, "CPhoneAudioPlayer::DoPlay EALL ");
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::DoPlay EALL ");
 TRAP (err, iAudioOutput->SetAudioOutputL( CAudioOutput::EAll ) );
 if ( err )
 {
-__PHONELOG1( EBasic, EPhoneUIView,
+PHONEUIVIEW_PRINTF( "CPhoneAudioPlayer::DoPlay SetAudioOutputL.err ", err );
-"P.AudPlayer.DoPlay.SetAudioOutputL.err ", err );
 }
 }
 iSamplePlayer->Play();
 }
 }
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::DoPlay() >" );
 }
 // -----------------------------------------------------------------------------
 // CPhoneAudioPlayer::SetRingingTypeProperties
 // -----------------------------------------------------------------------------
 //
 void CPhoneAudioPlayer::SetRingingTypeProperties()
 {
-__LOGMETHODSTARTEND( EPhoneUIView, "CPhoneAudioPlayer::SetRingingTypeProperties()" );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::SetRingingTypeProperties() <" );
-__PHONELOG2( EBasic, EPhoneUIView, "CPhoneAudioPlayer::SetRingingTypeProperties - iFormat(%d), iRingType(%d)",
+PHONEUIVIEW_PRINTF2( "CPhoneAudioPlayer::SetRingingTypeProperties - iFormat(%d), iRingType(%d)",
 iFormat, iRingType );
 TInt rampTime( 0 );
 if ( iFormat == EFormatTone )
 {
 switch ( iRingType )
 {
 case ETypeRinging:
 //If we have TTS activated and ringingtype is ringing:
 //We need to play TTS sequence again when ringingtone restarts.
 //Thats why we need to set ringingtype to ETypeRingingOnce because
 //it is the only way of knowing when ringingtone is completed.
 //Then we can restart it with new TTS iterations.
 if ( iTTsToBePlayed )
 {
 //play only once
 iTonePlayer->SetRepeats( 0,
 TTimeIntervalMicroSeconds(
 KPhoneRingingRepeatsTrailPause ) );
 iTonePlayer->SetVolume( ConvertVolume( iVolume ) );
-__PHONELOG1(
+PHONEUIVIEW_PRINTF( "CPhoneAudioPlayer::SetRingingTypeProperties - Ringing tone with TTS, Set volume(%d) and ring once",
-EBasic,
-EPhoneUIView,
-"CPhoneAudioPlayer::SetRingingTypeProperties - Ringing tone with TTS, Set volume(%d) and ring once",
 iVolume );
 }
 else
 {
 iTonePlayer->SetRepeats( KPhoneMdaAudioToneRepeatForever,
 TTimeIntervalMicroSeconds(
 KPhoneRingingRepeatsTrailPause ) );
 iTonePlayer->SetVolume( ConvertVolume( iVolume ) );
-__PHONELOG1(
+PHONEUIVIEW_PRINTF( "CPhoneAudioPlayer::SetRingingTypeProperties - Ringing tone, Set volume(%d)",
-EBasic,
-EPhoneUIView,
-"CPhoneAudioPlayer::SetRingingTypeProperties - Ringing tone, Set volume(%d)",
 iVolume );
 }
 break;
 case ETypeRingingOnce:
 //play only once
 iTonePlayer->SetRepeats( 0,
 TTimeIntervalMicroSeconds(
 KPhoneRingingRepeatsTrailPause ) );
 iTonePlayer->SetVolume( ConvertVolume( iVolume ) );
-__PHONELOG1(
+PHONEUIVIEW_PRINTF( "CPhoneAudioPlayer::SetRingingTypeProperties - Ring once tone, set volume(%d)",
-EBasic,
-EPhoneUIView,
-"CPhoneAudioPlayer::SetRingingTypeProperties - Ring once tone, set volume(%d)",
 iVolume );
 break;
 case ETypeAscending:
 iTonePlayer->SetRepeats( KPhoneMdaAudioToneRepeatForever,
 //and ramptime needs to be different as usual
 if ( iTTsToBePlayed )
 {
 //rampTime in this case is only 3 seconds and volume is 1.
 rampTime = KPhoneAudioAscendingRampDuration;
-__PHONELOG1(
+PHONEUIVIEW_PRINTF( "CPhoneAudioPlayer::SetRingingTypeProperties - Ascending tone with TTS, Start from lowest volume, rampTime(%d)",
-EBasic,
-EPhoneUIView,
-"CPhoneAudioPlayer::SetRingingTypeProperties - Ascending tone with TTS, Start from lowest volume, rampTime(%d)",
 rampTime );
 iTonePlayer->SetVolumeRamp(
 TTimeIntervalMicroSeconds( rampTime ) );
 iCurrentVolume = 1; //we start from the lowest volume
 }
 else
 {
 //rampTime: time for one step * volume level
 rampTime = KPhoneAudioAscendingRampDuration*iVolume;
-__PHONELOG2(
+PHONEUIVIEW_PRINTF2( "CPhoneAudioPlayer::SetRingingTypeProperties - Ascending tone, Set volume(%d), rampTime(%d)",
-EBasic,
-EPhoneUIView,
-"CPhoneAudioPlayer::SetRingingTypeProperties - Ascending tone, Set volume(%d), rampTime(%d)",
 iVolume, rampTime );
 iTonePlayer->SetVolumeRamp(
 TTimeIntervalMicroSeconds( rampTime ) );
 iCurrentVolume = 1; //we start from the lowest volume
 iTonePlayer->SetVolume( ConvertVolume( iVolume ) );
 }
 break;
 default:
 Panic( EPhoneViewGeneralError );
 break;
 }
-__PHONELOG3(
+PHONEUIVIEW_PRINTF3( "CPhoneAudioPlayer::SetRingingTypeProperties - Tone, iPriority(%d), iPreference(%d), iVolume(%d)",
-EBasic,
-EPhoneUIView,
-"CPhoneAudioPlayer::SetRingingTypeProperties - Tone, iPriority(%d), iPreference(%d), iVolume(%d)",
 iPriority, iPreference, iVolume );
 //Set priority and preference
 iTonePlayer->SetPriority( iPriority,
 static_cast< TMdaPriorityPreference >( iPreference ) );
 case ETypeRingingOnce:
 iTtsPlayer->SetRepeats( 0, // play only once
 TTimeIntervalMicroSeconds(
 KPhoneRingingRepeatsTrailPause ) );
 iTtsPlayer->SetVolume( ConvertVolume( iVolume ) );
-__PHONELOG1(
+PHONEUIVIEW_PRINTF( "CPhoneAudioPlayer::SetRingingTypeProperties - TTS, Set volume(%d)",
-EBasic,
-EPhoneUIView,
-"CPhoneAudioPlayer::SetRingingTypeProperties - TTS, Set volume(%d)",
 iVolume );
 break;
 default:
 __ASSERT_DEBUG( EFalse,
 Panic( EPhoneViewCaseNotHandled ) );
 }
-__PHONELOG(
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::SetRingingTypeProperties - TTS" );
-EBasic,
-EPhoneUIView,
-"CPhoneAudioPlayer::SetRingingTypeProperties - TTS" );
 }
 else
 {
 switch ( iRingType )
 {
 case ETypeRinging:
 //If we have TTS activated and ringingtype is ringing:
 //We need to play TTS sequence again when ringingtone restarts.
 //Thats why we need to set ringingtype to ETypeRingingOnce because
 //it is theonly way of knowing when ringingtone is completed.
 //Then we can restartit with new TTS iterations.
 if ( iTTsToBePlayed )
 {
 //play only once
 iSamplePlayer->SetRepeats( 0,
 TTimeIntervalMicroSeconds(
 KPhoneRingingRepeatsTrailPause ) );
 iSamplePlayer->SetVolume( ConvertVolume( iVolume ) );
-__PHONELOG1(
+PHONEUIVIEW_PRINTF( "CPhoneAudioPlayer::SetRingingTypeProperties - Ringing sample with TTS, Ring only once, Set volume(%d)",
-EBasic,
-EPhoneUIView,
-"CPhoneAudioPlayer::SetRingingTypeProperties - Ringing sample with TTS, Ring only once, Set volume(%d)",
 iVolume );
 }
 else
 {
 iSamplePlayer->SetRepeats( KPhoneMdaAudioToneRepeatForever,
 TTimeIntervalMicroSeconds(
 KPhoneRingingRepeatsTrailPause ) );
 iSamplePlayer->SetVolume( ConvertVolume( iVolume ) );
-__PHONELOG1(
+PHONEUIVIEW_PRINTF( "CPhoneAudioPlayer::SetRingingTypeProperties - Ringing sample, Set volume(%d)",
-EBasic,
-EPhoneUIView,
-"CPhoneAudioPlayer::SetRingingTypeProperties - Ringing sample, Set volume(%d)",
 iVolume );
 }
 break;
 case ETypeRingingOnce:
 iSamplePlayer->SetRepeats( 0,//play only once
 TTimeIntervalMicroSeconds(
 KPhoneRingingRepeatsTrailPause ) );
 iSamplePlayer->SetVolume( ConvertVolume( iVolume ) );
-__PHONELOG1(
+PHONEUIVIEW_PRINTF( "CPhoneAudioPlayer::SetRingingTypeProperties - Ring once sample, set volume(%d)",
-EBasic,
-EPhoneUIView,
-"CPhoneAudioPlayer::SetRingingTypeProperties - Ring once sample, set volume(%d)",
 iVolume );
 break;
 case ETypeAscending:
 iSamplePlayer->SetRepeats( KPhoneMdaAudioToneRepeatForever,
 //and ramptime needs to be different as usual
 if ( iTTsToBePlayed )
 {
 //rampTime in this case is only 3 seconds and volume is 1.
 rampTime = KPhoneAudioAscendingRampDuration;
-__PHONELOG1(
+PHONEUIVIEW_PRINTF( "CPhoneAudioPlayer::SetRingingTypeProperties - Ascending sample with TTS, Start from lowest volume, rampTime(%d)",
-EBasic,
-EPhoneUIView,
-"CPhoneAudioPlayer::SetRingingTypeProperties - Ascending sample with TTS, Start from lowest volume, rampTime(%d)",
 rampTime );
 iSamplePlayer->SetVolumeRamp(
 TTimeIntervalMicroSeconds( rampTime ) );
 iCurrentVolume = 1; //we start from the lowest volume
 }
 else
 {
 //rampTime: time for one step * volume level
 rampTime = KPhoneAudioAscendingRampDuration*iVolume;
-__PHONELOG2(
+PHONEUIVIEW_PRINTF2( "CPhoneAudioPlayer::SetRingingTypeProperties - Ascending sample, Set volume(%d), rampTime(%d)",
-EBasic,
-EPhoneUIView,
-"CPhoneAudioPlayer::SetRingingTypeProperties - Ascending sample, Set volume(%d), rampTime(%d)",
 iVolume, rampTime );
 iSamplePlayer->SetVolumeRamp(
 TTimeIntervalMicroSeconds( rampTime ) );
 iCurrentVolume = 1; //we start from the lowest volume
 iSamplePlayer->SetVolume( ConvertVolume( iVolume ) );
 }
 break;
 default:
 Panic( EPhoneViewGeneralError );
 break;
 }
-__PHONELOG(
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::SetRingingTypeProperties - Sample" );
-EBasic,
+}
-EPhoneUIView,
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::SetRingingTypeProperties() >" );
-"CPhoneAudioPlayer::SetRingingTypeProperties - Sample" );
-}
 }
 // -----------------------------------------------------------------------------
 // CPhoneAudioPlayer::SetNewVolumeAndRamptime
 // -----------------------------------------------------------------------------
 //
 void CPhoneAudioPlayer::SetNewVolumeAndRamptime( TInt aVolume, TInt aRamptime )
 {
-__LOGMETHODSTARTEND( EPhoneUIView, "CPhoneAudioPlayer::SetNewVolumeAndRamptime()" );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::SetNewVolumeAndRamptime() <" );
 //Check that volume is in valid range.
 TInt volume = aVolume<1 ? 1:aVolume;
-__PHONELOG1( EBasic, EPhoneUIView, "CPhoneAudioPlayer::SetNewVolumeAndRamptime - aVolume(%d)",
+PHONEUIVIEW_PRINTF( "CPhoneAudioPlayer::SetNewVolumeAndRamptime - aVolume(%d)",
 aVolume );
 if ( iFormat == EFormatTone && iTonePlayer )
 {
 iTonePlayer->SetVolumeRamp(TTimeIntervalMicroSeconds( aRamptime ) );
 iTonePlayer->SetVolume( ConvertVolume( volume ) );
-__PHONELOG( EBasic, EPhoneUIView, "CPhoneAudioPlayer::SetNewVolumeAndRamptime - Tone player" );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::SetNewVolumeAndRamptime - Tone player" );
 }
 else if ( iFormat == EFormatTts && iTtsPlayer )
 {
 iTtsPlayer->SetVolumeRamp(TTimeIntervalMicroSeconds( aRamptime ) );
 iTtsPlayer->SetVolume( ConvertVolume( volume ) );
-__PHONELOG( EBasic, EPhoneUIView, "CPhoneAudioPlayer::SetNewVolumeAndRamptime - TTS player" );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::SetNewVolumeAndRamptime - TTS player" );
 }
 else
 {
 iSamplePlayer->SetVolumeRamp(TTimeIntervalMicroSeconds( aRamptime ) );
 iSamplePlayer->SetVolume( ConvertVolume( volume ) );
-__PHONELOG( EBasic, EPhoneUIView, "CPhoneAudioPlayer::SetNewVolumeAndRamptime - Sample player" );
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::SetNewVolumeAndRamptime - Sample player" );
 }
-}
+PHONEUIVIEW_PRINT( "CPhoneAudioPlayer::SetNewVolumeAndRamptime() >" );
+}
 // -----------------------------------------------------------------------------
 // CPhoneAudioPlayer::ConvertVolume
 // -----------------------------------------------------------------------------
 //
 TInt CPhoneAudioPlayer::ConvertVolume( TInt aVolume )
 {
-//_DDPRINT( 5, "P.AudPlayer.ConvertVolume.aVolume", aVolume );
+TInt result( 0 );
-TInt result( 0 );
 if ( iFormat == EFormatTone && iTonePlayer )
 {
 result = iTonePlayer->MaxVolume() * aVolume / KMaxVolumeLevel;
 }
 else if ( iFormat == EFormatTts && iTtsPlayer )
 {
 result = iTtsPlayer->MaxVolume() * aVolume / KMaxVolumeLevel;
 }
 else
 {
 result = iSamplePlayer->MaxVolume() * aVolume / KMaxVolumeLevel;
 }
-	// if user has selected minimum volume level
+// if user has selected minimum volume level
-	// set HW volume 1
+// set HW volume 1
 if ( aVolume == KMinVolumeLevel && result == 0 )
 {
 result = 1;
 }
 //_DDPRINT( 5, "P.AudPlayer.ConvertVolume.result", result );
 return result;
 }
 // -----------------------------------------------------------------------------
 // CPhoneAudioPlayer::SetTTsToBePlayed
 // -----------------------------------------------------------------------------
 //
 void CPhoneAudioPlayer::SetTTsToBePlayed( TBool aTTsToBePlayed )
-	{
+{
-	iTTsToBePlayed = aTTsToBePlayed;
+iTTsToBePlayed = aTTsToBePlayed;
-	}
+}
 // -----------------------------------------------------------------------------
 // CPhoneAudioPlayer::MutePlaying
 // -----------------------------------------------------------------------------
 //
 void CPhoneAudioPlayer::MutePlaying()
 {
 //_DPRINT( 5, "P.Aud.Mute" );
 if ( iPlayerStatus == ETonePlaying )
 {
 {
 iTtsPlayer->SetVolume(0);
 }
 else // EFormatSample
 {
 iSamplePlayer->SetVolume(0);
 }
 }
 else
 {
 // Mute called during EToneLoading state.
 iToBePlaying = EFalse;
 }
 }
 //  End of File

branch	RCL_3
changeset 5	2a26698d78ba
parent 3	8871b09be73b