/*

* Copyright (c) 2004-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:  This file contains the implementation of Recognition Algorithm

*               Manager, a submodule of DevASR.

*

*/

// INCLUDE FILES

#ifdef _DEBUG

#include <e32svr.h>

#endif

#include "devasrrecognitionalgmgr.h"

#include "rubydebug.h"

// CONSTANTS

const TInt KInitFrontEnd        = 1;

//const TInt KInitTrainBE         = 2;

const TInt KInitRecognizerBE    = 3;

const TInt KLoadGrammar         = 4;

const TInt KLoadLexicon         = 5;

const TInt KLoadModels          = 6;

//const TInt KUtteranceDataRcvd   = 7;

const TInt KActivateGrammar     = 8;

const TInt KDeActivateGrammar   = 9;

const TInt KUnloadRule          = 10;

const TInt KUnloadGrammar       = 11;

//_LIT( KPanicDescriptor, "CRecognitionAlgMgr Panic" );

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

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

// CRecognitionAlgMgr::CRecognitionAlgMgr

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

// might leave.

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

//

CRecognitionAlgMgr::CRecognitionAlgMgr( MRecAlgMgrObserver& aObserver )

                    : CActive( CActive::EPriorityStandard ),

                      iRecAlgMgrObserver( &aObserver ),

                      iCombinedGrammar( NULL ),

                      iCombineNeeded( ETrue ),

                      iInitialized( EFalse ),

                      iRecoHw( NULL ),

                      iAdaptHw( NULL ),

                      iSDModelBank( NULL ),

                      iSIModelBank( NULL ),

                      iSDGrammar( NULL ),

                      iSIGrammar( NULL ),

                      iSICompGrammar( NULL ),

                      iSDCompGrammar( NULL ),

                      iSDLexicon( NULL ),

                      iSILexicon( NULL ),

                      iFEState( EIdle ),

                      iBEState( EIdle ),

                      iFeatures( EFalse ),

                      iAdaptation( ETrue ),

                      iAdaptationData( NULL )

    {

    RUBY_DEBUG0( "CRecognitionAlgMgr::CRecognitionAlgMgr()" );

    }

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

// CRecognitionAlgMgr::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CRecognitionAlgMgr::ConstructL()

    {

    RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::ConstructL()" );

    iRecoHw = CASRSRecognitionHwDevice::NewL( *this );

    iRecoHw->InitializeL();

    iAdaptHw = CASRSAdaptHwDevice::NewL( *this );

    iAdaptHw->InitializeL();

    CActiveScheduler::Add(this);

    RUBY_DEBUG1( "CRecognitionAlgMgr::ConstructL(): RecoHwDevice instance [%x]", iRecoHw );

    }

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

// CRecognitionAlgMgr::NewL

// Two-phased constructor.

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

//

CRecognitionAlgMgr* CRecognitionAlgMgr::NewL( MRecAlgMgrObserver& aObserver )

    {

    RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::ConstructL()" );

    CRecognitionAlgMgr* self = new ( ELeave ) CRecognitionAlgMgr( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CRecognitionAlgMgr::~CRecognitionAlgMgr

// Destructor

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

//

CRecognitionAlgMgr::~CRecognitionAlgMgr()

    {

    RUBY_DEBUG0( "CRecognitionAlgMgr::~CRecognitionAlgMgr()" );

    iSIActiveGrammars.Reset();

    iSIDeActivatedGrammars.Reset();

    iNBestList.Reset();

    iScores.Reset();

    if ( iRecoHw != NULL )

        {

        iRecoHw->Clear();

        delete iRecoHw;

        }

    if ( iAdaptHw != NULL )

        {

        iAdaptHw->Clear();

        delete iAdaptHw;

        }

    delete iCombinedGrammar;

    iBlackList.ResetAndDestroy();

    iBlackList.Close();

    delete iAdaptationData;

    }

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

// CRecognitionAlgMgr::AdaptModelsL

// Adapts models.

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

//

void CRecognitionAlgMgr::AdaptModelsL( const CSIResultSet& aResultSet, 

                                       TInt aResultIndex,

                                       TLanguage aLanguage )

    {

    RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::AdaptModelsL()" );

    RUBY_DEBUG1( "CRecognitionAlgMgr::AdaptModelsL aResultIndex: %x", aResultIndex );

    // TODO: Not too nice to remove consts like this

    CSIResult& iCorrectResult = ( CSIResult& ) aResultSet.AtL( aResultIndex );

    // Check that we have a modelbank to adapt

    if ( iSIModelBank == NULL )

        {

        User::Leave( KErrNotReady );

        }

    CSIResultSet& iResultSet = ( CSIResultSet& ) aResultSet;

    iAdaptHw->StartAdaptationL( iResultSet.AdaptationData(), 

                                *iSIModelBank, 

                                iCorrectResult.Pronunciation(),

                                aLanguage );

    }

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

// CRecognitionAlgMgr::InitFrontEnd

// Receives the initialize frontend request and starts an asynchronous handler

// for the request.

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

//

void CRecognitionAlgMgr::InitFrontEnd( TRecognizerMode aMode )

    {

    RUBY_DEBUG0( "CRecognitionAlgMgr::InitFrontEnd()" );

    // Save arguments and set code

    iMode = aMode;

    iRequestFunction = KInitFrontEnd;

    Ready( KErrNone );

    }

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

// CRecognitionAlgMgr::HandleInitFrontEnd

// Asynchronously handles the initialize frontend request. The front-end module

// is started as a result.

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

//

void CRecognitionAlgMgr::HandleInitFrontEnd()

    {

    RUBY_DEBUG0( "CRecognitionAlgMgr::HandleInitFrontEnd()" );

    if ( !iInitialized )

        {

        iRecAlgMgrObserver->InitFEComplete( KErrNotReady );

        return;

        }

    if ( iFEState != EIdle )

        {

        iRecAlgMgrObserver->InitFEComplete( KErrInUse );

        return;

        }

    if ( iMode != ESiRecognition && iMode != ESiRecognitionSpeechInput )

        {

        iRecAlgMgrObserver->InitFEComplete( KErrNotSupported );

        return;

        }

    TInt error = KErrNone;

    if ( iFeatures || iAdaptation )

        {

        TRAP( error, iRecoHw->InitRecognizerFEL( ETrue ) );

        }

    else

        {

        TRAP( error, iRecoHw->InitRecognizerFEL( EFalse ) );

        }

    iRecAlgMgrObserver->InitFEComplete( error );

    }

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

// CRecognitionAlgMgr::InitRecognizerBE

// Receives the initialize recognition backend request and starts an asynchronous

// handler for the request.

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

//

void CRecognitionAlgMgr::InitRecognizerBE( CSIResultSet& aResult )

    {

    RUBY_DEBUG0( "CRecognitionAlgMgr::InitRecognizerBE()" );

    // Save arguments and set code

    iSDResult = NULL;

    iSIResult = &aResult;

    iRequestFunction = KInitRecognizerBE;

    Ready( KErrNone );

    }

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

// CRecognitionAlgMgr::HandleInitRecognizerBE

// Asynchronously handles the initialize recognition backend request. The backend

// module for recognition function is started as a result.

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

//

void CRecognitionAlgMgr::HandleInitRecognizerBE()

    {

    RUBY_DEBUG0( "CRecognitionAlgMgr::HandleInitRecognizerBE()" );

    if ( !iInitialized )

        {

        iRecAlgMgrObserver->InitRecognizerBEComplete( KErrNotReady );

        return;

        }

    if ( iBEState != EIdle )

        {

        iRecAlgMgrObserver->InitRecognizerBEComplete( KErrInUse );

        return;

        }

    TInt error( KErrNone );

    if ( iSDResult )

        {

        iRecAlgMgrObserver->InitRecognizerBEComplete( KErrNotSupported );

        return;

        }

    else if ( iSIResult )

        {

        // Call RecoHwDevice

        if ( ( iSIActiveGrammars.Count() == 0 )  || ( iSIModelBank == NULL ) )

            {

            // Guess it is ok to leave with KErrNotReady if all necessary 

            iRecAlgMgrObserver->InitRecognizerBEComplete( KErrNotReady );

            return;

            }

        else

            {

            if ( iCombineNeeded )

                {

                delete iCombinedGrammar;

                iCombinedGrammar = NULL;

                TRAPD( error, iRecAlgMgrObserver->CombineGrammarL( iSIActiveGrammars, iBlackList ) );  

                if ( error != KErrNone )

                    {

                    iRecAlgMgrObserver->InitRecognizerBEComplete( error );

                    }

                // Wait for the callback from grammar compilation!

                return;

                }

            // Call reco HW device

            TRAP( error, iRecoHw->InitRecognizerBEL( iCombinedGrammar->Des(), *iSIModelBank ) );

            if ( error != KErrNone )

                {

                iRecAlgMgrObserver->InitRecognizerBEComplete( error );

                }

            }

        }

    else

        {

        error = KErrArgument;

        }

    if ( error == KErrNone )

        {

        iBEState = EProcessing;

        }

    }

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

// CRecognitionAlgMgr::LoadGrammarL

// Receives the load grammar request and start the asynchronous handler.

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

//

void CRecognitionAlgMgr::LoadGrammarL( const CSIGrammar& aGrammar )

    {

    RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::LoadGrammarL()" );

    if ( IsActive() )

        {

        // Callback before the request function returns

        User::Leave( KErrServerBusy );

        return;

        }

    // Save arguments and set code

    iSIGrammar = &aGrammar;

    iRequestFunction = KLoadGrammar;

    Ready( KErrNone );

    }

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

// CRecognitionAlgMgr::LoadGrammarL

// Receives the load grammar request and start the asynchronous handler.

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

//

void CRecognitionAlgMgr::LoadGrammarL( const CSICompiledGrammar& aGrammar )

    {

    RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::LoadGrammarL()" );

    if ( IsActive() )

        {

        // Callback before the request function returns

        User::Leave( KErrServerBusy );

        return;

        }

    // Save arguments and set code

    iSICompGrammar = &aGrammar; 

/*    __ASSERT_DEBUG( iSDGrammar == NULL, User::Panic( KPanicDescriptor, KErrCorrupt ) );

    __ASSERT_DEBUG( iSIGrammar == NULL, User::Panic( KPanicDescriptor, KErrCorrupt ) );*/

    iRequestFunction = KLoadGrammar;

    Ready( KErrNone );

    }

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

// CRecognitionAlgMgr::HandleLoadGrammar

// Asynchronous handler for Load Grammar request.

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

//

void CRecognitionAlgMgr::HandleLoadGrammar()

    {

    RUBY_DEBUG0( "CRecognitionAlgMgr::HandleLoadGrammar()" );

    TInt error( KErrNone );

    if ( !iInitialized )

        {

        iRecAlgMgrObserver->LoadGrammarComplete( KErrNotReady );

        return;

        }

    if ( iSICompGrammar )

        {

        if ( iSICompGrammar->Count() < 1 )

            {

            iRecAlgMgrObserver->LoadGrammarComplete( KErrArgument );

            return;

            }

        error = iSIActiveGrammars.Append( iSICompGrammar );

        iSICompGrammar = NULL;

        // Mark that there is need to recombine grammars

        iCombineNeeded = ETrue;

        iRecAlgMgrObserver->LoadGrammarComplete( error );

        }

    else

        {

        iRecAlgMgrObserver->LoadGrammarComplete( KErrNotSupported );

        }

    }

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

// CRecognitionAlgMgr::UnloadGrammarL

// Receives the unload grammar request and start the asynchronous handler.

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

//

void CRecognitionAlgMgr::UnloadGrammarL( const CSIGrammar& aGrammar )

    {

    RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::UnloadGrammarL()" );

    if ( IsActive() )

        {

        // Callback before the request function returns

        User::Leave( KErrServerBusy );

        return;

        }

    // Save arguments and set code

    iSIGrammar = &aGrammar;

    iRequestFunction = KUnloadGrammar;

    Ready( KErrNone );

    }

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

// CRecognitionAlgMgr::UnloadGrammarL

// Receives the unload grammar request and start the asynchronous handler.

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

//

void CRecognitionAlgMgr::UnloadGrammarL( const CSICompiledGrammar& aGrammar )

    {

    RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::UnloadGrammarL()" );

    if ( IsActive() )

        {

        // Callback before the request function returns

        User::Leave( KErrServerBusy );

        return;

        }

    // Save arguments and set code

    iSICompGrammar = &aGrammar; 

    iRequestFunction = KUnloadGrammar;

    Ready( KErrNone );

    }

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

// CRecognitionAlgMgr::HandleUnloadGrammar

// Asynchronous handler for Load Grammar request.

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

//

void CRecognitionAlgMgr::HandleUnloadGrammar()

    {

    RUBY_DEBUG0( "CRecognitionAlgMgr::HandleUnloadGrammar()" );

    CSICompiledGrammar* siActiveGrammar = NULL;

    CSICompiledGrammar* siNonActiveGrammar = NULL;

    if ( !iInitialized )

        {

        iRecAlgMgrObserver->UnloadGrammarComplete( KErrNotReady );

        return;

        }

    if ( iSICompGrammar )

        {

        TRAPD( error, GetGrammarL( iSICompGrammar->GrammarID(), &siActiveGrammar, &siNonActiveGrammar ) ); // Leaves if not found

        if ( error != KErrNone )

            {

            iRecAlgMgrObserver->UnloadGrammarComplete( error ); 

            return;

            }

        if ( siActiveGrammar )

            {

            // Remove grammar from active grammars

            iSIActiveGrammars.Remove( iSIActiveGrammars.Find( siActiveGrammar ) );

            // Mark that there is need to recombine grammars

            iCombineNeeded = ETrue;

            }

        else if ( siNonActiveGrammar )

            {

            // Remove grammar from deactive

            iSIActiveGrammars.Remove( iSIActiveGrammars.Find( siActiveGrammar ) );

            // No need to set recombination flag

            }

        else

            {

            iRecAlgMgrObserver->UnloadGrammarComplete( KErrNotFound ); 

            return;

            }

        }

    else

        {

        iRecAlgMgrObserver->UnloadGrammarComplete( KErrNotSupported );

        return;

        }

    iRecAlgMgrObserver->UnloadGrammarComplete( KErrNone );

    }

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

// CRecognitionAlgMgr::GetGrammarL

// Find grammar based on identifier

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

//

void CRecognitionAlgMgr::GetGrammarL( const TSIGrammarID aGrammarID,