diff -r cad71a31b7fc -r e36f3802f733 srsf/ttsutility/src/ttsutilitybody.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/srsf/ttsutility/src/ttsutilitybody.cpp	Wed Sep 01 12:29:17 2010 +0100
@@ -0,0 +1,1181 @@
+/*
+* Copyright (c) 2004-2007 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:  Implementations for methods in CTtsUtilityBody
+*
+*/
+
+
+// INCLUDE FILES
+#include "ttsutilitybody.h"
+#include <mmf/server/mmffile.h>
+#include <mmf/server/mmfdes.h>
+#include <mmf/common/mmfcontrollerpluginresolver.h>
+#include <ecom/ecom.h>
+#include <AudioPreference.h>
+#include <utf.h>
+#include "rubydebug.h"
+
+// CONSTANTS
+
+// TTS media type equals to audio media type
+const TUid KUidMediaTypeTTS = { 0x101F5D07 };
+
+// Implementation UID of Tts Plugin
+const TUid KUidTtsPlugin = { 0x101FF934 };
+
+// Implementation UID of HQ-TTS Plugin
+const TUid KUidHqTtsPlugin = { 0x10201AF5 };
+
+// Header for TTS input
+_LIT8( KTtsDataHeader, "(tts)" );
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::CTtsUtilityBody
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CTtsUtilityBody::CTtsUtilityBody( MTtsClientUtilityObserver& aObserver ) : 
+                                  iAudioPlayDeviceCommands( iController ),
+                                  iAudioPlayControllerCommands( iController ),
+                                  iTtsCustomCommands( iController ),
+                                  iObserver( aObserver ),
+                                  iTime( 0 ),
+                                  iCurrentStyleID( 0 ),
+                                  iTrailingSilence( 0 ),
+                                  iOpenPlugin( KNullUid ),
+                                  iUidOfDataSink( KUidMmfAudioOutput )
+    {
+    // Nothing
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::ConstructL
+// Symbian 2nd phase constructor can leave.
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::ConstructL()
+    {
+    // Dummy priority settings
+    iPrioritySettings.iPriority = 0;
+    iPrioritySettings.iPref = ( TMdaPriorityPreference ) 0;
+    iPrioritySettings.iState = EMMFStateIdle; // idle
+    
+    // List plugins to make sure that at least one is found
+    RArray<TUid> temp;
+    ListPluginsL( temp );
+    temp.Close();
+
+    // Default audio priority
+    StorePriority( KAudioPriorityVoiceDial, 
+                   static_cast<TMdaPriorityPreference>( KAudioPrefVocosPlayback ) );
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::NewL
+// Two-phased constructor.
+// -----------------------------------------------------------------------------
+//
+CTtsUtilityBody* CTtsUtilityBody::NewL( MTtsClientUtilityObserver& aObserver )
+    {
+    CTtsUtilityBody* self = new( ELeave ) CTtsUtilityBody( aObserver );
+    
+    CleanupStack::PushL( self );
+
+    self->ConstructL();
+    CleanupStack::Pop();
+    
+    return self;
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::~CTtsUtilityBody
+// Destructor.
+// -----------------------------------------------------------------------------
+//
+CTtsUtilityBody::~CTtsUtilityBody()
+    {
+    // Cancel any pending requests
+    if ( iControllerEventMonitor != NULL )
+        {
+        iControllerEventMonitor->Cancel();
+        }
+
+    delete iControllerEventMonitor;
+    iController.Close();
+ 
+    iStyles.Close();
+    iInternalStyleIDs.Close();
+    iControllerStyleIDs.Close();
+    
+    delete iParsedText;
+    
+    REComSession::FinalClose();
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::HandleEvent
+// Handles events from plugin via MMF.
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::HandleEvent( const TMMFEvent& aEvent )
+    {
+    TInt result = (TInt)aEvent.iErrorCode;
+
+#ifdef _DEBUG
+    TInt event = (TInt)aEvent.iEventType.iUid;
+    RUBY_DEBUG2( "CTtsUtilityBody::HandleEvent() - Event Type = %d, Event Result = %d", 
+                 event, result );
+#endif
+    
+    if ( aEvent.iEventType == KMMFEventCategoryPlaybackComplete )
+        {
+        if ( result == KErrNone )
+            {
+            iRepeats--;
+            
+            if ( iRepeats > 0 )
+                {
+                // @todo Not too good way to handle waiting, we're blocking
+                // the client thread here... Should be done in plugin side..
+                User::After( iTrailingSilence );
+                Play();
+                // Don't make the callback at this point
+                return;
+                }
+            }
+        else
+            {
+            iRepeats = 0;
+            }
+        
+        iUidOfDataSink = KUidMmfAudioOutput;
+
+        // Remove data sink - otherwise file handle stays open. 
+        // Return value ignored because there is nothing we can do. 
+        iController.RemoveDataSink( iSinkHandle );
+
+        iObserver.MapcPlayComplete( result );
+        
+        }
+    else if ( aEvent.iEventType == KMMFEventCategoryAudioLoadingComplete )
+        {
+        if ( result != KErrNone )
+            {
+            iUidOfDataSink = KUidMmfAudioOutput; 
+            iController.RemoveDataSink( iSinkHandle );
+            }
+            
+        iTime = Duration();
+        iObserver.MapcInitComplete( result, iTime );
+        if ( iPlayImmediately )
+            {
+            iPlayImmediately = EFalse;
+            if ( result == KErrNone )
+                {
+                Play();
+                }
+            }
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::AddStyleL
+// Adds style to collection, calls TTS custom commands.
+// -----------------------------------------------------------------------------
+//
+TTtsStyleID CTtsUtilityBody::AddStyleL( const TTtsStyle& aStyle )
+    {
+    TTtsStyleID controllerID( 0 );
+    
+    if ( IsPluginOpen() )
+        {
+        User::LeaveIfError( iTtsCustomCommands.AddStyle( aStyle, controllerID ) );
+        }
+
+    // Add style also to our own array
+    iStyles.Append( aStyle );
+    TTtsStyleID internalID( iCurrentStyleID ); 
+    iInternalStyleIDs.Append( internalID );
+
+    // This is zero if no open controller connection, will be updated later
+    iControllerStyleIDs.Append( controllerID ); 
+    iCurrentStyleID++;
+
+    return internalID;
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::DeleteStyle
+// Deletes style from collection, calls TTS custom commands.
+// -----------------------------------------------------------------------------
+//
+TInt CTtsUtilityBody::DeleteStyle( TTtsStyleID aID )
+    {
+    TTtsStyleID controllerStyleId( 0 );
+
+    // Delete from local storage
+    for ( TInt i = 0; i < iInternalStyleIDs.Count(); i++ )
+        {
+        if ( iInternalStyleIDs[i] == aID )
+            {
+            iInternalStyleIDs.Remove( i );
+            iStyles.Remove( i );
+            // Take note of the controller side style id before removing it
+            controllerStyleId = iControllerStyleIDs[i];
+            iControllerStyleIDs.Remove( i );
+            break;
+            }
+        }
+
+    // Reset style id counter if no styles registered anymore
+    if ( iInternalStyleIDs.Count() == 0 )
+        {
+        iCurrentStyleID = 0;
+        }
+
+    if ( IsPluginOpen() )
+        {
+        // Delete style from controller plugin
+        TInt error = iTtsCustomCommands.DeleteStyle( controllerStyleId );
+        if ( error != KErrNone )
+            {
+            return error;
+            }
+        }
+
+    return KErrNone;
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::NumberOfStyles
+// Returns number of registered styles.
+// -----------------------------------------------------------------------------
+//
+TUint16 CTtsUtilityBody::NumberOfStyles()
+    {
+    return ( TUint16 ) iStyles.Count();
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::StyleL
+// Returns reference to registered style based on style ID.
+// -----------------------------------------------------------------------------
+//
+TTtsStyle& CTtsUtilityBody::StyleL( TTtsStyleID aStyleID )
+    {
+    TInt i( 0 );
+    TInt count( iInternalStyleIDs.Count() );
+    
+    while ( i < count && iInternalStyleIDs[i] != aStyleID )
+        {
+        i++;
+        }
+    
+    if ( i == count )
+        {
+        User::Leave( KErrNotFound );
+        }
+
+    return iStyles[i];
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::StyleL
+// Returns reference to registered style based on style index.
+// -----------------------------------------------------------------------------
+//
+TTtsStyle& CTtsUtilityBody::StyleL( TUint16 aIndex )
+    {
+    if ( aIndex >= iStyles.Count() )
+        {
+        User::Leave( KErrNotFound );
+        }
+
+    return iStyles[aIndex];
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::Play
+// Starts playback.
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::Play()
+    {
+    iController.Play();
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::Stop
+// Stops playback.
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::Stop()
+    {
+    iRepeats = 0;
+    iController.Stop();
+    iUidOfDataSink = KUidMmfAudioOutput;
+    iController.RemoveDataSink( iSinkHandle );
+    iPlayImmediately = EFalse;
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::SetVolume
+// Sets playback volume.
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::SetVolume( TInt aVolume )
+    {
+    iAudioPlayDeviceCommands.SetVolume( aVolume );
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::SetRepeats
+// Sets number of repeats.
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::SetRepeats( TInt aRepeatNumberOfTimes, 
+                                  const TTimeIntervalMicroSeconds& aTrailingSilence )
+    {
+    iTrailingSilence = TTimeIntervalMicroSeconds32( I64LOW( aTrailingSilence.Int64() ) );
+    iRepeats = aRepeatNumberOfTimes;
+    }
+        
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::Duration
+// Returns duration of TTS 'clip'.
+// -----------------------------------------------------------------------------
+//
+const TTimeIntervalMicroSeconds& CTtsUtilityBody::Duration()
+    {
+    iDuration = 0; 
+    iController.GetDuration( iDuration ); // Ignoring return value 
+    
+    return iDuration; 
+    } 
+    
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::MaxVolume
+// Returns maximum volume.
+// -----------------------------------------------------------------------------
+//
+TInt CTtsUtilityBody::MaxVolume()
+    {
+    TInt volume = 0;
+    if ( iAudioPlayDeviceCommands.GetMaxVolume( volume ) != KErrNone )
+        {
+        return 0;
+        }
+    return volume;
+    } 
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::OpenAndPlayDesL
+// Opens descriptor source and plays it immediately.
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::OpenAndPlayDesL( const TDesC8& aDescriptor )
+    {
+    iPlayImmediately = ETrue;
+    
+    TRAPD( error, OpenDesL( aDescriptor ) );
+    if ( error != KErrNone )
+        {
+        iPlayImmediately = EFalse;
+        User::Leave( error );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::OpenAndPlayFileL
+// Opens file source and plays it immediately.
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::OpenAndPlayFileL( const TDesC& aFileName )
+    {
+    iPlayImmediately = ETrue;
+    
+    TRAPD( error, OpenFileL( aFileName ) );
+    if ( error != KErrNone )
+        {
+        iPlayImmediately = EFalse;
+        User::Leave( error );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::OpenAndPlayParsedTextL
+// Opens parsed text source and plays it immediately.
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::OpenAndPlayParsedTextL( CTtsParsedText& aText )
+    {
+    iPlayImmediately = ETrue;
+    
+    TRAPD( error, OpenParsedTextL( aText ) );
+    if ( error != KErrNone )
+        {
+        iPlayImmediately = EFalse;
+        User::Leave( error );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::OpenDesL
+// Opens descriptor source 
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::OpenDesL( const TDesC8& aDescriptor )
+    {
+    if ( !iPluginOpenedExplicitly )
+        {
+        CheckAndLoadCorrectPluginL( iDefaultStyle.iQuality, 
+                                    iDefaultStyle.iLanguage, 
+                                    iDefaultStyle.iVoice );
+        }
+
+    // Add data descriptor source
+    TMMFDescriptorConfig sourceCfg;
+    sourceCfg().iDes = (TAny*)&aDescriptor;
+    sourceCfg().iDesThreadId = RThread().Id();
+    User::LeaveIfError( iController.AddDataSource( KUidMmfDescriptorSource, 
+                                                   sourceCfg, iSourceHandle ) );
+
+    // Add data sink to file or audio output
+    AddDataSinkL();
+
+    // Prime controller
+    User::LeaveIfError( iController.Prime() );
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::OpenFileL
+// Opens file source
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::OpenFileL( const TDesC& aFileName )
+    {
+    if ( !iPluginOpenedExplicitly )
+        {
+        CheckAndLoadCorrectPluginL( iDefaultStyle.iQuality, 
+                                    iDefaultStyle.iLanguage, 
+                                    iDefaultStyle.iVoice );
+        }
+
+    // Add data file source
+    TMMFFileConfig sourceCfg;
+    sourceCfg().iPath = aFileName;
+    User::LeaveIfError( iController.AddDataSource( KUidMmfFileSource, sourceCfg, 
+                                                   iSourceHandle ) );
+    // Add data sink to file or audio output
+    AddDataSinkL();
+        
+    // Prime controller
+    User::LeaveIfError( iController.Prime() );
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::OpenParsedTextL
+// Opens parsed text source with the help of TTS custom commands.
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::OpenParsedTextL( CTtsParsedText& aText )
+    {
+    if ( !iPluginOpenedExplicitly )
+        {
+        if ( aText.NumberOfSegments() > 0 )
+            {
+            // Take the first segment
+            const TTtsSegment& segment = aText.SegmentL( 0 );
+        
+            TTtsStyleID styleID = segment.StyleID();
+        
+            // Style should have been registered already
+            TTtsStyle& style = StyleL( styleID );
+        
+            CheckAndLoadCorrectPluginL( style.iQuality, style.iLanguage, 
+                                        style.iVoice );
+            }
+         else
+            {
+            User::Leave( KErrArgument );
+            }
+        }
+
+    // Data source is now parsed text
+    CopyParsedTextL( aText );
+    User::LeaveIfError( iTtsCustomCommands.OpenParsedText( *iParsedText ) );
+
+    // Add data sink to file or audio output
+    AddDataSinkL();
+
+    User::LeaveIfError( iController.Prime() );
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::Pause
+// Pauses playback.
+// -----------------------------------------------------------------------------
+//
+TInt CTtsUtilityBody::Pause()
+    {
+    return iController.Pause();
+    }   
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::OpenPluginL
+// Opens connection to plugin
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::OpenPluginL( TUid aUid )
+    {
+    OpenControllerConnectionL( aUid );
+    
+    iPluginOpenedExplicitly = ETrue;
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::ListPluginsL
+// Lists available plugins
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::ListPluginsL( RArray<TUid>& aUids )
+    {
+    // Empty the list
+    aUids.Reset();
+    
+    RMMFControllerImplInfoArray controllers;
+    CleanupResetAndDestroyPushL( controllers );
+    
+    CMMFControllerPluginSelectionParameters* selectionParams = CMMFControllerPluginSelectionParameters::NewLC();
+    
+    // Select the media IDs to allow
+    RArray<TUid> mediaIds;
+    CleanupClosePushL( mediaIds );
+    User::LeaveIfError( mediaIds.Append( KUidMediaTypeTTS ) );
+
+    selectionParams->SetMediaIdsL( mediaIds, CMMFPluginSelectionParameters::EAllowOnlySuppliedMediaIds );
+    CleanupStack::PopAndDestroy( &mediaIds );
+    
+    // Check also the allowed data headers
+    // Should be "(tts)"
+    CMMFFormatSelectionParameters* formatSelectParams = CMMFFormatSelectionParameters::NewLC();
+    formatSelectParams->SetMatchToHeaderDataL( KTtsDataHeader );
+    
+    selectionParams->SetRequiredPlayFormatSupportL( *formatSelectParams );
+    
+    CleanupStack::PopAndDestroy( formatSelectParams );
+    
+    // Do the list of implementation
+    selectionParams->ListImplementationsL( controllers );    
+    
+    // Make sure at least one controller has been found
+    if( controllers.Count() == 0 )
+        {
+        RUBY_DEBUG1( "No controllers found using media type %x", KUidMediaTypeTTS );
+        User::Leave( KErrNotFound );
+        }
+
+    for ( TInt c = 0; c < controllers.Count(); c++ )
+        {
+        RUBY_DEBUG1( "UID = %x", controllers[c]->Uid() );
+        aUids.Append( controllers[c]->Uid() );
+        }
+
+    CleanupStack::PopAndDestroy( selectionParams );
+    CleanupStack::PopAndDestroy( &controllers ); 
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::SetDefaultStyleL
+// Sets deafault style 
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::SetDefaultStyleL( const TTtsStyle& aStyle )
+    {
+    User::LeaveIfError( iTtsCustomCommands.SetDefaultStyle( aStyle ) );
+    iDefaultStyle = aStyle;
+    }
+        
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::DefaultStyleL
+// Returns default style
+// -----------------------------------------------------------------------------
+//
+TTtsStyle& CTtsUtilityBody::DefaultStyleL()
+    {   
+    User::LeaveIfError( iTtsCustomCommands.GetDefaultStyle( iDefaultStyle ) );
+    return iDefaultStyle;
+    }
+        
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::SetSpeakingRateL
+// Sets speaking rate
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::SetSpeakingRateL( TInt aRate )
+    {
+    User::LeaveIfError( iTtsCustomCommands.SetSpeakingRate( aRate ) );
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::SpeakingRateL
+// Returns speaking rate
+// -----------------------------------------------------------------------------
+//
+TInt CTtsUtilityBody::SpeakingRateL()
+    {
+    TInt rate( KErrGeneral );
+    User::LeaveIfError( iTtsCustomCommands.GetSpeakingRate( rate ) );
+    return rate;
+    }
+    
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::GetSupportedLanguagesL
+// Returns list of supported languages
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::GetSupportedLanguagesL( RArray<TLanguage>& aLanguages )
+    {
+    User::LeaveIfError( iTtsCustomCommands.GetSupportedLanguages( aLanguages ) );
+    }
+        
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::GetSupportedVoicesL
+// Returns list of supported voices
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::GetSupportedVoicesL( TLanguage aLanguage, 
+                                           RArray<TTtsStyle>& aVoices )
+    {
+    User::LeaveIfError( iTtsCustomCommands.GetSupportedVoices( aLanguage, aVoices ) );
+    }
+    
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::OpenDesL
+// Opens unicode descriptor
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::OpenDesL( const TDesC& aDescriptor )
+    {
+    HBufC8* utf8string = ConvertToUtf8LC( aDescriptor );
+    OpenDesL( utf8string->Des() );
+    CleanupStack::PopAndDestroy( utf8string );
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::GetSupportedVoicesL
+// Opens and plays unicode descriptor
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::OpenAndPlayDesL( const TDesC& aDescriptor )
+    {
+    HBufC8* utf8string = ConvertToUtf8LC( aDescriptor );
+    OpenAndPlayDesL( utf8string->Des() );
+    CleanupStack::PopAndDestroy( utf8string );        
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::SetOutputFileL
+// Sets output to be written to the file handle 
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::SetOutputFileL( const RFile& aFile )
+    {
+    iUidOfDataSink = KUidMmfFileSink; 
+
+    // iFile has to contain valid file handle when data sink 
+    // is marked to be file sink. 
+    iFile = aFile; 
+    }
+    
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::Close
+// Closes current TTS synthesis source.
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::Close()
+    {
+    iRepeats = 0;
+    if ( iControllerEventMonitor != NULL )
+        {
+        iControllerEventMonitor->Cancel();
+        }
+    delete iControllerEventMonitor;
+    iControllerEventMonitor = NULL;
+    iController.Close();
+    iPluginOpenedExplicitly = EFalse;
+    iOpenPlugin = KNullUid;
+    iUidOfDataSink = KUidMmfAudioOutput;
+    }        
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::GetPosition
+// Returns position of synthesis in microseconds.
+// -----------------------------------------------------------------------------
+//
+TInt CTtsUtilityBody::GetPosition( TTimeIntervalMicroSeconds& aPosition )
+    {
+    return iController.GetPosition( aPosition );
+    }
+       
+ 
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::GetPosition
+// Returns position of synthesis in words.
+// -----------------------------------------------------------------------------
+//
+TInt CTtsUtilityBody::GetPosition( TInt& aWordIndex )
+    {
+    return iTtsCustomCommands.GetPosition( aWordIndex );
+    }
+
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::SetPosition
+// Sets synthesis position in microseconds.
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::SetPosition( const TTimeIntervalMicroSeconds& aPosition )
+    {
+    iController.SetPosition( aPosition );
+    }
+
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::SetPosition
+// Sets synthesis position in words.
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::SetPosition( TInt aWordIndex )
+    {
+    iTtsCustomCommands.SetPosition( aWordIndex );
+    }
+
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::SetPriority
+// Sets playback priority.
+// -----------------------------------------------------------------------------
+//
+TInt CTtsUtilityBody::SetPriority( TInt aPriority, TMdaPriorityPreference aPref )
+    {
+    StorePriority( aPriority, aPref );
+
+    if ( IsPluginOpen() )
+        {
+        return iController.SetPrioritySettings( iPrioritySettings );
+        }
+    else
+        {
+        return KErrNone;
+        }
+    }
+    
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::GetVolume
+// Returns volume value.
+// -----------------------------------------------------------------------------
+//
+TInt CTtsUtilityBody::GetVolume( TInt& aVolume )
+    {
+    return iAudioPlayDeviceCommands.GetVolume( aVolume );
+    }
+        
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::SetBalance
+// Sets balance.
+// -----------------------------------------------------------------------------
+//
+TInt CTtsUtilityBody::SetBalance( TInt aBalance )
+    {
+    return iAudioPlayDeviceCommands.SetBalance( aBalance );
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::GetBalance
+// Returns current balance setting.
+// -----------------------------------------------------------------------------
+//
+TInt CTtsUtilityBody::GetBalance( TInt& aBalance )
+    {
+    return iAudioPlayDeviceCommands.GetBalance( aBalance );
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::CustomCommandSync
+// Sends synchronous custom command via MMF.
+// -----------------------------------------------------------------------------
+//
+TInt CTtsUtilityBody::CustomCommandSync( const TMMFMessageDestinationPckg& aDestination, 
+                                         TInt aFunction, 
+                                         const TDesC8& aDataTo1, 
+                                         const TDesC8& aDataTo2, 
+                                         TDes8& aDataFrom )
+    {
+    return iController.CustomCommandSync( aDestination, aFunction, aDataTo1, aDataTo2, aDataFrom );
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::CustomCommandSync
+// Sends synchronous custom command via MMF.
+// -----------------------------------------------------------------------------
+//
+TInt CTtsUtilityBody::CustomCommandSync( const TMMFMessageDestinationPckg& aDestination, 
+                                         TInt aFunction, 
+                                         const TDesC8& aDataTo1, 
+                                         const TDesC8& aDataTo2 )
+    {
+    return iController.CustomCommandSync( aDestination, aFunction, aDataTo1, aDataTo2 );
+    }
+
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::CustomCommandAsync
+// Sends asynchronous custom command via MMF.
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::CustomCommandAsync( const TMMFMessageDestinationPckg& aDestination,  
+                                          TInt aFunction, 
+                                          const TDesC8& aDataTo1, 
+                                          const TDesC8& aDataTo2, 
+                                          TDes8& aDataFrom,
+                                          TRequestStatus& aStatus )
+    {
+    iController.CustomCommandAsync( aDestination, aFunction, aDataTo1, aDataTo2, aDataFrom, aStatus );
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::CustomCommandAsync
+// Sends asynchronous custom command via MMF.
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::CustomCommandAsync( const TMMFMessageDestinationPckg& aDestination, 
+                                          TInt aFunction, 
+                                          const TDesC8& aDataTo1, 
+                                          const TDesC8& aDataTo2, 
+                                          TRequestStatus& aStatus )
+    {
+    iController.CustomCommandAsync( aDestination, aFunction, aDataTo1, aDataTo2, aStatus );
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::IsPluginOpen
+// Returns ETrue if connection is established with controller plugin
+// -----------------------------------------------------------------------------
+//
+TBool CTtsUtilityBody::IsPluginOpen()
+    {
+    if ( iOpenPlugin == KNullUid )
+        {
+        return EFalse;
+        }
+    else
+        {
+        return ETrue;
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::OpenControllerConnectionL
+// Opens controller connection if it has been closed
+// Changes plugin if the one requested is not loaded currently
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::OpenControllerConnectionL( TUid aPluginUid )
+    {
+    RUBY_DEBUG_BLOCK( "CTtsUtilityBody::OpenControllerConnectionL(aPluginUid)" );
+    
+    if ( iOpenPlugin != aPluginUid )
+        {
+        // Clear previously loaded plugin if needed
+        if ( IsPluginOpen() )
+            {
+            Close();
+            }
+
+        TInt error = iController.Open( aPluginUid, iPrioritySettings );
+        if ( error ) 
+            {
+            RUBY_DEBUG2( "Unable to load controller plugin, error = %d, UID = %x", 
+                         error, aPluginUid );            
+            User::Leave( error );
+            }
+        else
+            {
+            if ( iControllerEventMonitor == NULL )
+                {
+                // Start the event monitor
+                iControllerEventMonitor = CMMFControllerEventMonitor::NewL( *this, iController );
+                iControllerEventMonitor->Start();
+                }
+            }
+      
+        iOpenPlugin = aPluginUid;
+
+        // Add already registered styles to controller plugin too         
+        for ( TInt i( 0 ); i < iStyles.Count(); i++ )
+            {
+            TTtsStyleID controllerStyleId( 0 );
+            User::LeaveIfError( iTtsCustomCommands.AddStyle( iStyles[i], controllerStyleId ) );
+            iControllerStyleIDs[i] = controllerStyleId;
+            } 
+        
+        // Set priority settings
+        User::LeaveIfError( SetPriority( iPrioritySettings.iPriority, 
+                                         (TMdaPriorityPreference) iPrioritySettings.iPref ) );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::CopyParsedTextL
+// Copies parsed text structure and substitutes style ids to corresponding plugin
+// ids.
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::CopyParsedTextL( CTtsParsedText& aText )
+    {
+    RUBY_DEBUG_BLOCK( "CTtsUtilityBody::CopyParsedTextL" );
+
+    // Delete previous object if exists
+    delete iParsedText;
+    iParsedText = NULL;
+
+    // New instance
+    iParsedText = CTtsParsedText::NewL( aText.Text(), aText.PhonemeSequence(),
+                                        aText.PhonemeNotation() );
+
+    // Segments
+
+    // Indexes for starting points for segment's text and phoneme part in
+    // CTtsParsedText object's text and phoneme sequence    
+    TInt textIndex( 0 );
+    TInt phonemeIndex( 0 );
+
+    for ( TInt i = 0; i < aText.NumberOfSegments(); i++ )
+        {
+        TTtsSegment segment = aText.SegmentL( i );
+        
+        TInt styleIndex = iInternalStyleIDs.Find( aText.SegmentL( i ).StyleID() );
+        User::LeaveIfError( styleIndex );
+        segment.SetStyleID( iControllerStyleIDs[styleIndex] );
+        
+        TInt segTextLength = aText.SegmentL( i ).TextPtr().Length();
+        TInt segPhonemeSeqLength = aText.SegmentL( i )
+                                      .PhonemeSequencePtr().Length();
+        
+        // Text
+        if ( textIndex + segTextLength
+             <= iParsedText->Text().Length() )
+            {
+            segment.SetTextPtr( iParsedText->Text()
+                                .Mid( textIndex, segTextLength ) );
+            
+            textIndex += segTextLength;
+            }
+        // Segments are somehow constructed illegally. Copy the whole text.
+        else
+            {
+            segment.SetTextPtr( iParsedText->Text() );
+            }
+        
+        // Phoneme sequence
+        if ( phonemeIndex + segPhonemeSeqLength
+             <= iParsedText->PhonemeSequence().Length() )
+            {
+            segment.SetPhonemeSequencePtr(
+                iParsedText->PhonemeSequence().Mid( phonemeIndex, segPhonemeSeqLength ) );
+            
+            phonemeIndex += segPhonemeSeqLength;
+            }
+        else
+            {
+            segment.SetPhonemeSequencePtr(
+                iParsedText->PhonemeSequence() );
+            }
+
+        // Add segment to the new instance of CTtsParsedText
+        iParsedText->AddSegmentL( segment );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::StorePriority
+// Stores priority values locally to be sent to the plugin when connection is
+// opened.
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::StorePriority( TInt aPriority, TMdaPriorityPreference aPref )
+    {
+    iPrioritySettings.iPriority = aPriority;
+    iPrioritySettings.iPref = aPref;
+    iPrioritySettings.iState = EMMFStateIdle;
+    }    
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::ConvertToUtf8LC
+// Converts unicode descriptor to utf-8
+// -----------------------------------------------------------------------------
+//
+HBufC8* CTtsUtilityBody::ConvertToUtf8LC( const TDesC& aDes )
+    {
+    HBufC8* utf8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L( aDes );
+    CleanupStack::PushL( utf8 );
+    return utf8;
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::AddDataSinkL
+// Adds data sink (file and audio supported)
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::AddDataSinkL()
+    {
+    RUBY_DEBUG_BLOCKL( "CTtsUtilityBody::AddDataSinkL" );
+    
+    if ( iUidOfDataSink == KUidMmfAudioOutput )
+        {
+        User::LeaveIfError( iController.AddDataSink( KUidMmfAudioOutput, 
+                                                     KNullDesC8, iSinkHandle ) ); 
+        }
+    else if ( iUidOfDataSink == KUidMmfFileSink )
+        {
+        TMMFFileHandleConfig destCfg( &iFile );
+
+        TInt error = iController.AddDataSink( KUidMmfFileSink,destCfg, iSinkHandle ); 
+        if ( error )
+            {
+            iUidOfDataSink = KUidMmfAudioOutput; 
+            User::Leave( error ); 
+            }
+        }
+    else
+        {
+        User::Leave( KErrNotSupported );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::CheckAndLoadCorrectPluginL
+// 
+// -----------------------------------------------------------------------------
+//
+void CTtsUtilityBody::CheckAndLoadCorrectPluginL( TTtsQuality aQuality, 
+                                                  TLanguage aLanguage, 
+                                                  const TTtsVoice& aVoice )
+    {
+    RUBY_DEBUG_BLOCKL( "CTtsUtilityBody::CheckAndLoadCorrectPluginL" );
+    
+    TInt error( KErrNone );
+    
+    switch ( aQuality )
+        {
+        case ETtsQualityHighOnly:
+
+            OpenControllerConnectionL( KUidHqTtsPlugin );
+            
+            break;
+            
+        case ETtsQualityLowOnly:
+        case ETtsQualityUndefined:
+        
+            OpenControllerConnectionL( KUidTtsPlugin );
+                
+            break;
+            
+        case ETtsQualityHighPreferred:
+
+            TRAP( error, OpenControllerConnectionL( KUidHqTtsPlugin ) );
+            if ( error || !IsSupportedSpeaker( aLanguage, aVoice ) )
+                {
+                // Try to use Klatt if Hqtts not found or specific language/speaker 
+                // not available
+                OpenControllerConnectionL( KUidTtsPlugin );
+                }
+                
+            break;
+            
+        case ETtsQualityLowPreferred:
+
+            TRAP( error, OpenControllerConnectionL( KUidTtsPlugin ) );
+            if ( error || !IsSupportedSpeaker( aLanguage, aVoice ) )
+                {
+                // Try to use Hqtts if Klatt not found or specific language/speaker 
+                // not available
+                OpenControllerConnectionL( KUidHqTtsPlugin );
+                }
+        
+            break;
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CTtsUtilityBody::IsSupportedSpeaker
+// 
+// -----------------------------------------------------------------------------
+//
+TBool CTtsUtilityBody::IsSupportedSpeaker( TLanguage aLanguage, 
+                                           const TTtsVoice& aVoice )
+    {
+    TBool answer( EFalse );
+    
+    if ( aLanguage == KTtsUndefinedLanguage )
+        {
+        // Undefined language -> plugin can use default language and voice.
+        answer = ETrue;
+        }
+    else
+        {
+        RArray<TLanguage> languages;
+        iTtsCustomCommands.GetSupportedLanguages( languages );
+
+        if ( languages.Find( aLanguage ) != KErrNotFound )
+            {
+            if ( aVoice == KNullDesC )
+                {
+                // Language found and undefined voice
+                answer = ETrue;
+                }
+            else
+                {
+                RArray<TTtsStyle> voices;
+                iTtsCustomCommands.GetSupportedVoices( aLanguage, voices );
+                
+                TInt counter( 0 );
+
+                while ( answer == EFalse && counter < voices.Count() )
+                    {
+                    if ( voices[counter].iVoice == aVoice )
+                        {
+                        // Both language and voice are supported 
+                        // by currently loaded plugin.
+                        answer = ETrue;
+                        }
+                        
+                    counter++;
+                    }
+                        
+                voices.Close();
+                }
+            }
+            
+        languages.Close();
+        }
+        
+    return answer;
+    }
+    
+// End of File