/*

* Copyright (c) 2004-2006 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:  The CNssSpeechItem provides speech mechanism to request services 

*               from SRS.

*

*/

// INCLUDE FILES

#include <e32std.h>

#include "srsfbldvariant.hrh"

#include <nssvascoreconstant.h>

#include "nssvascspeechitem.h"

#include "nssvascspeechitemtrainer.h"

#include "nssvasctag.h"

#include "nssvasctrainingparameters.h"

#include "nssvasdbkonsts.h"

#include "rubydebug.h"

// CONSTANTS

// This value is used for maximum retry times

const TInt KVASSpeechItemMaxRetry = 2;   

// This value is used to reset the retry number 

const TInt KVASSpeechItemResetRetry = 0;

// Character which is used instead of separator marker

_LIT( KEmptySpace, " " );

// Panic category

_LIT( KSpeechItemPanic, "CNssSpeechItem" );

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

// CNssSpeechItem::CNssSpeechItem

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

// might leave.

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

//

CNssSpeechItem::CNssSpeechItem( CNssContext& aContext, 

                                CNssSpeechItemSrsPortal& aPortal, 

                                CNssSpeechItemTrainer& aTrainer )

                              : iRuleID( KInvalidRuleID ),

                                iTrainedType( TNssVasCoreConstant::EVasNotTrained ),

                                iState( TNssSpeechItemConstant::EIdle ),

                                iContext( aContext ),

                                iPortal( aPortal ),

                                iTrainer( aTrainer ),

                                iTagId( KNssVASDbDefaultValue ),

                                iTrained( EFalse ),

                                iRecover( EFalse )

    {

    //Register to Portal

    iPortal.Register();

    }

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

// CNssSpeechItem::~CNssSpeechItem

// Destructor

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

//

CNssSpeechItem::~CNssSpeechItem()

    {

    delete iText;

    delete iTrimmedText;

    if ( iTtsData )

        {

        CleanPlayback();

        }

    iPortal.Deregister(); // Deregister to Portal

    }

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

// CNssSpeechItem::NewL

// Two-phased constructor.

// This is for new SpeechItem

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

//

CNssSpeechItem* CNssSpeechItem::NewL( CNssContext& aContext, 

                                      CNssSpeechItemSrsPortal& aPortal, 

                                      CNssSpeechItemTrainer& aTrainer )

    {

    CNssSpeechItem* self = new (ELeave) CNssSpeechItem( aContext, aPortal, aTrainer );

    return self;

    }

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

// CNssSpeechItem::ConstructL

// Symbian 2nd phase constructor can leave.

// This is overloaded function for SpeechItem from database

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

//

void CNssSpeechItem::ConstructL( TUint32 aRuleID, const TDesC& aText )

    {

    SetTextL( aText );

    iRuleID = aRuleID;

    }

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

// CNssSpeechItem::NewLC

// Two-phased constructor.

// This is overloaded function for SpeechItem from database

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

//

CNssSpeechItem* CNssSpeechItem::NewLC( CNssContext& aContext,

                                       CNssSpeechItemSrsPortal& aPortal,

                                       CNssSpeechItemTrainer& aTrainer,

                                       TUint32 aRuleID, const TDesC& aText )

    {

    CNssSpeechItem* self = new (ELeave) CNssSpeechItem( aContext, aPortal, aTrainer );

    CleanupStack::PushL( self );

    self->ConstructL( aRuleID, aText );

    return self;

    }

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

// CNssSpeechItem::NewL

// Two-phased constructor.

// This is overloaded function for SpeechItem from database

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

//

CNssSpeechItem* CNssSpeechItem::NewL( CNssContext& aContext,

                                      CNssSpeechItemSrsPortal& aPortal,

                                      CNssSpeechItemTrainer& aTrainer,

                                      TUint32 aRuleID, 

                                      const TDesC& aText )

    {

    CNssSpeechItem* self = NewLC( aContext, aPortal, aTrainer, aRuleID, 

                                  aText );

    CleanupStack::Pop( self );

    return self;

    }

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

// CNssSpeechItem::PlayL

// Method to do play operation. In SI, this means synthesizing the name.

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

//

MNssSpeechItem::TNssSpeechItemResult

CNssSpeechItem::PlayL( MNssPlayEventHandler* aPlayEventHandler, TLanguage aLanguage )

    {

    if ( !iTtsData )

        {

        iTtsData = new (ELeave) TTtsData;

        }

    iTtsData->iStyle.iLanguage = aLanguage;

    RUBY_DEBUG1( "CNssSpeechItem::PlayL lang id: %d", iTtsData->iStyle.iLanguage );

    // Verify for valid state

    if (!(iState == TNssSpeechItemConstant::EIdle ||

        iState == TNssSpeechItemConstant::ETrainComplete))

        {

        RUBY_DEBUG0( "CNssSpeechItem::PlayL - wrong state" );

        return MNssSpeechItem::EVasUnexpectedRequest;

        }

    // Verify for valid event handler

    if ( aPlayEventHandler )

        {

        iPlayEventHandler = aPlayEventHandler;

        }

    else

        {

        return MNssSpeechItem::EVasInvalidParameter;

        }

    TRAPD( err, DoPlayL() );

    if ( err != KErrNone )

        {

        CleanPlayback();

        return MNssSpeechItem::EVasPlayFailed;

        }

    return MNssSpeechItem::EVasErrorNone;

    }

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

// CNssSpeechItem::PlayL

// Method to do play operation. In SI, this means synthesizing the name.

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

//

MNssSpeechItem::TNssSpeechItemResult 

CNssSpeechItem::PlayL( MNssPlayEventHandler* aPlayEventHandler )

    {

    // Use UI language by default

    // If synthesis engine does not support UI language for some reason,

    // then language identification will be used instead

    return PlayL( aPlayEventHandler, User::Language() );

    }

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

// CNssSpeechItem::DoPlayL

// Starts playing. Assumes that all checks have been done earlier.

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

//

void CNssSpeechItem::DoPlayL()

    {

    TTtsData* d = iTtsData;

    d->iTts = CNssTtsUtilityWrapper::NewL( *this );

    d->iStyleID = d->iTts->AddStyleL( d->iStyle );

    d->iParsedText = CTtsParsedText::NewL();

    d->iParsedText->SetTextL( Text() );

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

    d->iSegment.SetStyleID( d->iStyleID );

    d->iParsedText->AddSegmentL( d->iSegment );

    d->iTts->OpenAndPlayParsedTextL( *d->iParsedText );

    iOldState = iState;

    iState = TNssSpeechItemConstant::EPlayStart;

    }

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

// CNssSpeechItem::CleanPlayback

// Cleans playback and releases all memory.

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

//

void CNssSpeechItem::CleanPlayback()

    {

    TTtsData* d = iTtsData;

    if ( d->iTts )

        {

        d->iTts->Stop();

        d->iTts->Close();

        }

    delete d->iParsedText;

    d->iParsedText = NULL;

    delete d->iTts;

    d->iTts = NULL;

    delete iTtsData;

    iTtsData = NULL;

    iState = iOldState;

    }

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

// CNssSpeechItem::MakePlayCallback

// Makes callback to VAS client. Uses error status from TTS Utility to decide

// callback and parameters.

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

//

void CNssSpeechItem::MakePlayCallback( TInt aResult )

    {

    MNssPlayEventHandler::TNssPlayResult res;

    if ( aResult == KErrNone )

        {

        iPlayEventHandler->HandlePlayComplete( MNssPlayEventHandler::EVasErrorNone );

        }

    else{

        switch( aResult )

            {

            case KErrNoMemory:

                res = MNssPlayEventHandler::EVasPlayNoMemory;

                break;

            case KErrAccessDenied:

                res = MNssPlayEventHandler::EVasPlayAccessDeny;

                break;

            default:

                res = MNssPlayEventHandler::EVasPlayFailed;

                break;

            }

        iPlayEventHandler->HandlePlayComplete( res );

        }

    }

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

// CNssSpeechItem::MapcCustomCommandEvent

// TTS may call this method if we had used custom interfaces,

// But we don't use custom interfaces.

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

//

void CNssSpeechItem::MapcCustomCommandEvent( TInt /*aEvent*/, TInt /*aError*/ )

    {

    // We don't expect to arrive here

    }

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

// CNssSpeechItem::MapcInitComplete

// TTS calls this method to announce that it has initialized playing.

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

//

void CNssSpeechItem::MapcInitComplete( TInt aError, const TTimeIntervalMicroSeconds& aDuration )

    {

    if ( aError != KErrNone )

        {

        CleanPlayback();

        MakePlayCallback( aError );

        }

    else

        {

        if ((iState == TNssSpeechItemConstant::EPlayStart) || 

            (iState == TNssSpeechItemConstant::EPlayMemoryStart)

            )

            {

            iPlayDuration = I64LOW( aDuration.Int64() );

            iPlayEventHandler->HandlePlayStarted(iPlayDuration);

            }

        else

            {

            NotifyHandlerForUnexpectedEvent();

            }

        }

    }

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

// CNssSpeechItem::MapcPlayComplete

// TTS calls this method to announce that playing has finished.

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

//

void CNssSpeechItem::MapcPlayComplete( TInt aError )

    {

    CleanPlayback();

    MakePlayCallback( aError );

    }

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

// CNssSpeechItem::RecordL

// Method to do record operation

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

//

MNssSpeechItem::TNssSpeechItemResult 

CNssSpeechItem::RecordL( MNssTrainVoiceEventHandler* aTrainVoiceEventHandler )

    {

    RUBY_DEBUG1( "CNssSpeechItem::RecordL tagid [%d]", iTagId );

    // Verify for valid state

    if (iState == TNssSpeechItemConstant::EIdle)

        {

        RUBY_DEBUG0( "CNssSpeechItem::RecordL - wrong state" );

        return MNssSpeechItem::EVasUnexpectedRequest;

        }

    // Verify for valid event handler

    if (aTrainVoiceEventHandler)

        {

        iTrainVoiceEventHandler = aTrainVoiceEventHandler;

        }

    else

        {

        return MNssSpeechItem::EVasInvalidParameter;

        }

    return MNssSpeechItem::EVasErrorNone;

    }

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

// CNssSpeechItem::TrainVoiceL

// Method to do train operation

// For retraining, the previous utterance data need to be preserved for the 

// delete operation later.

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

//

MNssSpeechItem::TNssSpeechItemResult 

CNssSpeechItem::TrainVoiceL(MNssTrainVoiceEventHandler* /*aTrainVoiceEventHandler*/)

    {

    // This is SI, don't even try to train by voice.

    return MNssSpeechItem::EVasUnexpectedRequest;

    }

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

// CNssSpeechItem::CancelL

// Method to do cancel operation by calling the SpeechRecognitionUtility Cancel

// method, and cleanup the SRS from the current transaction.

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

//

MNssSpeechItem::TNssSpeechItemResult CNssSpeechItem::CancelL()

    {

    RUBY_DEBUG1( "CNssSpeechItem::CancelL tagid [%d]", iTagId );

    //Verify a transaction is in progress

    if (iState == TNssSpeechItemConstant::EIdle)

        {   

        return MNssSpeechItem::EVasUnexpectedRequest;

        }

    // Do the Clean up

    CleanUp();

    return MNssSpeechItem::EVasErrorNone;

    }

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

// CNssSpeechItem::TrainingCapabilities

// Method to get the Training capabilities

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

//

CArrayFixFlat<TNssVasCoreConstant::TNssTrainingCapability>* 

CNssSpeechItem::TrainingCapabilities()

    { 

    return NULL;

    }

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

// CNssSpeechItem::RuleID

// Method to get the rule ID

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

//

TUint32 CNssSpeechItem::RuleID()

    {

    return iRuleID;

    }

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

// CNssSpeechItem::SetRuleID

// Method to set the rule ID

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

//

void CNssSpeechItem::SetRuleID(TUint32 aRuleID)

    {

    iRuleID = aRuleID;

    }

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

// CNssSpeechItem::TrainedType

// Method to get the Trained Type

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

//

TNssVasCoreConstant::TNssTrainedType CNssSpeechItem::TrainedType()

    {

    return iTrainedType;

    }

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

// CNssSpeechItem::SetTrainedType

// Method to set the Trained Type

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

//

void CNssSpeechItem::SetTrainedType( TNssVasCoreConstant::TNssTrainedType aTrainType )

    {

    iTrainedType = aTrainType;

    }

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

// CNssSpeechItem::Text

// Method to get the Text

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

//

TDesC& CNssSpeechItem::Text()

    {

    if ( iTrimmedText )

        {

        return *iTrimmedText;

        }

    if ( iText )

        {

        return *iText;

        }

    else

        {

        return (TDesC&)KNullDesC;

        }

    }

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

// CNssSpeechItem::RawText

// Method to get the raw text

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

//

TDesC& CNssSpeechItem::RawText()

    {

    if ( !iText )

        {

        return (TDesC&)KNullDesC;

        }

    return *iText;

    }

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

// CNssSpeechItem::PartialTextL

// Returns the part of the text which is indentified with the given ID

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

//

HBufC* CNssSpeechItem::PartialTextL( const TDesC& aIdentifier )

    {

    if ( !iText )

        {

        User::Leave( KErrNotFound  );

        }

    // Copy text for manipulation

    HBufC* partialText = HBufC::NewL( iText->Length() );

    CleanupStack::PushL( partialText );

    *partialText = *iText;

    TPtr partialTextPtr = partialText->Des();

    // Find all separator characters from text

    TInt markerIndex = partialTextPtr.Find( KNameSeparator );

    TBool found( EFalse );

    while ( markerIndex != KErrNotFound )

        {

        // Separator marker should never be the last character of string

        __ASSERT_ALWAYS( markerIndex <= partialTextPtr.Length(), User::Leave( KErrCorrupt ) );

        TBool removeThisPart( ETrue );

        if ( partialTextPtr.Mid( markerIndex + 1, 1 ) == aIdentifier )

            {