/*

* Copyright (c) 2006-2008 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 server

*

*/

// INCLUDES

#include <AudioOutput.h>

#include <nssttscommon.h>

#include "speechsynthesisserver.h"

#include "speechsynthesisclientserver.h"

#include "speechsynthesisserverutilities.h"

#include "speechsynthesissession.h"

#include "rubydebug.h"

// CONSTANTS

// Time to wait before tts plugin is closed if no activity detected. 

const TTimeIntervalMicroSeconds32 KTtsPluginCloseWait = 30000000; // 30 sec.

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

// RunServerL

// Server startup code

// Perform all server initialisation, in particular creation of the

// scheduler and server and then run the scheduler

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

//  

static void RunServerL()

    {

    RUBY_DEBUG_BLOCK( "SpeechSynthesisServer: RunServerL" );

    // Naming the server thread after the server helps to debug panics

    User::LeaveIfError( User::RenameThread( KSpeechSynthesisServerName ) );

    // Create and install the active scheduler we need

    CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;

    CleanupStack::PushL( scheduler );

    CActiveScheduler::Install( scheduler );

    // Create the server (leave it on the cleanup stack)

    CServer2* server = CSpeechSynthesisServer::NewLC();

    // Initialisation complete, now signal the client

    RProcess::Rendezvous( KErrNone );

    RUBY_DEBUG0( "SpeechSynthesisServer: server fully running." );

    // Ready to run

    CActiveScheduler::Start();

    RUBY_DEBUG0( "SpeechSynthesisServer: server closing." );

    // Cleanup the server and scheduler

    CleanupStack::PopAndDestroy( server );

    CleanupStack::PopAndDestroy( scheduler );

    }

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

// E32Main

// Server process entry-point

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

//

TInt E32Main()

    {

    __UHEAP_MARK;

    RUBY_DEBUG0( "SpeechSynthesisServer: E32Main" );

    CTrapCleanup* cleanup = CTrapCleanup::New();

    TInt error( KErrNoMemory );

    if ( cleanup )

        {

        TRAP( error, RunServerL() );

        delete cleanup;

        }

    __UHEAP_MARKEND;

    return error;

    }

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

// LanguageOrder

// Used in CSpeechSynthesisServer::GetSupportedLanguagesL()

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

// 

static TInt LanguageOrder( const TLanguage& a, const TLanguage& b )

    {

    TInt result( 0 );

    if ( a < b )

        {

        result = -1;

        }

    else if ( a > b )

        {

        result = 1;

        }

    return result;

    }

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

// CSpeechSynthesisServer::CSpeechSynthesisServer

// Constructor

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

inline CSpeechSynthesisServer::CSpeechSynthesisServer() :

    CPolicyServer( CActive::EPriorityStandard, 

                   KSpeechSynthesisPolicy, 

                   ESharableSessions ),

    iOpenTtsPlugin( KNullUid ),

    iSessionPriority( EMdaPriorityMin ), 

    iDefaultSpeakingRate( KTtsMaxSpeakingRate / 2 ),

    iDefaultAudioPriority( EMdaPriorityNormal ),

    iDefaultAudioPreference( EMdaPriorityPreferenceTimeAndQuality )

    {

    // Nothing

    }

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

// CSpeechSynthesisServer::~CSpeechSynthesisServer

// Destructor

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

//

CSpeechSynthesisServer::~CSpeechSynthesisServer()

    {    

    delete iTtsUtility;

    delete iShutdown;

    delete iConfigurationListener;

    delete iMMCListener; 

    iTtsVoiceConfigs.Close();

    if ( iPluginCloser )

        {

        iPluginCloser->Cancel();

        delete iPluginCloser;

        }

    }

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

// CSpeechSynthesisServer::NewLC

// 

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

//

CServer2* CSpeechSynthesisServer::NewLC()

    {

    RUBY_DEBUG0( "CSpeechSynthesisServer::NewLC" );

    CSpeechSynthesisServer* self = new(ELeave) CSpeechSynthesisServer();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CSpeechSynthesisServer::ConstructL

// 2nd phase construction - ensure the timer and server objects are running

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

//

void CSpeechSynthesisServer::ConstructL()

    {

    RUBY_DEBUG_BLOCK( "CSpeechSynthesisServer::ConstructL" );

    StartL( KSpeechSynthesisServerName );

    iTtsUtility = CTtsUtility::NewL( *this );

    iTtsUtility->SetPriority( iDefaultAudioPriority, 

                              (TMdaPriorityPreference)iDefaultAudioPreference );

    // Create object for closing tts plugin when server has been idle for a while. 

    iPluginCloser = CPeriodic::NewL( CActive::EPriorityIdle );

    // Listens for changes in SIS installations

    iConfigurationListener = CConfigurationListener::NewL( *this );

    // Listens insertions and removals of MMC. 

    iMMCListener = CMMCListener::NewL( *this );

    UpdateSynthesisConfigurationL();

    // Ensure that the server still exits even if the 1st client fails to connect

    iShutdown = CShutdown::NewL();

    iShutdown->Cancel();

    iShutdown->Start();

    }

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

// CSpeechSynthesisServer::AddSession

// A new session is being created

// Cancel the shutdown timer if it was running

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

//

void CSpeechSynthesisServer::AddSession()

    {

    RUBY_DEBUG0( "CSpeechSynthesisServer::AddSession" );

    iSessionCount++;

    iShutdown->Cancel();

    }

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

// CSpeechSynthesisServer::DropSession

// A session is being destroyed

// Start the shutdown timer if it is the last session.

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

//

void CSpeechSynthesisServer::DropSession()

    {

    RUBY_DEBUG0( "CSpeechSynthesisServer::DropSession" );

    iSessionCount--;

    if ( iSessionCount == 0 )

        {

        iShutdown->Cancel();

        iShutdown->Start();

        }

    }

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

// CSpeechSynthesisServer::ReserveL

//

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

//

void CSpeechSynthesisServer::ReserveL( MSpeechSynthesisServerObserver* aSession )

    {

    RUBY_DEBUG_BLOCK( "CSpeechSynthesisServer::ReserveL" );

    iPluginCloser->Cancel();

    if ( !iSession || iSession == aSession )

        {

        // Session is not in use or it's reserved already for this session

        iSession = aSession;

        }

    else

        {

        User::Leave( KErrInUse );

        }

    }

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

// CSpeechSynthesisServer::ReserveL

//

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

//

void CSpeechSynthesisServer::ReserveL( MSpeechSynthesisServerObserver* aSession,

                                       TInt aPriority )

    {

    RUBY_DEBUG_BLOCK( "CSpeechSynthesisServer::ReserveL" );

    iPluginCloser->Cancel();

    if ( !iSession || iSession == aSession )

        {

        // Session is not in use or it's reserved already for this session

        iSession = aSession;

        iSessionPriority = aPriority;

        }

    else if ( aPriority > iSessionPriority )

        {

        Stop();

        iSession->MsssOperationAborted();

        iPreviousSession = iSession;

        iSession = aSession; 

        iSessionPriority = aPriority; 

        }

    else 

        {

        User::Leave( KErrInUse ); 

        }

    }

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

// CSpeechSynthesisServer::Release

//

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

//

void CSpeechSynthesisServer::Release( const MSpeechSynthesisServerObserver* aSession )

    {

    RUBY_DEBUG0( "CSpeechSynthesisServer::Release" );

    if ( iSession == aSession )

        {

        iPreviousSession = iSession;

        iSession = NULL; 

        iSessionPriority = EMdaPriorityMin;

        TRAP_IGNORE( UpdateSynthesisConfigurationIfNeededL() );

        iPluginCloser->Cancel();

        iPluginCloser->Start( KTtsPluginCloseWait, KTtsPluginCloseWait,

                              TCallBack( ClosePlugin, this ) );

        RUBY_DEBUG0( "iPluginCloser started" );

        }

    }

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

// CSpeechSynthesisServer::GetDefaultSettingsL

//

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

//

void CSpeechSynthesisServer::GetDefaultSettingsL( TVoice& aVoice, 

                                  TInt& aSpeakingRate, TInt& aMaxSpeakingRate,

                                  TInt& aVolume, TInt& aMaxVolume, 

                                  TInt& aAudioPriority, TInt& aAudioPreference,

                                  TInt& aAudioOutput )

    {

    UpdateSynthesisConfigurationIfNeededL();

    aVoice           = iDefaultVoice;

    aSpeakingRate    = iDefaultSpeakingRate;

    aMaxSpeakingRate = KTtsMaxSpeakingRate;

    aVolume          = iDefaultVolume;

    aMaxVolume       = iDefaultMaxVolume;

    aAudioPriority   = iDefaultAudioPriority;

    aAudioPreference = iDefaultAudioPreference;

    aAudioOutput     = RSpeechSynthesis::ETtsOutputDefault;

    }

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

// CSpeechSynthesisServer::GetDefaultVoiceL

//

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

//

void CSpeechSynthesisServer::GetDefaultVoiceL( TVoice& aVoice )

    {

    UpdateSynthesisConfigurationIfNeededL();

    aVoice = iDefaultVoice;

    }

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

// CSpeechSynthesisServer::PrimeL

//

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

//

void CSpeechSynthesisServer::PrimeL( const TDesC& aText )

    {

    RUBY_DEBUG_BLOCK( "CSpeechSynthesisServer::PrimeL" );

    RUBY_ASSERT_DEBUG( iOpenTtsPlugin != KNullUid, User::Panic( KPanic, __LINE__ ) );

    iTtsUtility->OpenDesL( aText );

    }

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

// CSpeechSynthesisServer::PrimeL

//

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

//

void CSpeechSynthesisServer::PrimeL( const TDesC& aText, const RFile& aFile )

    {

    RUBY_DEBUG_BLOCK( "CSpeechSynthesisServer::PrimeL" );

    RUBY_ASSERT_DEBUG( iOpenTtsPlugin != KNullUid, User::Panic( KPanic, __LINE__ ) );

    iTtsUtility->SetOutputFileL( aFile ); 

    iTtsUtility->OpenDesL( aText ); 

    } 

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

// CSpeechSynthesisServer::Synthesize

//

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

//

void CSpeechSynthesisServer::Synthesize()

    {

    RUBY_DEBUG0( "CSpeechSynthesisServer::Synthesize" );

    RUBY_ASSERT_DEBUG( iOpenTtsPlugin != KNullUid, User::Panic( KPanic, __LINE__ ) );

    iTtsUtility->Play();

    }

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

// CSpeechSynthesisServer::Stop

//

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

//

void CSpeechSynthesisServer::Stop()

    {

    RUBY_DEBUG0( "CSpeechSynthesisServer::Stop" );

    if ( iOpenTtsPlugin != KNullUid )

        {

        iTtsUtility->Stop();

        }

    }

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

// CSpeechSynthesisServer::Pause

//

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

//

void CSpeechSynthesisServer::Pause()

    {

    RUBY_DEBUG0( "CSpeechSynthesisServer::Pause" );

    RUBY_ASSERT_DEBUG( iOpenTtsPlugin != KNullUid, User::Panic( KPanic, __LINE__ ) );

    iTtsUtility->Pause(); 

    }  

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

// CSpeechSynthesisServer::GetSupportedLanguagesL

//

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

//

void CSpeechSynthesisServer::GetSupportedLanguagesL( RArray<TLanguage>& aLanguages )

    {

    RUBY_DEBUG_BLOCK( "CSpeechSynthesisServer::GetSupportedLanguagesL" );

    UpdateSynthesisConfigurationIfNeededL();

    TInt error( KErrNone );    

    TLinearOrder<TLanguage> order( LanguageOrder );

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

        {

        // Add every language only once 

        error = aLanguages.InsertInOrder( iTtsVoiceConfigs[i].iLanguage, order );

        if ( error && error != KErrAlreadyExists )

            {

            User::Leave( error );

            }

        }

    }

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

// CSpeechSynthesisServer::GetSupportedVoicesL

//

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

//

void CSpeechSynthesisServer::GetSupportedVoicesL( TLanguage aLanguage, 

                                                  RArray<TVoice>& aVoices )

    {

    RUBY_DEBUG_BLOCK( "CSpeechSynthesisServer::GetSupportedVoicesL" );

    UpdateSynthesisConfigurationIfNeededL();

    TVoice voice;

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

        {

        if ( iTtsVoiceConfigs[i].iLanguage == aLanguage )

            {

            voice.iLanguage     = iTtsVoiceConfigs[i].iLanguage;

            voice.iVoiceName    = iTtsVoiceConfigs[i].iVoiceName;

            voice.iSamplingRate = iTtsVoiceConfigs[i].iSamplingRate;

            aVoices.AppendL( voice );

            }

        }

    }

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

// CSpeechSynthesisServer::SetVoiceL

//

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

//

void CSpeechSynthesisServer::SetVoiceL( TVoice aVoice, TInt aSpeakingRate )

    {

    RUBY_DEBUG_BLOCK( "CSpeechSynthesisServer::SetVoiceL" );

    UpdateSynthesisConfigurationIfNeededL();

    TTtsStyle newStyle;

    newStyle.iLanguage = aVoice.iLanguage;

    newStyle.iVoice    = aVoice.iVoiceName;

    newStyle.iRate     = aSpeakingRate;

    newStyle.iNlp      = ETrue;  // Turn NLP flag on, only Klatt will use it. 

    TInt voiceIndex( KErrNotFound );

    const TInt count ( 

    iTtsVoiceConfigs.Count() );

    TInt i( 0 );

    while ( i < count && voiceIndex < 0 )

        {        

        if ( iTtsVoiceConfigs[i].iLanguage == aVoice.iLanguage )

            {

            if ( aVoice.iVoiceName.Length() > 0 )

                {

                if ( iTtsVoiceConfigs[i].iVoiceName == aVoice.iVoiceName )

                    {

                    voiceIndex = i;

                    }

                }

            else

                {

                voiceIndex = i;

                }

            }

        i++;

        }

    if ( voiceIndex >= 0 )

        {

        if ( iOpenTtsPlugin != iTtsVoiceConfigs[voiceIndex].iPluginUid )

            {

            iTtsUtility->Close();