/*

* Copyright (c) 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:

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <stifparser.h>

#include <stiftestinterface.h>

#include <stiftesteventinterface.h>

#include <audiopreference.h>

#include <nssttscustomcommands.h>

#include <utf.h>

#include "ttsutilitytest.h"

_LIT( Kttsutilitytest, "ttsutilitytest" );

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

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

// Cttsutilitytest::Delete

// Delete here all resources allocated and opened from test methods. 

// Called from destructor. 

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

//

void Cttsutilitytest::Delete() 

    {

    iFs.Close();

    }

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

// Cttsutilitytest::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

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

//

TInt Cttsutilitytest::RunMethodL( 

    CStifItemParser& aItem ) 

    {

    TStifFunctionInfo const KFunctions[] =

        {  

        ENTRY( "CreateTtsUtility",      Cttsutilitytest::CreateTtsUtilityL ),

        ENTRY( "DestroyTtsUtility",     Cttsutilitytest::DestroyTtsUtilityL ),

        ENTRY( "StyleSettings",         Cttsutilitytest::StyleSettingsL ),

        ENTRY( "PlaybackProperties",    Cttsutilitytest::PlaybackPropertiesL ),

        ENTRY( "Play",                  Cttsutilitytest::Play ),

        ENTRY( "Pause",                 Cttsutilitytest::Pause ),

        ENTRY( "Stop",                  Cttsutilitytest::Stop ),

        ENTRY( "OpenDes",               Cttsutilitytest::OpenDesL ),

        ENTRY( "OpenDes8",              Cttsutilitytest::OpenDes8L ),

        ENTRY( "OpenFile",              Cttsutilitytest::OpenFileL ),

        ENTRY( "OpenParsedText",        Cttsutilitytest::OpenParsedTextL ),

        ENTRY( "OpenAndPlayDes",        Cttsutilitytest::OpenAndPlayDesL ),

        ENTRY( "OpenAndPlayDes8",       Cttsutilitytest::OpenAndPlayDes8L ),

        ENTRY( "OpenAndPlayFile",       Cttsutilitytest::OpenAndPlayFileL ),

        ENTRY( "OpenAndPlayParsedText", Cttsutilitytest::OpenAndPlayParsedTextL ),

        ENTRY( "SynthesisToFile",       Cttsutilitytest::SynthesisToFileL ),

        ENTRY( "CustomCommands",        Cttsutilitytest::CustomCommandsL ),

        ENTRY( "CustomCommands2",       Cttsutilitytest::CustomCommands2L ),

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

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

// Cttsutilitytest::CreateTtsUtilityL

// 

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

//

TInt Cttsutilitytest::CreateTtsUtilityL()

    {

    TestModuleIf().Printf( 0, Kttsutilitytest, _L("In CreateTtsUtilityL") );

    if ( iTtsUtility )

        {

        User::LeaveIfError( KErrAlreadyExists );

        }

    iTtsUtility = CTtsUtility::NewL( *this );

    return KErrNone;

    }

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

// Cttsutilitytest::DestroyTtsUtilityL

// 

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

//

TInt Cttsutilitytest::DestroyTtsUtilityL()

    {

    TestModuleIf().Printf( 0, Kttsutilitytest, _L("In DestroyTtsUtilityL") );

    delete iParsedText;

    iParsedText = NULL;

    iTtsUtility->Close();

    delete iTtsUtility;

    iTtsUtility = NULL; 

    return KErrNone;

    }

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

// Cttsutilitytest::StyleSettingsL

// 

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

//

TInt Cttsutilitytest::StyleSettingsL()

    {

    TestModuleIf().Printf( 0, Kttsutilitytest, _L("In StyleSettingsL") );

    OpenPluginL();

    iStyle.iLanguage = ELangEnglish;

    iStyle.iVoice    = KDefaultVoiceNameMale;

    iStyle.iQuality  = ETtsQualityLowPreferred;

    iTtsUtility->SetDefaultStyleL( iStyle );

    TTtsStyle defaultStyle = iTtsUtility->DefaultStyleL();

    if ( iStyle.iLanguage != defaultStyle.iLanguage || 

         iStyle.iVoice    != defaultStyle.iVoice || 

         iStyle.iQuality  != defaultStyle.iQuality )

        {

        User::Leave( KErrGeneral );

        }

    TTtsStyleID styleId = iTtsUtility->AddStyleL( iStyle ); 

    TTtsStyle style = iTtsUtility->StyleL( styleId ); 

    if ( iStyle.iLanguage != style.iLanguage || 

         iStyle.iVoice    != style.iVoice || 

         iStyle.iQuality  != style.iQuality )

        {

        User::Leave( KErrGeneral );

        }

    // There should be only one style

    TUint16 index = 1;

    TRAPD( error, style = iTtsUtility->StyleL( index ) );

    if ( error != KErrNotFound )

        {

        User::Leave( KErrGeneral );

        }

    if ( iTtsUtility->NumberOfStyles() == 1 )

        {

        iTtsUtility->DeleteStyle( styleId );

        }

    RArray<TLanguage> languages;

    CleanupClosePushL( languages );

    iTtsUtility->GetSupportedLanguagesL( languages );

    if ( languages.Count() > 0 )

        {

        RArray<TTtsStyle> voices;

        iTtsUtility->GetSupportedVoicesL( languages[0], voices );

        if ( voices.Count() == 0 )

            {

            User::Leave( KErrNotFound );

            }

        voices.Close();

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    CleanupStack::PopAndDestroy( &languages );

    return KErrNone;

    }

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

// Cttsutilitytest::PlaybackPropertiesL

// 

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

//

TInt Cttsutilitytest::PlaybackPropertiesL()

    {

    TestModuleIf().Printf( 0, Kttsutilitytest, _L("In PlaybackPropertiesL") );

    OpenPluginL();

    TInt maxVolume( iTtsUtility->MaxVolume() );

    iTtsUtility->SetVolume( maxVolume );

    TInt volume;

    iTtsUtility->GetVolume( volume );

    if ( volume != maxVolume )

        {

        User::Leave( KErrGeneral );

        }

    TRAP_IGNORE( TInt speakingRate = iTtsUtility->SpeakingRateL() );

    TRAP_IGNORE( iTtsUtility->SetSpeakingRateL( KTtsMaxSpeakingRate ) );

    iTtsUtility->SetRepeats( 1, 1000 );

    TInt balance;

    iTtsUtility->GetBalance( balance );

    iTtsUtility->SetBalance( balance );

    TTimeIntervalMicroSeconds duration = iTtsUtility->Duration();

    iTtsUtility->SetPriority( KAudioPriorityVoiceDial, 

                              (TMdaPriorityPreference)KAudioPrefVocosPlayback );

    iTtsUtility->GetPosition( duration );

    iTtsUtility->SetPosition( duration );

    TInt wordIndex( KErrNotFound );

    iTtsUtility->GetPosition( wordIndex );

    iTtsUtility->SetPosition( wordIndex );

    return KErrNone;

    }

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

// Cttsutilitytest::Play

// 

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

//

TInt Cttsutilitytest::Play()

    {

    TestModuleIf().Printf( 0, Kttsutilitytest, _L("In Play") );

    iTtsUtility->Play();

    return KErrNone;

    }

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

// Cttsutilitytest::Pause

// 

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

//

TInt Cttsutilitytest::Pause()

    {

    TestModuleIf().Printf( 0, Kttsutilitytest, _L("In Pause") );

    iTtsUtility->Pause();

    return KErrNone;

    }

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

// Cttsutilitytest::Stop

// 

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

//

TInt Cttsutilitytest::Stop()

    {

    TestModuleIf().Printf( 0, Kttsutilitytest, _L("In Stop") );

    iTtsUtility->Stop();

    return KErrNone;

    }

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

// Cttsutilitytest::OpenDesL

// 

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

//

TInt Cttsutilitytest::OpenDesL( CStifItemParser& aItem )

    {

    TestModuleIf().Printf( 0, Kttsutilitytest, _L("In OpenDesL") );

    TPtrC input;

    User::LeaveIfError( aItem.GetNextString ( input ) );

    iTtsUtility->OpenDesL( input );

    return KErrNone;

    }

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

// Cttsutilitytest::OpenDes8L

// 

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

//

TInt Cttsutilitytest::OpenDes8L( CStifItemParser& aItem )

    {

    TestModuleIf().Printf( 0, Kttsutilitytest, _L("In OpenDes8L") );

    TPtrC input;

    User::LeaveIfError( aItem.GetNextString ( input ) );

    HBufC8* input8 = HBufC8::NewLC( 4 * input.Length() );

    TPtr8 refText = input8->Des();

    User::LeaveIfError( CnvUtfConverter::ConvertFromUnicodeToUtf8( refText, input ) );

    iTtsUtility->OpenDesL( *input8 );

    CleanupStack::PopAndDestroy( input8 );

    return KErrNone;

    }

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

// Cttsutilitytest::OpenFileL

// 

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

//

TInt Cttsutilitytest::OpenFileL( CStifItemParser& aItem )

    {

    TestModuleIf().Printf( 0, Kttsutilitytest, _L("In OpenFileL") );

    TPtrC input;

    User::LeaveIfError( aItem.GetNextString ( input ) );

    iTtsUtility->OpenFileL( input );

    return KErrNone;

    }

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

// Cttsutilitytest::OpenParsedTextL

// 

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

//

TInt Cttsutilitytest::OpenParsedTextL( CStifItemParser& aItem )

    {

    TestModuleIf().Printf( 0, Kttsutilitytest, _L("In OpenParsedTextL") );

    TInt result( KErrGeneral );

    TPtrC input;

    User::LeaveIfError( aItem.GetNextString ( input ) );

    if ( iParsedText )

        {

        delete iParsedText;

        iParsedText = NULL;

        }

    iStyle.iLanguage = User::Language();

    iStyle.iVoice    = KDefaultVoiceNameFemale;

    iStyle.iQuality  = ETtsQualityLowOnly;

    iParsedText = CTtsParsedText::NewL();

    iParsedText->SetPhonemeNotationL( KNullDesC );

    iParsedText->SetTextL( input );

    iSegment.SetStyle( iStyle );

    iStyle = iSegment.StyleL();

    iSegment.ResetStyle();

    iSegment.SetTrailingSilenceL( iSegment.TrailingSilence() );

    iSegment.SetStyleID( iTtsUtility->AddStyleL( iStyle ) );

    iSegment.SetTextPtr( iParsedText->Text() );

    iParsedText->AddSegmentL( iSegment );   

    if ( iParsedText->IsValid() )

        {

        result = KErrNone;

        iTtsUtility->OpenParsedTextL( *iParsedText );

        }

    return result;

    }

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

// Cttsutilitytest::OpenAndPlayDesL

// 

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

//

TInt Cttsutilitytest::OpenAndPlayDesL( CStifItemParser& aItem )

    {

    TestModuleIf().Printf( 0, Kttsutilitytest, _L("In OpenAndPlayDesL") );

    TPtrC input;

    User::LeaveIfError( aItem.GetNextString ( input ) );

    iTtsUtility->OpenAndPlayDesL( input );

    return KErrNone;

    }

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

// Cttsutilitytest::OpenAndPlayDes8L

// 

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

//

TInt Cttsutilitytest::OpenAndPlayDes8L( CStifItemParser& aItem )

    {

    TestModuleIf().Printf( 0, Kttsutilitytest, _L("In OpenAndPlayDes8L") );

    TPtrC input;

    User::LeaveIfError( aItem.GetNextString ( input ) );

    HBufC8* input8 = HBufC8::NewLC( 4 * input.Length() );

    TPtr8 refText = input8->Des();

    User::LeaveIfError( CnvUtfConverter::ConvertFromUnicodeToUtf8( refText, input ) );

    iTtsUtility->OpenAndPlayDesL( *input8 );

    CleanupStack::PopAndDestroy( input8 );

    return KErrNone;

    }

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

// Cttsutilitytest::OpenAndPlayFileL

// 

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

//

TInt Cttsutilitytest::OpenAndPlayFileL( CStifItemParser& aItem )

    {

    TestModuleIf().Printf( 0, Kttsutilitytest, _L("In OpenAndPlayFileL") );

    TPtrC input;

    User::LeaveIfError( aItem.GetNextString ( input ) );

    iTtsUtility->OpenAndPlayFileL( input );

    return KErrNone;

    }

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

// Cttsutilitytest::OpenAndPlayParsedTextL

// 

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

//

TInt Cttsutilitytest::OpenAndPlayParsedTextL( CStifItemParser& aItem )

    {

    TestModuleIf().Printf( 0, Kttsutilitytest, _L("In OpenAndPlayParsedTextL") );

    TPtrC input;

    User::LeaveIfError( aItem.GetNextString ( input ) );

    if ( iParsedText == NULL )

        {

        iStyle.iLanguage = User::Language();

        iStyle.iVoice    = KDefaultVoiceNameFemale;

        iStyle.iQuality  = ETtsQualityLowOnly;

        iParsedText = CTtsParsedText::NewL();

        iParsedText->SetTextL( input );

        iSegment.SetStyleID( iTtsUtility->AddStyleL( iStyle ) );

        iSegment.SetTextPtr( iParsedText->Text() );

        iParsedText->AddSegmentL( iSegment );   

        }

    iTtsUtility->OpenAndPlayParsedTextL( *iParsedText );

    return KErrNone;

    }

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

// Cttsutilitytest::SynthesisToFileL

// 

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

//

TInt Cttsutilitytest::SynthesisToFileL( CStifItemParser& aItem )

    {

    TestModuleIf().Printf( 0, Kttsutilitytest, _L("In SynthesisToFileL") );

    TPtrC fileName;

    User::LeaveIfError( aItem.GetNextString ( fileName ) );

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

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

    iFs.MkDirAll( fileName ); // Ignore error (KErrAlreadyExists comes quite often)

    User::LeaveIfError( iFile.Replace( iFs, fileName, EFileWrite ) ); 

    iTtsUtility->SetOutputFileL( iFile );

    return KErrNone;

    }

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

// Cttsutilitytest::CustomCommandsL

// 

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

//

TInt Cttsutilitytest::CustomCommandsL()

    {

    TestModuleIf().Printf( 0, Kttsutilitytest, _L("In CustomCommandsL") );

    TUid openPlugin = OpenPluginL();

    TMMFMessageDestinationPckg destination( openPlugin );

    TBuf8<2> dataTo;

    dataTo.AppendNum( 1 );    

    TInt err1 = iTtsUtility->CustomCommandSync( destination, ETtsCustomCommandSetAudioOutput, 

                                                dataTo, KNullDesC8 );

    TBuf8<16> dataFrom;

    TInt err2 = iTtsUtility->CustomCommandSync( destination, ETtsCustomCommandSetAudioOutput, 

                                                dataTo, KNullDesC8, dataFrom );

    TRequestStatus status1( KRequestPending );

    iTtsUtility->CustomCommandAsync( destination, ETtsCustomCommandSetAudioOutput, 

                                     dataTo, KNullDesC8, status1 );

    User::WaitForRequest( status1 );