--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/satui/satapp/src/satapptoneprovider.cpp Tue Aug 31 15:45:17 2010 +0300
@@ -0,0 +1,702 @@
+/*
+* 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:
+*
+*/
+
+// includes
+#include <QTimer>
+#include <QCoreApplication>
+#include <QtDebug>
+#include <hbmessagebox.h>//playtone note
+
+#include "SatAppToneProvider.h"
+#include "satappconstant.h"
+#include "satappaction.h"
+
+// ----------------------------------------------------------------------------
+// SatAppToneProvider::SatAppToneProvider
+// ----------------------------------------------------------------------------
+//
+SatAppToneProvider::SatAppToneProvider(QObject *parent) :
+ QObject(parent)
+{
+ qDebug("SATAPP: SatAppToneProvider::SatAppToneProvider <>");
+ mState = Idle;
+ mWarningAndPlayTones = false;
+ mVolume = 0;
+ mPlayer = 0;
+ mPlayToneError = ESatSuccess;
+ mTimer = 0;
+ mPermanentNote = 0;
+ mAudioPlayer = 0;
+ mCurrentAction = 0;
+}
+
+// ----------------------------------------------------------------------------
+// SatAppToneProvider::~SatAppToneProvider
+// ----------------------------------------------------------------------------
+//
+SatAppToneProvider::~SatAppToneProvider()
+{
+ qDebug("SATAPP: SatAppToneProvider::~SatAppToneProvider >");
+
+ if (mCurrentAction) {
+ stopPlayTone();
+ }
+
+ if (mPermanentNote) {
+ qDebug("SatAppToneProvider::resetState delete mPermanentNote");
+ delete mPermanentNote;
+ mPermanentNote = 0;
+ }
+
+ if (mTimer) {
+ qDebug("SatAppToneProvider::resetState delete timer");
+ delete mTimer;
+ mTimer = 0;
+ }
+
+ qDebug("SATAPP: SatAppToneProvider::~SatAppToneProvider <");
+}
+
+//-----------------------------------------------------------------------------
+// SatAppToneProvider::playTone
+//-----------------------------------------------------------------------------
+void SatAppToneProvider::playTone(SatAppAction& action)
+{
+ qDebug("SATAPP: SatAppToneProvider::playTone >");
+ resetState();
+
+ mCurrentAction = &action;
+ int tone = action.value(KeyToneId).toInt();
+ int duration = action.value(KeyDuration).toInt();
+ QString text = action.value(KeyText).toString();
+ QByteArray sequence;
+ mState = recognizeTone(tone,sequence,duration);
+ if (mState == PlayStandardTone)
+ {
+ playStandardTone(text,sequence,duration);
+ }
+ else if (mState == PlayUserSelectedTone)
+ {
+ playUserSelectedTone(text,tone,duration);
+ }
+ else
+ {
+ mCurrentAction->complete(ESatCmdDataNotUnderstood);
+ mCurrentAction = 0;
+ }
+ qDebug("SATAPP: SatAppToneProvider::playTone <");
+}
+
+//-----------------------------------------------------------------------------
+// SatAppToneProvider::recognizeTone
+// @param tone the tone code from server (see TSatTone in MSatUiObserver)
+// @param sequence (out) standard tone play sequence
+// @param duration (out) stanrard tone play duration (manipulated in some cases)
+// @return suggested state for the tone provider (or Idle if tone is not recognised)
+//-----------------------------------------------------------------------------
+SatAppToneProvider::State SatAppToneProvider::recognizeTone(
+ int tone,
+ QByteArray& sequence,
+ int& duration)
+{
+ qDebug("SATAPP: SatAppToneProvider::recognizeTone >");
+ State ret = Idle;
+ qDebug("SATAPP: SatAppToneProvider::recognizeTone tone: %d", tone);
+ switch (tone)
+ {
+ case ESatGeneralBeep:
+ case ESatPositiveTone:
+ case ESatToneNotSet:
+ {
+ if (duration == 0) duration = KSatDur170ms; // 170ms
+ sequence = charArrayToByteArray(KGeneralBeep,
+ sizeof(KGeneralBeep));
+ ret = PlayStandardTone;
+ break;
+ }
+ case ESatNegativeTone:
+ {
+ if (duration == 0) duration = KSatDur250ms; // 250ms
+ sequence = charArrayToByteArray(KErrorTone,
+ sizeof(KErrorTone));
+ ret = PlayStandardTone;
+ break;
+ }
+ case ESatRadioPathNotAvailableCallDropped:
+ {
+ if (duration == 0) duration = KSatDur1200ms; // 1200ms
+ sequence = charArrayToByteArray(KRadioPathNotAvailable,
+ sizeof(KRadioPathNotAvailable));
+ ret = PlayStandardTone;
+ break;
+ }
+ case ESatRadioPathAcknowledge:
+ {
+ if (duration == 0) duration = KSatDur200ms; // 200ms
+ sequence = charArrayToByteArray(KRadioPathAck,
+ sizeof(KRadioPathAck));
+ ret = PlayStandardTone;
+ break;
+ }
+ case ESatDialTone:
+ {
+ if (duration == 0) break;
+ sequence = charArrayToByteArray(KNetToneSeqDial,
+ sizeof(KNetToneSeqDial));
+ ret = PlayStandardTone;
+ break;
+ }
+ case ESatCalledSubscriberBusy:
+ {
+ if (duration == 0) break;
+ sequence = charArrayToByteArray(KNetToneSeqNetBusy,
+ sizeof(KNetToneSeqNetBusy));
+ ret = PlayStandardTone;
+ break;
+ }
+ case ESatCongestion:
+ {
+ if (duration == 0) break;
+ sequence = charArrayToByteArray(KNetToneSeqNetCongestion,
+ sizeof(KNetToneSeqNetCongestion));
+ ret = PlayStandardTone;
+ break;
+ }
+ case ESatErrorSpecialInfo:
+ {
+ if (duration == 0) break;
+ sequence = charArrayToByteArray(KNetToneSeqNetSpecialInformation,
+ sizeof(KNetToneSeqNetSpecialInformation));
+ ret = PlayStandardTone;
+ break;
+ }
+ case ESatCallWaitingTone:
+ {
+ if (duration == 0) break;
+ sequence = charArrayToByteArray(KNetToneSeqNetCallWaiting,
+ sizeof(KNetToneSeqNetCallWaiting));
+ ret = PlayStandardTone;
+ break;
+ }
+ case ESatRingingTone:
+ {
+ if (duration == 0) break;
+ sequence = charArrayToByteArray(KNetToneSeqRingGoing,
+ sizeof(KNetToneSeqRingGoing));
+ ret = PlayStandardTone;
+ break;
+ }
+ case ESatUserSelectedToneIncomingSpeech:
+ case ESatUserSelectedToneIncomingSms:
+ {
+ ret = PlayUserSelectedTone;
+ break;
+ }
+ default:
+ break;
+ }
+
+ qDebug("SATAPP: SatAppToneProvider::recognizeTone state=%d <", ret);
+ return ret;
+}
+
+//-----------------------------------------------------------------------------
+// SatAppToneProvider::charArrayToByteArray
+//-----------------------------------------------------------------------------
+QByteArray SatAppToneProvider::charArrayToByteArray(
+ const char tone[],
+ int size)
+{
+ qDebug("SATAPP: SatAppToneProvider::charArrayToByteArray >");
+ QByteArray seq;
+ seq = QByteArray::fromRawData(tone, size);
+ qDebug("SATAPP: SatAppToneProvider::charArrayToByteArray <");
+ return seq;
+}
+
+//-----------------------------------------------------------------------------
+// SatAppToneProvider::playStandardTone
+//-----------------------------------------------------------------------------
+void SatAppToneProvider::playStandardTone(
+ const QString& text,
+ const QByteArray& sequence,
+ int duration)
+{
+ qDebug("SATAPP: SatAppToneProvider::playStandardTone >");
+
+ if (text.length() > 0) {
+ mPermanentNote = new HbMessageBox(HbMessageBox::MessageTypeInformation);
+ SAT_ASSERT(connect(mPermanentNote, SIGNAL(aboutToClose()),
+ this, SLOT(stopPlayTone())));
+ mPermanentNote->setText(text);
+ mPermanentNote->setStandardButtons(HbMessageBox::Cancel);
+ if (duration > 0 ) {
+ mPermanentNote->setTimeout(duration);
+ }
+ mPermanentNote->setDismissPolicy(HbPopup::TapAnywhere);
+ qDebug("SatAppToneProvider::playStandardTone show before");
+ mPermanentNote->show();
+ qDebug("SatAppToneProvider::playStandardTone show after");
+ }
+
+ TPtrC8 seq((unsigned char*)sequence.constData(), sequence.length());
+ qDebug("SATAPP: SatAppToneProvider::playStandardTone TPtrC8 seq: %S", &seq);
+ QT_TRAP_THROWING(SymbianPrepareAudioToneUtilityL(seq));
+
+ if (duration > 0) {
+ mTimer = new QTimer(this);
+ SAT_ASSERT(connect(mTimer, SIGNAL(timeout()),
+ this, SLOT(stopPlayTone())));
+ mTimer->start(duration);
+ }
+
+ qDebug("SATAPP: SatAppToneProvider::playStandardTone <");
+}
+
+//-----------------------------------------------------------------------------
+// SatAppToneProvider::playUserSelectedTone
+//-----------------------------------------------------------------------------
+void SatAppToneProvider::playUserSelectedTone(
+ const QString& text,
+ int tone,
+ int duration)
+{
+ qDebug("SatAppToneProvider::playUserSelectedTone >");
+
+ // If several messages/calls arrive during a small amount of time and if the
+ // message received or incoming call tone is already being played we do not
+ // restart it.
+ if (mAudioPlayer) {
+ qDebug( "SatAppToneProvider::\
+ PlayUserSelectedToneL Error - already played" );
+ mCurrentAction->complete(ESatFailure);
+ mCurrentAction = 0;
+ mState = Idle;
+ return;
+ }
+
+ if (text.length() > 0) {
+ mPermanentNote = new HbMessageBox(HbMessageBox::MessageTypeInformation);
+ mPermanentNote->setText(text);
+ mPermanentNote->setStandardButtons(HbMessageBox::Cancel);
+ if (duration) {
+ mPermanentNote->setTimeout(duration);
+ }
+ mPermanentNote->setDismissPolicy(HbPopup::TapAnywhere);
+ qDebug("SatAppToneProvider::PlayUserSelectedToneL show before");
+ mPermanentNote->show();
+ qDebug("SatAppToneProvider::PlayUserSelectedToneL show after");
+ }
+
+ QT_TRAP_THROWING(SymbianPrepareAudioPlayerL(tone,duration));
+
+ if (duration > 0) {
+ qDebug( "SATAPP: SatAppToneProvider::PlayUserSelectedToneL\
+ duration not 0" );
+ mTimer = new QTimer(this);
+ mTimer->start(duration);
+ SAT_ASSERT(connect(mTimer, SIGNAL(timeout()), this, SLOT(stopPlayTone())));
+
+ if (mPermanentNote) {
+ SAT_ASSERT(connect(mPermanentNote, SIGNAL(aboutToClose()),
+ this, SLOT(stopPlayTone())));
+ }
+ }
+
+ qDebug( "SatAppToneProvider::PlayUserSelectedToneL <" );
+}
+
+
+// ----------------------------------------------------------------------------
+// SatAppToneProvider::clearScreen
+// terminates all ongoing UI actions
+// ----------------------------------------------------------------------------
+//
+void SatAppToneProvider::clearScreen()
+{
+ qDebug( "SatAppToneProvider::clearScreen >" );
+ if (mCurrentAction) {
+ stopPlayTone();
+ }
+ qDebug( "SatAppToneProvider::clearScreen <" );
+}
+
+// ----------------------------------------------------------------------------
+// SatAppToneProvider::stopPlayTone
+// Stops the music, frees blocked functions
+// ----------------------------------------------------------------------------
+//
+void SatAppToneProvider::stopPlayTone()
+{
+ qDebug("SATAPP: SatAppToneProvider::stopPlayTone >");
+
+ if (mPermanentNote) {
+ qDebug("SatAppToneProvider::stopPlayTone close mPermanentNote");
+ disconnect(mPermanentNote,SIGNAL(aboutToClose()),
+ this, SLOT(stopPlayTone()));
+ mPermanentNote->close();
+ }
+
+ if (mTimer) {
+ qDebug("SatAppToneProvider::stopPlayTone stop timer");
+ disconnect(mTimer,SIGNAL(timeout()), this, SLOT(stopPlayTone()));
+ if (mTimer->isActive()) {
+ mTimer->stop();
+ }
+ }
+
+ switch(mState) {
+ case PlayStandardTone: {
+ qDebug("SATAPP: SatAppToneProvider::stopPlayTone before play cancel");
+ SymbianStopAudioToneUtility();
+
+ //get warning and game tones setting from active profile
+ QT_TRAP_THROWING(GetProfileParamsL());
+ if( EFalse == mWarningAndPlayTones
+ && ESatSuccess == mPlayToneError ) {
+ mPlayToneError = ESatSuccessToneNotPlayed;
+ }
+ break;
+ }
+ case PlayUserSelectedTone: {
+ // Sample is played in forever loop for the duration.
+ // After duration call back timers are destroyed
+ // If player exists, stop playing and delete player. MapcPlayComplete
+ // is not called because CallBackTimer stops the playing.
+ SymbianStopAudioPlayer();
+ if( EFalse == mWarningAndPlayTones ) {
+ mPlayToneError = ESatSuccessToneNotPlayed;
+ }
+ break;
+ }
+ default:
+ break;
+ }
+
+ mState = Idle;
+ if (mCurrentAction) {
+ mCurrentAction->complete(mPlayToneError);
+ mCurrentAction = 0;
+ }
+
+ qDebug("SATAPP: SatAppToneProvider::stopPlayTone <");
+}
+
+void SatAppToneProvider::resetState()
+{
+ qDebug("SATAPP: SatAppToneProvider::resetState >");
+ if (mCurrentAction) {
+ mCurrentAction->completeWithNoResponse();
+ mCurrentAction = 0;
+ }
+
+ if (mPermanentNote) {
+ qDebug("SatAppToneProvider::resetState delete mPermanentNote");
+ delete mPermanentNote;
+ mPermanentNote = 0;
+ }
+
+ if (mTimer) {
+ qDebug("SatAppToneProvider::resetState delete timer");
+ delete mTimer;
+ mTimer = 0;
+ }
+ qDebug("SATAPP: SatAppToneProvider::resetState <");
+}
+
+
+
+// ****************************************************************************
+// * ************************************************************************ *
+// * * SYMBIAN PART * *
+// * ************************************************************************ *
+// ****************************************************************************
+
+
+// includes
+#include <e32std.h> //TTimeIntervalMicroSeconds
+#include <MProfile.h>
+#include <MProfileEngine.h>
+#include <MProfileTones.h>
+#include <TProfileToneSettings.h>
+#include <AudioPreference.h> //KAudioPriorityLowLevel
+#include <mdaaudiotoneplayer.h> // for CMdaAudioToneUtility&CMdaAudioPlayerUtility
+#include <mda/common/resource.h> //KMdaRepeatForever
+
+//constants
+
+// Maximum length for sound file.
+const TInt KMaxSoundFileLength = 256;
+// Used when dividing some values. Used only for preventing the use of magic
+// numbers
+// Audio sample is repeated indefinitely.
+const TInt KSoundPlayerRepeatForever = KMdaRepeatForever;
+
+// The max volume value from settings.
+// From TProfileToneSettings.h
+const TInt KMaxVolumeFromProfile( 10 );
+
+// ----------------------------------------------------------------------------
+// SatAppToneProvider::SymbianPrepareAudioToneUtilityL
+// creates and prepares CMdaAudioToneUtility
+// ----------------------------------------------------------------------------
+//
+void SatAppToneProvider::SymbianPrepareAudioToneUtilityL(const TDesC8& sequence)
+{
+ qDebug( "SatAppToneProvider::SymbianPrepareAudioToneUtilityL >" );
+ if (mPlayer) {
+ delete mPlayer;
+ mPlayer = 0;
+ }
+ mPlayer = CMdaAudioToneUtility::NewL(*this);
+ TInt volume(mPlayer->MaxVolume());
+ mPlayer->SetVolume(volume);
+ mPlayer->PrepareToPlayDesSequence(sequence);
+ qDebug( "SatAppToneProvider::SymbianPrepareAudioToneUtilityL <" );
+}
+
+// ----------------------------------------------------------------------------
+// SatAppToneProvider::SymbianStopAudioToneUtility
+// cancels and deletes CMdaAudioToneUtility
+// ----------------------------------------------------------------------------
+void SatAppToneProvider::SymbianStopAudioToneUtility()
+{
+ qDebug( "SatAppToneProvider::SymbianStopAudioToneUtility >" );
+ if (mPlayer) {
+ mPlayer->CancelPlay();
+ }
+ delete mPlayer;
+ mPlayer = NULL;
+ qDebug( "SatAppToneProvider::SymbianStopAudioToneUtility <" );
+}
+
+// ----------------------------------------------------------------------------
+// SatAppToneProvider::SymbianPrepareAudioPlayerL
+// cancels and deletes CMdaAudioToneUtility
+// ----------------------------------------------------------------------------
+void SatAppToneProvider::SymbianPrepareAudioPlayerL(
+ int tone, int duration)
+{
+ qDebug( "SatAppToneProvider::SymbianPrepareAudioPlayerL >" );
+ // This defines name for the current message alert or incoming call tone.
+ TBuf<KMaxSoundFileLength> soundFileName;
+ GetProfileParamsL(tone, &soundFileName);
+
+ // This defines the behaviour to be adopted by an
+ // audio client if a higher priority client takes over the device.
+ TInt mdaPriority( KAudioPrefIncomingCall );
+ // This is used to resolve conflicts when more than one client tries to
+ // access the same sound output device simultaneously.
+ TInt audioPriority( KAudioPriorityPhoneCall );
+
+ qDebug( "SATAPP: SatAppToneProvider::PlayUserSelectedToneL\
+ Volume is %d ", mVolume );
+
+ // Creates the audio player.
+ mAudioPlayer = CMdaAudioPlayerUtility::NewFilePlayerL(
+ soundFileName,
+ *this,
+ audioPriority,
+ ( TMdaPriorityPreference ) mdaPriority );
+
+ TTimeIntervalMicroSeconds no_silence(0);
+ if (duration > 0)
+ {
+ // repeat forever in a loop
+ mAudioPlayer->SetRepeats(KSoundPlayerRepeatForever, no_silence);
+ }
+ else
+ {
+ // play only once
+ mAudioPlayer->SetRepeats(0, no_silence);
+ }
+ qDebug( "SatAppToneProvider::SymbianPrepareAudioPlayerL <" );
+
+}
+
+// ----------------------------------------------------------------------------
+// SatAppToneProvider::SymbianStopAudioPlayer
+// cancels and deletes CMdaAudioToneUtility
+// ----------------------------------------------------------------------------
+void SatAppToneProvider::SymbianStopAudioPlayer()
+{
+ qDebug( "SatAppToneProvider::SymbianStopAudioPlayer >" );
+ if (mAudioPlayer) {
+ qDebug( "SatAppToneProvider::SymbianStopAudioPlayer AudioPlayer stop" );
+ mAudioPlayer->Stop();
+ }
+ delete mAudioPlayer;
+ mAudioPlayer = 0;
+ qDebug( "SatAppToneProvider::SymbianStopAudioPlayer <" );
+}
+
+// ---------------------------------------------------------
+// SatAppCommandHandler::GetProfileParamsL
+// Get and store settings from current profile
+// (other items were commented in a header).
+// ---------------------------------------------------------
+//
+void SatAppToneProvider::GetProfileParamsL(
+ int aTone /*= ESatToneNotSet*/,
+ TDes* aToneName /*= NULL*/ )
+{
+ qDebug( "SatAppCommandHandler::GetProfileParamsL >" );
+ MProfile* profile = NULL;
+ MProfileEngine* engine = NULL;
+ engine = CreateProfileEngineL();
+ CleanupReleasePushL( *engine );
+
+ profile = engine->ActiveProfileLC();
+
+ const MProfileTones& tones = profile->ProfileTones();
+
+ // Takes a current warning and gametones setting.
+ const TProfileToneSettings& ts = tones.ToneSettings();
+ mWarningAndPlayTones = ts.iWarningAndGameTones;
+ mVolume = ts.iRingingVolume;
+
+ qDebug( "SatAppCommandHandler::GetProfileParamsL \
+ mVolume before mapping %d", mVolume );
+
+ // Max volume from profile is KMaxVolumeFromProfile, Max volume from
+ // CMdaAudioToneUtility is different, maybe 10,000. So,
+ // rate = maxVolumeFromPlayer / KMaxVolumeFromProfile
+ // User may never hear the TONE, because volume is too small.
+ // iVolume times the rate make it can be heard.
+
+ CMdaAudioToneUtility* toneUtl = CMdaAudioToneUtility::NewL( *this );
+ TInt maxVolumeFromPlayer( toneUtl->MaxVolume() );
+ mVolume *= maxVolumeFromPlayer / KMaxVolumeFromProfile;
+ delete toneUtl;
+ toneUtl = NULL;
+ qDebug( "CSatUiViewAppUi::GetProfileParamsL \
+ mVolume after mapping %d", mVolume );
+
+ if ( ( ESatUserSelectedToneIncomingSms == aTone ) && ( aToneName ) )
+ {
+ qDebug("SatAppCommandHandler::GetProfileParamsL message tone");
+ aToneName->Copy( tones.MessageAlertTone() );
+ } else if( aToneName ) {
+ qDebug("SatAppCommandHandler::GetProfileParamsL ring tone");
+ aToneName->Copy( tones.RingingTone1() );
+ }
+
+ CleanupStack::PopAndDestroy(2); // engine, profile
+ qDebug("SatAppCommandHandler::GetProfileParamsL <");
+}
+
+// ---------------------------------------------------------
+// SatAppToneProvider::MatoPrepareComplete
+// Preparation is complete -> Starts playing tone
+// ---------------------------------------------------------
+//
+void SatAppToneProvider::MatoPrepareComplete(TInt aError)
+{
+ qDebug("SatAppToneProvider::MatoPrepareComplete \
+ aError = %d >", aError);
+ if (KErrNone == aError && mPlayer) {
+ mPlayToneError = ESatSuccess;
+ TTimeIntervalMicroSeconds zero(static_cast<TInt64>( 0 ));
+ mPlayer->SetPriority(KAudioPriorityLowLevel,
+ STATIC_CAST(TMdaPriorityPreference, KAudioPrefConfirmation));
+ mPlayer->SetRepeats( KMdaAudioToneRepeatForever, zero );
+ mPlayer->Play();
+ } else {
+ mPlayToneError = ESatFailure;
+ stopPlayTone();
+ }
+ qDebug( "SatAppToneProvider::MatoPrepareComplete <" );
+}
+
+//-----------------------------------------------------------------------------
+// SatAppToneProvider::MatoPlayComplete
+// Play complete -> Frees blocking function
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void SatAppToneProvider::MatoPlayComplete( TInt aError )
+{
+ qDebug("SatAppToneProvider::MatoPlayComplete >");
+ if (KErrNone == aError && mPlayer) {
+ qDebug("SatAppToneProvider::MatoPlayComplete play");
+ mPlayer->Play();
+ } else {
+ qDebug( "SatAppToneProvider::MatoPlayComplete stop playing");
+ // Stops playing if error.
+ stopPlayTone();
+ }
+ qDebug("SatAppToneProvider::MatoPlayComplete error %d <", aError);
+}
+
+//-----------------------------------------------------------------------------
+// SatAppToneProvider::MapcInitComplete
+// Initialisation complete -> starts playing the tone.
+// ----------------------------------------------------------------------------
+void SatAppToneProvider::MapcInitComplete( TInt aError,
+ const TTimeIntervalMicroSeconds& /*aDuration*/ )
+{
+ qDebug( "SatAppToneProvider::MapcInitComplete >" );
+ // Audio player is initialised, so if there is no error, we can start
+ // playing the tone.
+ if (KErrNone == aError && mAudioPlayer) {
+ const TInt volume( Max(0, Min(mVolume,
+ mAudioPlayer->MaxVolume())));
+ qDebug("CSatUiViewAppUi::\
+ MapcInitComplete SetVolume %d", volume );
+ // Set volume according Settings.
+ mAudioPlayer->SetVolume( volume );
+ mAudioPlayer->Play();
+ qDebug( "SatAppToneProvider::MapcInitComplete Play" );
+ } else {
+ // Otherwise, we delete the initialised audio player.
+ if ( mAudioPlayer ) {
+ qDebug( "SatAppToneProvider::MapcInitComplete mAudioPlayer \
+ true" );
+ delete mAudioPlayer;
+ mAudioPlayer = 0;
+ }
+
+ // Remove also the note for play tone
+ // If there was a duration for play tone, stop waiting
+ stopPlayTone();
+
+ qDebug( "SatAppToneProvider::MapcInitComplete Error %d", aError );
+ }
+ qDebug( "SatAppToneProvider::MapcInitComplete <" );
+}
+
+//-----------------------------------------------------------------------------
+// SatAppToneProvider::MapcPlayComplete
+// Deletes audio player after playing is completed.
+// ----------------------------------------------------------------------------
+void SatAppToneProvider::MapcPlayComplete( TInt /*aError*/ )
+{
+ qDebug( "SatAppToneProvider::MapcPlayComplete >" );
+
+ // When playing is completed, deleting the audio player.
+ if ( mAudioPlayer ) {
+ qDebug("SatAppToneProvider::MapcPlayComplete delete mAudioPlayer");
+ delete mAudioPlayer;
+ mAudioPlayer = 0;
+ }
+ // Remove note after play has completed.
+ stopPlayTone();
+ qDebug( "SatAppToneProvider::MapcPlayComplete <" );
+}
+
+
+//End of file