/*

* 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 CTtsControllerPluginBody methods.

*

*/

// INCLUDE FILES

#include <AudioPreference.h>

#include <e32base.h>

#include <mmfdes.h>

#include <mmffile.h>

#include <reent.h>

#include <sysutil.h>

#include <utf.h>

#include "ttsplugin.h"

#include "ttspluginbody.h"

#include "ttsplugindataloader.h"

#include "ttspluginresourcehandler.h"

#include "rubydebug.h"

#include "srsfbldvariant.hrh"

// CONSTANTS

// Playback state

const TInt KPlay = 1; 

// Package types for general & language specific TTP data

// const TUint32 KTtpGeneralDataPackageType = 1;

const TUint32 KTtpLanguageDataPackageType = 0;

const TUint32 KTtsDataPackageType = 2;

// Header used to direct input to us from CMdaAudioPlayerUtility

_LIT8( KTtsContentHeader, "(tts)" );

// TTS language can be set by adding "(l:lang_id)" to the beginning of descriptor

// or file input. 

_LIT8( KTtsLanguageStartTag, "(l:" );

_LIT8( KTtsLanguageEndTag, ")" );

_LIT( KTextFileExtension, ".txt" );

const TInt KSamplingRate = 16000; // Hz

// ============================ MEMBER FUNCTIONS ===============================

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

// CTtsControllerPluginBody::CTtsControllerPluginBody

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CTtsControllerPluginBody::CTtsControllerPluginBody( CTtsControllerPlugin* aObserver ) : 

    CActive( CActive::EPriorityStandard ),

    iObserver( aObserver ),

    iTtsOutputMode( EDevTTSSoundDeviceMode ) 

    {

    // Nothing

    }

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

// CTtsControllerPluginBody::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CTtsControllerPluginBody::ConstructL()

    {

    RUBY_DEBUG1( "CTtsControllerPluginBody::ConstructL [%x]", this );

    User::LeaveIfError( iFs.Connect() );

    // Loads resource file

    CTtsPluginResourceHandler* resourceHandler = 

        CTtsPluginResourceHandler::NewL( iFs );

    TFileName generalTTPFileName( *resourceHandler->iTtpGeneralFilename );

    TFileName languageTTPFileName( *resourceHandler->iTtpLanguangeFilename );

    TFileName postfixOfTTPFileName( *resourceHandler->iTtpFilenamePostfix );

    TFileName TTSFileName( *resourceHandler->iTtsFilename );

    TFileName postfixOfTTSFileName( *resourceHandler->iTtsFilenamePostfix );

    delete resourceHandler; 

    resourceHandler = NULL;

    // TTP Data loader

    iTtsLoader = CTTSDataLoader::NewL( iFs,

                                       generalTTPFileName, 

                                       languageTTPFileName, 

                                       postfixOfTTPFileName,

                                       TTSFileName,

                                       postfixOfTTSFileName );

    // DevTTS

    iDevTts = CDevTTS::NewL( *this );

    // Add default style to DevTTS

    iDefaultStyleID = iDevTts->AddStyleL( iDefaultStyle );

    // Add ourselves to active scheduler

    CActiveScheduler::Add( this );

    }

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

// CTtsControllerPluginBody::NewL

// Two-phased constructor.

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

//

CTtsControllerPluginBody* CTtsControllerPluginBody::NewL( CTtsControllerPlugin* aObserver )

    {

    CTtsControllerPluginBody* self = new( ELeave ) CTtsControllerPluginBody( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CTtsControllerPluginBody::~CTtsControllerPluginBody

// Destructor.

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

//

CTtsControllerPluginBody::~CTtsControllerPluginBody()

    {

    delete iParsedTextPointer;

    delete iDevTts;

    delete iTtsLoader;

    iFs.Close();

    CloseSTDLIB();

    }

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

// CTtsControllerPluginBody::AddDataSourceL

// Adds data suorce.

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

//

void CTtsControllerPluginBody::AddDataSourceL( MDataSource& aDataSource )

    {

    RUBY_DEBUG_BLOCK( "CTtsControllerPluginBody::AddDataSourceL" );

    iEarlyPrimingDone = EFalse;

    // Check the source type

    if ( aDataSource.DataSourceType() == KUidMmfDescriptorSource )

        {

        CMMFDescriptor* des = STATIC_CAST( CMMFDescriptor*, &aDataSource );

        RUBY_DEBUG1( "Descriptor source detected, size: %x bytes", des->Size() );

        // Copy data to CMMFDescriptorBuffer

        CMMFDescriptorBuffer* desBuf = CMMFDescriptorBuffer::NewL( des->Size() );

        CleanupStack::PushL( desBuf );

        des->ReadBufferL( desBuf, 0 );

        // To 'normal' descriptor

        TDes8& descriptor = desBuf->Data();

        RUBY_DEBUG1( "Created descriptor, size: %x", descriptor.Size() );

        ConstructParsedTextL( descriptor );

        CleanupStack::PopAndDestroy( desBuf );

        DoEarlyPrimingL();

        }

    else if ( aDataSource.DataSourceType() == KUidMmfFileSource )

        {

        RUBY_DEBUG0( "File source detected" );

        CMMFFile* mmfFile = STATIC_CAST( CMMFFile*, &aDataSource );

        RUBY_DEBUG1( "Filename: %s", mmfFile->FullName().Ptr() );

        // Check that correct filename extension is used

        if ( mmfFile->FullName().Find( KTextFileExtension ) == KErrNotFound )

            {

            User::Leave( KErrNotSupported );

            }

        // Open file first if not yet open

        mmfFile->SourcePrimeL();

        RFile file( mmfFile->FileL() );

        // Find the size of tts input file

        TInt fileSize( 0 );

        User::LeaveIfError( file.Size( fileSize ) );

        // Create buffer for data

        HBufC8* fileBuffer = HBufC8::NewLC( fileSize );

        // Make sure we are in the beginnig of the file

        TInt tmp( 0 );

        file.Seek( ESeekStart, tmp );

        // Read data

        TPtr8 bufferPtr( fileBuffer->Des() );

        User::LeaveIfError( file.Read( bufferPtr ) );

        ConstructParsedTextL( bufferPtr );

        // No need to store the 8-bit text

        CleanupStack::PopAndDestroy( fileBuffer );

        DoEarlyPrimingL();    

        }

    else

        {

        RUBY_ERROR0( "Unknown source!" );

        User::Leave( KErrNotSupported );

        }

    }

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

// CTtsControllerPluginBody::AddDataSinkL

// Adds data sink.

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

//

void CTtsControllerPluginBody::AddDataSinkL( MDataSink& aDataSink )

    {

    RUBY_DEBUG_BLOCK( "CTtsControllerPluginBody::AddDataSinkL" );

    if ( aDataSink.DataSinkType() == KUidMmfAudioOutput )

        {

        iTtsOutputMode = EDevTTSSoundDeviceMode;

        }

    else if ( aDataSink.DataSinkType() == KUidMmfFileSink )

        {

        iTtsOutputMode = EDevTTSClientMode;

        CMMFFile* mmfFile = STATIC_CAST( CMMFFile*, &aDataSink );

        mmfFile->SinkPrimeL(); 

        iOutputFile = &mmfFile->FileL(); 

        TDriveInfo driveInfo;    

        User::LeaveIfError( iOutputFile->Drive( iOutFileDriveNumber, driveInfo ) );

        }

    else

        {

        User::Leave( KErrNotSupported );

        }

    }

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

// CTtsControllerPluginBody::RemoveDataSourceL

// Removes data source.

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

//

void CTtsControllerPluginBody::RemoveDataSourceL( MDataSource& /*aDataSource*/ )

    {

    RUBY_DEBUG_BLOCK( "CTtsControllerPluginBody::RemoveDataSourceL" );

    User::Leave( KErrNotSupported );

    }

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

// CTtsControllerPluginBody::RemoveDataSinkL

// Removes data sink.

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

//

void CTtsControllerPluginBody::RemoveDataSinkL( MDataSink& /*aDataSink*/ )

    {

    RUBY_DEBUG_BLOCK( "CTtsControllerPluginBody::RemoveDataSinkL" );

    if ( iOutputFile )

        {

        iOutputFile->Close(); 

        iOutputFile = NULL; 

        }

    }

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

// CTtsControllerPluginBody::ResetL

// Resets plugin & DevTTS to starting state.

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

//

void CTtsControllerPluginBody::ResetL()

    {

    RUBY_DEBUG_BLOCK( "CTtsControllerPluginBody::ResetL" );

    iDevTts->Stop();

    delete iDevTts;

    iDevTts = NULL;

    iDevTts = CDevTTS::NewL( *this );

    // Add default style to DevTTS

    iDefaultStyleID = iDevTts->AddStyleL( iDefaultStyle );

    delete iParsedTextPointer;

    iParsedTextPointer = NULL;

    iEarlyPrimingDone = EFalse;

    if ( iOutputFile )

        {

        iOutputFile->Close(); 

        iOutputFile = NULL; 

        }

    }

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

// CTtsControllerPluginBody::PrimeL

// Initializes synthesis. 

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

//

void CTtsControllerPluginBody::PrimeL()

    {

    RUBY_DEBUG_BLOCK( "CTtsControllerPluginBody::PrimeL" );

    TInt error( KErrNone );

    if ( iEarlyPrimingDone )

        {

        iEarlyPrimingDone = EFalse;

        }

    else

        {

        // Make sure that parsed text contains at least something to synthesize

        if ( iParsedTextPointer->Text() != KNullDesC  || 

             iParsedTextPointer->PhonemeSequence() != KNullDesC8 ) 

            {

            TRAP( error, iDevTts->PrimeSynthesisL( *iParsedTextPointer ) );

            }

        }

    iObserver->InitializationReady( error );        

    }

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

// CTtsControllerPluginBody::DoEarlyPrimingL

// Initializes synthesis. 

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

//

void CTtsControllerPluginBody::DoEarlyPrimingL()

    {

    RUBY_DEBUG_BLOCK( "CTtsControllerPluginBody::DoEarlyPrimingL" );

    // Make sure that parsed text contains at least something to synthesize

    if ( iParsedTextPointer->Text() != KNullDesC  || 

         iParsedTextPointer->PhonemeSequence() != KNullDesC8 )

        {

        iDevTts->PrimeSynthesisL( *iParsedTextPointer );

        }

    iEarlyPrimingDone = ETrue;    

    }

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

// CTtsControllerPluginBody::PlayL

// Starts playback.

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

//

void CTtsControllerPluginBody::PlayL()

    {

    RUBY_DEBUG_BLOCK( "CTtsControllerPluginBody::PlayL" );

    if ( IsActive() )

		{

		User::Leave( KErrServerBusy );

		}

	iRequestFunction = KPlay;

    Ready();

    }

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

// CTtsControllerPluginBody::HandlePlay

// Async handler for play

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

//

void CTtsControllerPluginBody::HandlePlay()

    {

    // Make sure that parsed text contains at least something to synthesize

    if ( iParsedTextPointer->Text() != KNullDesC || 

         iParsedTextPointer->PhonemeSequence() != KNullDesC8 )

        {

        TRAPD( error, iDevTts->SynthesizeL( iTtsOutputMode ) );

        // Do client callback now if leave happens, otherwise wait for the callback 

        // from DevTTS

        if ( error != KErrNone )

            {

            // Try if we can get rid of the problem by first doing initialization

            TRAP( error, iDevTts->PrimeSynthesisL( *iParsedTextPointer ) );

            if ( error != KErrNone )

                {

                iObserver->SynthesisReady( error );

                }

            // Then try to start synthesis again

            TRAP( error, iDevTts->SynthesizeL( iTtsOutputMode ) );

            if ( error != KErrNone )

                {

                iDevTts->Stop();

                iObserver->SynthesisReady( error );

                }

            }

        }

    else

        {

        iObserver->SynthesisReady( KErrNone );

        }

    }

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

// CTtsControllerPluginBody::PauseL

// Pauses playback & synthesis.

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

//

void CTtsControllerPluginBody::PauseL()

    {

    RUBY_DEBUG_BLOCK( "CTtsControllerPluginBody::PauseL" );

    iDevTts->Pause();

    }

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

// CTtsControllerPluginBody::StopL

// Stops playback & synthesis.

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

//

void CTtsControllerPluginBody::StopL()

    {

    RUBY_DEBUG_BLOCK( "CTtsControllerPluginBody::StopL" );

    iEarlyPrimingDone = EFalse;

    iDevTts->Stop();

    if ( iOutputFile )

        {

        iOutputFile->Close();

        iOutputFile = NULL; 

        }

    }

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

// CTtsControllerPluginBody::PositionL

// Returns the current playback position in microseconds.

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

//

TTimeIntervalMicroSeconds CTtsControllerPluginBody::PositionL() const

    {

    RUBY_DEBUG_BLOCK( "CTtsControllerPluginBody::PositionL" );

    TTimeIntervalMicroSeconds time( 0 );

    iDevTts->GetPositionL( time );

    return time;

    }

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

// CTtsControllerPluginBody::SetPositionL

// Sets the playback position.

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

//

void CTtsControllerPluginBody::SetPositionL( const TTimeIntervalMicroSeconds& /*aPosition*/ )

    {

    RUBY_DEBUG_BLOCK( "CTtsControllerPluginBody::SetPositionL" );

    // @todo Remove from comments when DevTTS does not anymore return 

    // KErrNotSupported

    // iDevTts->SetPositionL( aPosition );

    }

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

// CTtsControllerPluginBody::DurationL

// Returns duration of synthesized output.

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

//

TTimeIntervalMicroSeconds CTtsControllerPluginBody::DurationL() const

    {

    RUBY_DEBUG_BLOCK( "CTtsControllerPluginBody::DurationL" );

    TTimeIntervalMicroSeconds duration( 0 );

    if ( iParsedTextPointer )

        {

        // Count overall duration

        for ( TInt i = 0; i < iParsedTextPointer->NumberOfSegments(); i++ )

            {

            TTtsSegment segment = iParsedTextPointer->SegmentL( i );

            TTtsStyleID styleID = segment.StyleID();

            TTtsStyle style = iDevTts->StyleL( styleID );

            duration = duration.Int64() + style.iDuration.Int();

            }

        }

    return duration;

    }

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

// CTtsControllerPluginBody::SetPrioritySettings

// Sets the playback priority.

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

//

void CTtsControllerPluginBody::SetPrioritySettings( const TMMFPrioritySettings& aPrioritySettings )

    {

    RUBY_DEBUG0( "CTtsControllerPluginBody::SetPrioritySettings" );

    iDevTts->SetAudioPriority( aPrioritySettings.iPriority, 

                               (TDevTTSAudioPreference)aPrioritySettings.iPref );

    }

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

// CTtsControllerPluginBody::CustomCommand

// One supported custom command at the moment.

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

//

void CTtsControllerPluginBody::CustomCommand( TMMFMessage& aMessage )

    {

    RUBY_DEBUG0( "CTtsControllerPluginBody::CustomCommand" );

    TInt result( KErrNone );

    if ( aMessage.Function() == ETtsCustomCommandSetAudioOutput )

        {

        TBuf8<2> data;

        if ( aMessage.SizeOfData1FromClient() <= 2  && 

             aMessage.ReadData1FromClient( data ) == KErrNone )

            {