/*

* Copyright (c) 2003-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:  The CNssRecognitionHandler class performs the recognition function.

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <e32property.h>

#include "nssvascoreconstant.h"

#include "nssvascrecognitionhandler.h"

#include "nssvasctagmgr.h"

#include "nssvascadaptationitem.h"

#include <nsssispeechrecognitionutilityobserver.h>

#ifndef __WINS__

	// for hardware

    #include <AudioPreference.h>

#else

  // use default values for WINS

  const TUint KAudioPriorityVoiceDial = 73;

  const TUint KAudioPrefVocosPlayback = 0x00030001;

  const TUint KAudioPrefVocosTrain = 0x00020001;

  const TUint KAudioPrefVocosRecog = 0x00010001;

#endif

#include "nssvascdbtagselectnotifier.h"

#include "nssvascoreconstant.h"

#include "nssvasmrecognizeinitcompletehandler.h"

#include "nssvascvasdbbuilder.h"

#include "rubydebug.h"

// maximal number of results that can be handled

const TInt KMaxResults = 100;

#ifdef _DEBUG

// Used under UDEB only

_LIT( KRecognitionHandlerPanic, "VasCNssRecognitionHandler.cpp" );

#endif  // _DEBUG

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

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

// CNssRecognitionHandler::NewL

// Two-phased constructor.

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

//

CNssRecognitionHandler* CNssRecognitionHandler::NewL()

    {

    RUBY_DEBUG_BLOCK( "CNssRecognitionHandler::NewL" );

    // version of NewLC which leaves nothing on the cleanup stack

    CNssRecognitionHandler* self=NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CNssRecognitionHandler::NewLC

// Two-phased constructor.

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

//

CNssRecognitionHandler* CNssRecognitionHandler::NewLC()

    {

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

    CleanupStack::PushL(self);

    // push onto cleanup stack 

    // (in case self->ConstructL leaves)

    self->ConstructL();      // use two-stage construct

    return self;

    }

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

// CNssRecognitionHandler::~CNssRecognitionHandler

// Destructor

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

//

CNssRecognitionHandler::~CNssRecognitionHandler()

    {

    RUBY_DEBUG0( "CNssRecognitionHandler::~CNssRecognitionHandler" );

    Cleanup();

    for ( TInt k( 0 ); k < iAdaptItemArray.Count(); k++ )

        {

        iAdaptItemArray[k]->Disable();

        }

    iAdaptItemArray.Close();

    CNssVASDBBuilder::RemoveInstance();  // remove iVasDBBuilder instance

    TInt state( ERecognitionFail );

    RProperty::Get( KSINDUID, ERecognitionState, state );

    if ( state == ERecognitionStarted || state == ERecognitionSpeechEnd )

        {

        RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail );

        }

    // Delete P&S property

    RProperty::Delete( KSINDUID, ERecognitionState ); 

    }

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

// CNssRecognitionHandler::RecognizeInitL

// Method to perform initialization for the recognize funtion.

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

//

MNssRecognitionHandler::TNssRecognitionResult CNssRecognitionHandler::RecognizeInitL(

    MNssRecognizeInitCompleteHandler* aInitCompleteHandler,

    const CArrayPtrFlat<MNssContext>& aRecognitionVocabulary,

	TInt aMaxResults)

    {

    RUBY_DEBUG_BLOCK( "CNssRecognitionHandler::RecognizeInitL" );

    MNssRecognitionHandler::TNssRecognitionResult res = EVasErrorNone;

    // Vocabulary independent initialization:

    // CSISpeechRecognitionUtility and CSIClientResultSet.

    res = CommonRecognizeInitL( aInitCompleteHandler, aMaxResults );

    if ( res != EVasErrorNone )

        {

        return( res );

        }

    // Agenda for vocab dependent init:

    // 1. Get the list of global contexts from VAS DB.

    //    The information we need is:

    //     * Model Bank ID, which is the same for all contexts

    //     * Grammar ID for each context

    // 2. Load a model bank from SRS DB.

    // 3. Load the grammars from SRS DB. Each context has one grammar.

	if ( !iContextList )

	    {

		iContextList = new (ELeave) TMNssContextList(1);

        }

    else

        {

        iContextList->Reset();

        }

    for ( TInt k( 0 ); k < aRecognitionVocabulary.Count(); k++ )

        {

        CNssContext* context = ((CNssContext*)aRecognitionVocabulary[k])->CopyL();

        CleanupStack::PushL( context );

        iContextList->AppendL( context );

        CleanupStack::Pop( context );

        }

    iContextCount = iContextList->Count();

    // Check if there are tags in the contexts.

    // If there are, load a model bank. After that, further initializations

    // follow: Loading lexicons and grammars.

	// Check for Tags in contexts and continue recognition

	TRAPD( err, HandleTagCheckL() );

	if ( err != KErrNone )

	    {

        RUBY_DEBUG0( "CNssRecognitionHandler: TRAPD HandleTagCheckL() failed" );

		// Notify P&S

        RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 

		Cleanup();

        return EVasRecognitionInitFailed;

	    }

    return( EVasErrorNone );

    }

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

// CNssRecognitionHandler::RecognizeInitL

// Method to perform initialization for the recognize funtion.

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

//

MNssRecognitionHandler::TNssRecognitionResult CNssRecognitionHandler::RecognizeInitL(

		                   MNssRecognizeInitCompleteHandler* aInitCompleteHandler,

						   TInt aMaxResults)

    {

    RUBY_DEBUG_BLOCK( "CNssRecognitionHandler::RecognizeInitL" );

    MNssRecognitionHandler::TNssRecognitionResult res = EVasErrorNone;

    // Vocabulary independent initialization:

    // CSISpeechRecognitionUtility and CSIClientResultSet.

    res = CommonRecognizeInitL( aInitCompleteHandler, aMaxResults );

    if ( res != EVasErrorNone )

        {

        return( res );

        }

    // Agenda for vocab dependent init:

    // 1. Get the list of global contexts from VAS DB.

    //    The information we need is:

    //     * Model Bank ID, which is the same for all contexts

    //     * Grammar ID for each context

    // 2. Load a model bank from SRS DB.

    // 3. Load the grammars from SRS DB. Each context has one grammar.

    if ( iContextList )

        {

        iContextList->Reset();

        delete iContextList;

        }

	// Get Global Context List from Vas Db

    iContextList = iContextMgr->GetGlobalContexts();

    if ( !iContextList )

        {

        return EVasRecognitionInitFailed;

        }

    iContextCount = iContextList->Count();

	// Check for Tags in contexts and continue recognition

	TRAPD( err, HandleTagCheckL() );

	if ( err != KErrNone )

	    {

        RUBY_DEBUG0( "CNssRecognitionHandler: TRAPD HandleTagCheckL() failed" );

		// Notify P&S

        RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 

		Cleanup();

        return EVasRecognitionInitFailed;

	    }

	return EVasErrorNone;

    }

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

// CNssRecognitionHandler::Recognize

// Method to perform the recognize function.

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

//

MNssRecognitionHandler::TNssRecognitionResult CNssRecognitionHandler::Recognize(

                                        MNssRecognizeEventHandler* aEventHandler )

    {

    RUBY_DEBUG0( "CNssRecognitionHandler::Recognize" );

    if ( iRState != EVasWaitingForRecognize )

        {

        RUBY_DEBUG0( "CNssRecognitionHandler::Recognize - Unexpected Request" );

        // Notify P&S

        RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 

        Cleanup();

        return EVasUnexpectedRequest;

        }

    iEventHandler = aEventHandler;

    iRState = EVasWaitingForRecordStarted;

    RUBY_DEBUG0( "CNssRecognitionHandler: SRSF Record()" );

    // Asynchronous call: next expected event: ERecordStarted

    TInt errorCode = iSrsApi->Record( KNssVASRecordTime );

    if ( errorCode != KErrNone )

        {

        RUBY_DEBUG1( "CNssRecognitionHandler: Record Err = %d", errorCode );

        // Notify P&S

        RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 

        Cleanup();

        return EVasRecognitionFailed;

        }

    return EVasErrorNone;

    }

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

// CNssRecognitionHandler::PreStartSampling

// Method to start pre-sampling before the actual recognition start.

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

//

MNssRecognitionHandler::TNssRecognitionResult 

CNssRecognitionHandler::PreStartSampling( MNssRecognizeInitCompleteHandler* aInitCompleteHandler )

    {

    RUBY_DEBUG0( "" ); 

    // State check

    if ( iRState != EVasIdle )

        {

        RUBY_DEBUG0( "Unexpected Request" );

        return EVasUnexpectedRequest;

        }

    // Check callback

    if ( !aInitCompleteHandler )

        {

        return EVasInvalidParameter;

        }    

    iInitCompleteHandler = aInitCompleteHandler;

    if ( !iSrsApi )

        {		

        TRAPD( err, CreateSrfL() );

        if ( err != KErrNone )

            {

            RUBY_DEBUG0( "SRS creation fails" );

            iSrsApi = NULL;

            Cleanup();

            return EVasRecognitionInitFailed;

            }    

        }

    iSrsApi->SetAudioPriority( KAudioPriorityVoiceDial, 

                               KAudioPrefVocosTrain, 

                               KAudioPrefVocosPlayback, 

                               KAudioPrefVocosRecog );               

    TInt errorCode = iSrsApi->PreStartSampling();

    if ( errorCode != KErrNone )

        {

        RUBY_DEBUG1( "PreStartSampling Err = %d", errorCode );

        Cleanup();

        return EVasRecognitionInitFailed;

        }    

    return EVasErrorNone;

    }

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

// CNssRecognitionHandler::SelectTagL

// Method to initiate the Select Tag event.

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

//

MNssRecognitionHandler::TNssRecognitionResult CNssRecognitionHandler::SelectTagL(

															   MNssTag *aClientTag)

    {

    return SelectTagL( aClientTag, ETrue );

    }

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

// CNssRecognitionHandler::SelectTagL

// Method to initiate the Select Tag event.

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

//

MNssRecognitionHandler::TNssRecognitionResult CNssRecognitionHandler::SelectTagL( 

                                                            MNssTag* aClientTag, 

                                                            TBool aNotifyHandlers )

    {

    RUBY_DEBUG_BLOCK( "CNssRecognitionHandler::SelectTagL" );

    if ( iRState != EVasWaitingForSelectTag )

        {

        RUBY_DEBUG0( "CNssRecognitionHandler::SelectTagL - Unexpected Request" );

        // Notify P&S

        RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 

        Cleanup();

        return EVasUnexpectedRequest;

        }

    if ( !aClientTag )

        {

        RUBY_DEBUG0( "CNssRecognitionHandler: Invalid Parameter" );

        // Notify P&S

        RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 

        Cleanup();

        return EVasInvalidParameter;

        }

    // Check if we want to notify GlobalContext handlers

    if ( !aNotifyHandlers )

        {

        // No; just cleanup

        Cleanup();

        }

    else

        { // Yes

        // make a copy of the client tag, aClientTag, so the client can delete it

        CNssTag* internalTag = ((CNssTag*)aClientTag)->CopyL();

        Cleanup();

        CNssDBTagSelectNotifier *selectNotifier = iVasDBBuilder->GetTagSelectNotifier();

        selectNotifier->HandleSelection(internalTag);

        delete internalTag;

        }

    return EVasErrorNone;

    }

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

// CNssRecognitionHandler::RejectTagL

// Method to perform Reject Tag, i.e. blacklisting.

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

//

MNssRecognitionHandler::TNssRecognitionResult CNssRecognitionHandler::RejectTagL(

						   MNssRejectTagCompleteHandler* aRejectTagCompleteHandler,

		                   CArrayPtrFlat<MNssTag>* aClientTagList)

    {

    RUBY_DEBUG_BLOCK( "CNssRecognitionHandler::RejectTagL" );

    if ( iRState != EVasWaitingForSelectTag )

        {

        RUBY_DEBUG0( "CNssRecognitionHandler::RejectTagL - Unexpected Request" );

        // Notify P&S

        RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 	

        Cleanup();

        return EVasUnexpectedRequest;

        }

    // Begin a Loop to unload rules. A rule is contained in a tag.

    // The unload rule requests are Asynchronous. The 

    // loop is continued and completed in the event handler logic, 

    // MsruoEvent(aEvent=UnloadRuleComplete).

    // Loop through the input client tag list to build a Rule List, one rule 	

    // for each tag. Unload the rule corresponding to each tag.

    // iRejectTagCurrentLoopCount and iRejectTagCount control the loop.

    iRejectTagCompleteHandler = aRejectTagCompleteHandler;

    if (aClientTagList == 0)

        {

        // client tag list is NULL error

        RUBY_DEBUG0( "CNssRecognitionHandler: Invalid Parm: Tag List Null" );

        // Notify P&S

        RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 

        Cleanup();

        return EVasInvalidParameter;

        }

    iRejectTagCount = aClientTagList->Count(); 

    if (iRejectTagCount == 0)

        {

        // tag list is empty error

        RUBY_DEBUG0( "NssRecognitionHandler: Invalid Parm: Tag List Empty" );

        // Notify P&S

        RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 

        Cleanup();

        return EVasInvalidParameter;

        }

    iRejectTagCurrentLoopCount = 0; 

    if (!iRuleList)

        {

        iRuleList = new (ELeave) CArrayFixFlat<TRuleEntry>(iRejectTagCount);

        }

    TRuleEntry ruleEntry;

    for ( TInt index=0; index < iRejectTagCount; index++ )

        {

        CNssTag* tempTag = (CNssTag*)aClientTagList->At(index);

        CNssSpeechItem* speechItem = (CNssSpeechItem*)tempTag->SpeechItem();

        TUint32 ruleID = speechItem->RuleID();

        CNssContext* context = (CNssContext*)tempTag->Context();

        TUint32 grammarID = context->GrammarId();

        ruleEntry.ruleId = ruleID; 

        ruleEntry.grammarId = grammarID;

        iRuleList->AppendL(ruleEntry);

        }

    // get the first iRuleList entry = 0. The rest of the entries are

    // processed in the event handler, MsruoEvent(aEvent=UnloadRuleComplete)

    ruleEntry = iRuleList->At(iRejectTagCurrentLoopCount);

    TUint32 ruleID = ruleEntry.ruleId;

    TUint32 grammarID = ruleEntry.grammarId;

    iRState = EVasWaitingForUnloadRuleComplete;

    RUBY_DEBUG0( "CNssRecognitionHandler: SRSF UnloadRule()" );

    TInt errorCode = iSrsApi->UnloadRule( (TSIGrammarID)grammarID, ruleID );

    if ( errorCode )

        {

        RUBY_DEBUG1( "CNssRecognitionHandler: UnloadRule Err = %d", errorCode );

        // Notify P&S

        RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 

        Cleanup();

        return EVasRejectTagFailed;

        }

    return EVasErrorNone;

    }

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

// CNssRecognitionHandler::Cancel

// Method to cancel the last recognition function.

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

//

MNssRecognitionHandler::TNssRecognitionResult CNssRecognitionHandler::Cancel()

    {

    RUBY_DEBUG1( "CNssRecognitionHandler::Cancel() iRState = %d", iRState );

	// a Cancel request for the Idle state requires no action.	

    if ( iRState == EVasIdle )

        {

		return EVasErrorNone;    

        }