/*

* 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() );

    }

// -----------------------------------------------------------------------------