/*

* Copyright (c) 2006-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:  Speech synthesis session

*

*/

// INCLUDES

#include "speechsynthesissession.h"

#include "speechsynthesisserver.h"

#include "speechsynthesisclientserver.h"

#include "rubydebug.h"

// CONSTANTS

const TInt KMinVolume = 0;

const TInt KMinSpeakingRate = 1;

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

// CSpeechSynthesisSession::CSpeechSynthesisSession

// Constructor 

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

//

CSpeechSynthesisSession::CSpeechSynthesisSession():

    iSessionState( ESessionIdle )

    {

    RUBY_DEBUG0( "CSpeechSynthesisSession::CSpeechSynthesisSession" );

    }

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

// CSpeechSynthesisSession::CreateL

// 2nd phase construct for sessions - called by the CServer framework

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

//

void CSpeechSynthesisSession::CreateL()

    {

    RUBY_DEBUG_BLOCK( "CSpeechSynthesisSession::CreateL" );

    Server().GetDefaultSettingsL( iCurrentVoice, 

                                  iSpeakingRate, iMaxSpeakingRate,

                                  iVolume, iMaxVolume, 

                                  iAudioPriority, iAudioPreference,

                                  iAudioOutput );

    iTmpAudioOutput = iAudioOutput;

    iTmpVolume = iVolume;

    Server().AddSession();

    }

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

// CSpeechSynthesisSession::~CSpeechSynthesisSession

// Destructor

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

//

CSpeechSynthesisSession::~CSpeechSynthesisSession()

    {

    RUBY_DEBUG0( "CSpeechSynthesisSession::~CSpeechSynthesisSession" );

    iLanguages.Close();

    iVoices.Close();

    iCustomCommands.Close();

    Server().Release( this );

    Server().DropSession();

    }

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

// CSpeechSynthesisSession::MsssInitComplete

// Callback from server

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

//

void CSpeechSynthesisSession::MsssInitComplete( TInt aError, 

                                                const TTimeIntervalMicroSeconds& aDuration )

    {

    RUBY_DEBUG1( "CSpeechSynthesisSession::MsssInitComplete [%d]", aError );

    if ( aError )

        {

        iSessionState = ESessionIdle;

        iFileOutputActivated = EFalse; 

        iDuration = 0;

        iFile.Close();

        Server().Release( this );

        }

    else

        {

        iSessionState = ESessionPrimed;

        iDuration = aDuration;

        }

    if ( iStoredMessage.IsNull() )

        {

        RUBY_ERROR0( "iStoredMessage.IsNull() == ETrue" );

        }

    else

        {

        iStoredMessage.Complete( aError );

        RUBY_DEBUG0( "Message completed" );

        }

    }

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

// CSpeechSynthesisSession::MsssPlayComplete

// Callback from server

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

//      

void CSpeechSynthesisSession::MsssPlayComplete( TInt aError )

    {

    RUBY_DEBUG1( "CSpeechSynthesisSession::MsssPlayComplete [%d]", aError );

    iSessionState = ESessionIdle;

    iFileOutputActivated = EFalse; 

    iDuration = 0;

    iFile.Close();

    Server().Release( this );

    if ( iStoredMessage.IsNull() )

        {

        RUBY_ERROR0( "iStoredMessage.IsNull() == ETrue" );

        }

    else

        {

        iStoredMessage.Complete( aError );

        RUBY_DEBUG0( "Message completed" );

        }

    }

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

// CSpeechSynthesisSession::MsssOperationAborted

// Callback from server

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

//      

void CSpeechSynthesisSession::MsssOperationAborted()

    {

    RUBY_DEBUG0( "CSpeechSynthesisSession::MsssOperationAborted" );

    iSessionState = ESessionIdle;

    iFileOutputActivated = EFalse; 

    iDuration = 0;

    iFile.Close();

    if ( !iStoredMessage.IsNull() )

        {

        RUBY_DEBUG0( "Completing message with KErrDied" );

        iStoredMessage.Complete( KErrDied );

        }

    }

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

// CSpeechSynthesisSession::Server

//

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

//

inline CSpeechSynthesisServer& CSpeechSynthesisSession::Server()

    {

    return *static_cast<CSpeechSynthesisServer*>(

                const_cast<CServer2*>( CSession2::Server() ) );

    }

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

// CSpeechSynthesisSession::ServiceL

// Handle a client request.

// Leaving is handled by CSpeechSynthesisSession::ServiceError() which reports

// the error code to the client

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

//

void CSpeechSynthesisSession::ServiceL( const RMessage2& aMessage )

    {

    RUBY_DEBUG_BLOCK( "CSpeechSynthesisSession::ServiceL" );

    RUBY_DEBUG1( "aMessage.Function(): %d", aMessage.Function() );

    TInt message( aMessage.Function() );

    if ( message == EPrime || message == EPrimeFileOutput || 

         message == EPrimeStreamOutput || message == ESynthesise )

        {

        Server().ReserveL( this, iAudioPriority );

        TRAPD( error, DoAsyncServiceL( aMessage ) );

        if( error ) 

            {

            Server().Release( this );

            User::Leave( error );

            }

        }

    else

        {

        DoSyncServiceL( aMessage );

        }

    }

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

// CSpeechSynthesisSession::DoAsyncServiceL

// 

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

//

void CSpeechSynthesisSession::DoAsyncServiceL( const RMessage2& aMessage )

    {

    RUBY_DEBUG_BLOCK( "CSpeechSynthesisSession::DoAsyncServiceL" );

    TInt function( aMessage.Function() );

    if ( function == ESynthesise )

        {

        if ( iSessionState == ESessionPrimed )

            {

            if ( !iFileOutputActivated )

                { // Values may be changed when synthesis is paused. 

                if ( iTmpVolume != iVolume )

                    {

                    Server().SetVolume( iVolume );

                    iTmpVolume = iVolume;

                    }

                if ( iTmpAudioOutput != iAudioOutput )

                    {

                    Server().SetAudioOutputL( iAudioOutput );

                    iTmpAudioOutput = iAudioOutput;

                    }

                }

            Server().Synthesize();

            }

        else

            {

            User::Leave( KErrNotReady );

            }

        }

    else if ( function == EPrimeStreamOutput )

        {

        User::Leave( KErrNotSupported );

        }

    else  // Prime or EPrimeFileOutput

        {

        iSessionState = ESessionIdle;

        Server().Stop();

        if ( iClosePlugin || Server().PreviousSession() != this )

            {

            iClosePlugin = EFalse; 

            Server().ClosePlugin();

            Server().SetVoiceL( iCurrentVoice, iSpeakingRate );

            // Set custom commands, plugin ingnores commands if the state

            // is incorrect for some command

            for ( TInt i( 0 ); i < iCustomCommands.Count(); i++ )

                {

                Server().CustomCommand( iCustomCommands[i].iCommand, iCustomCommands[i].iValue );

                }

            }

        else

            {

            Server().SetVoiceL( iCurrentVoice, iSpeakingRate );

            }

        // Fetch text to be synthesised

        HBufC* text = HBufC::NewLC( aMessage.GetDesLengthL( 0 ) );

        TPtr ptr = text->Des();

        aMessage.ReadL( 0, ptr );

        if ( function == EPrime )

            {

            Server().SetAudioPriorityL( iAudioPriority, iAudioPreference );

            Server().SetVolume( iVolume );

            iTmpVolume = iVolume;

            Server().SetAudioOutputL( iAudioOutput );

            iTmpAudioOutput = iAudioOutput;

            Server().PrimeL( ptr );

            // Set custom commands, plugin ingnores commands if the state

            // is incorrect for some command

            for ( TInt i( 0 ); i < iCustomCommands.Count(); i++ )

                { 

                Server().CustomCommand( iCustomCommands[i].iCommand, iCustomCommands[i].iValue );

                }

            iFileOutputActivated = EFalse; 

            }

        else

            {

            Server().PrimeL( ptr, iFile ); 

            iFileOutputActivated = ETrue;

            }

        CleanupStack::PopAndDestroy( text );

        }

    iStoredMessage = aMessage;

    }

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

// CSpeechSynthesisSession::DoSyncServiceL

// 

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

//

void CSpeechSynthesisSession::DoSyncServiceL( const RMessage2& aMessage )

    {

    RUBY_DEBUG_BLOCK( "CSpeechSynthesisSession::DoSyncServiceL" );

    switch ( aMessage.Function() ) 

        {

        case ETransferFileHandle:

            User::LeaveIfError( iFile.AdoptFromClient( aMessage, 

                                                       KFsHandleIndex, 

                                                       KFileHandleIndex ) ); 

            break;

        case EStopSynthesis:

            DoStopSynthesisL();

            break;

        case EPauseSynthesis:

            DoPauseSynthesisL();

            break;

        case EGetDuration: 

            DoGetDurationL( aMessage );

            break;

        case EGetLanguages:

            DoGetLanguagesL( aMessage );

            break;

        case EGetLanguageCount:

            DoGetLanguageCountL( aMessage );

            break;

        case EGetVoices:

            DoGetVoicesL( aMessage );

            break;

        case EGetVoiceCount:

            DoGetVoiceCountL( aMessage );

            break;            

        case EVoice:

            DoVoiceL( aMessage );

            break;

        case ESetVoice:

            DoSetVoiceL( aMessage );

            break;

        case EMaxSpeakingRate:

            DoMaxSpeakingRateL( aMessage );

            break;

        case ESpeakingRate:

            DoSpeakingRateL( aMessage );

            break;

        case ESetSpeakingRate:

            DoSetSpeakingRateL( aMessage );

            break;

        case EMaxVolume:

            DoMaxVolumeL( aMessage );

            break;

        case EVolume:

            DoVolumeL( aMessage );

            break;

        case ESetVolume:

            DoSetVolumeL( aMessage );

            break;

        case ESetAudioPriority:

            DoSetAudioPriority( aMessage );

            break;

        case ESetAudioOutput:

            DoSetAudioOutputL( aMessage );

            break;

        case ECustomCommand:

            DoCustomCommandL( aMessage );

            break;

        default:

            RUBY_ERROR1( "CSpeechSynthesisSession::ServiceL - %d",

                         aMessage.Function() );

            PanicClient( aMessage, EPanicIllegalFunction );

            break;

        }

    aMessage.Complete( KErrNone ); 

    }

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

// CSpeechSynthesisSession::DoStopSynthesisL

// 

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

//

void CSpeechSynthesisSession::DoStopSynthesisL()

    {

    RUBY_DEBUG_BLOCK( "" );

    // Check we have permission to use server. 

    Server().ReserveL( this );

    // Synthesis is ongoing

    Server().Stop();

    iSessionState = ESessionIdle;

    iDuration = 0;

    iFile.Close();

    // Release server and complete the previous message

    Server().Release( this );

    if ( !iStoredMessage.IsNull() )

        {

        iStoredMessage.Complete( KErrAbort );

        }

    }

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

// CSpeechSynthesisSession::DoPauseSynthesisL

// 

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

//

void CSpeechSynthesisSession::DoPauseSynthesisL()

    {

    RUBY_DEBUG_BLOCK( "" );

    if ( iSessionState == ESessionPrimed && !iStoredMessage.IsNull() )

        {

        if ( iFileOutputActivated )

            {

            User::Leave( KErrNotSupported );

            }

        // Check we have permission to use server. 

        Server().ReserveL( this );

        // Synthesis is ongoing

        Server().Pause();

        iStoredMessage.Complete( KErrCancel );

        }

    else

        {

        User::Leave( KErrNotReady );

        }

    }

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

// CSpeechSynthesisSession::DoGetDurationL

// 

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

//

void CSpeechSynthesisSession::DoGetDurationL( const RMessage2& aMessage )

    {

    RUBY_DEBUG_BLOCK( "" );

    if ( iSessionState != ESessionPrimed )

        {

        User::Leave( KErrNotReady ); 

        }

    else if ( iDuration.Int64() == 0 )