/*

* Copyright (c) 2004-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:  This is the main implementation of the SI Controller Plugin.

*               Finite State Machine is implemented here.

*

*/

// INCLUDE FILES

#include <mmfcodec.h>

#include <nsssispeechrecognitiondatadevasr.h>

#include <badesca.h>

#include <mmfbase.h>

#include "sicontrollerplugin.h"

#include "sicontrollerplugininterface.h"

#include "sidatabase.h"

#include "siresourcehandler.h"

#include "asrplugindataloader.h"

#include "sigrammardb.h"

#include "silexicondb.h"

#include "simodelbankdb.h"

#include "rubydebug.h"

#ifdef __SINDE_TRAINING

#include "sindetraining.h"

#endif // __SINDE_TRAINING

// Package types for general & language specific TTP data

// CONSTANTS

// Message types used in RunL

//const TInt KAddPronunciation			= 1; // Commented out to remove "not referenced" warning

const TInt KAddRule						= 2;

const TInt KCreateGrammar				= 3;

const TInt KCreateLexicon				= 4;

const TInt KCreateModelBank				= 5;

const TInt KGetAllClientGrammarIDs		= 6;

const TInt KGetAllClientLexiconIDs		= 7;

const TInt KGetAllClientModelBankIDs	= 8;

const TInt KGetAllGrammarIDs			= 9;

const TInt KGetAllLexiconIDs			= 10;

const TInt KGetAllModelBankIDs			= 11;

const TInt KGetAllModelIDs				= 12;

const TInt KGetAllPronunciationIDs		= 13;

const TInt KGetAllRuleIDs				= 14;

const TInt KGetAvailableStorage			= 15;

const TInt KGetModelCount				= 16;

const TInt KGetRuleValidity				= 17;

const TInt KGetUtteranceDuration		= 18;

const TInt KLoadGrammar					= 19;

const TInt KLoadLexicon					= 20;

const TInt KLoadModels					= 21;

const TInt KPlayUtterance				= 22;

const TInt KRecognize					= 23;

const TInt KRecord						= 24;

const TInt KRemoveGrammar				= 25;

const TInt KRemoveLexicon				= 26;

const TInt KRemoveModelBank				= 27;

const TInt KRemoveModel					= 28;

const TInt KRemovePronunciation			= 29;

const TInt KRemoveRule					= 30;

const TInt KTrain						= 31;

const TInt KUnloadRule					= 32;

// SI only functionalities

const TInt KAdapt					= 33;

//const TInt KSIAddPronunciation				= 34; // Commented out to remove "not referenced" warning

const TInt KAddRuleVariant				= 35;

//const TInt KAddVoiceTag					= 36; // Commented out to remove "not referenced" warning

const TInt KAddVoiceTags				= 37;

const TInt KCreateRule					= 38;

//const TInt KSIRecognize					= 39; // Commented out to remove "not referenced" warning

const TInt KEndRecord					= 40;

const TInt KUnloadGrammar 				= 41;

//const TInt KUpdateGrammarAndLexicon 				= 42; // Commented out to remove "not referenced" warning

const TInt KGetPronunciationCount				= 43;

const TInt KGetRuleCount				= 44;

const TInt KRemoveRules					= 45;

//const TInt KAddSIPronunciation			= 43; // Commented out to remove "not referenced" warning

//const TInt KAddOneSIPronunciation	= 44; // Commented out to remove "not referenced" warning

#ifdef __SINDE_TRAINING

// SINDE voice tags creation

const TInt KAddSindeVoiceTags = 46;

//const TInt KAddSindeVoiceTag = 47; // Commented out to remove "not referenced" warning

#endif // __SINDE_TRAINING

const TInt KPreStartSampling = 48;

// Define this if SINDE lexicon optimization is on

#define __SIND_LEXICON_OPT

// Secure ID of voice commands application process

_LIT_SECURE_ID( KVoiceCommandsAppUid, 0x101f8555 );

// ============================= LOCAL FUNCTIONS ===============================

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

// Panic

// User panic when an unrecoverable error occurs.

// Returns: -

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

//

void Panic( TInt aPanicCode ) // Panic code

    {

    _LIT( KSDControllerPanicCategory, "SIControllerPlugin" );

    User::Panic( KSDControllerPanicCategory, aPanicCode );

    }

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

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

// CSIControllerPlugin::CSIControllerPlugin

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

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

//

CSIControllerPlugin::CSIControllerPlugin( CSIControllerPluginInterface& aControllerIf )

                                        : CActive( EPriorityLess ),

                                          iState( ESiPluginIdle ),

                                          iControllerIf( aControllerIf ),

                                          iClientRegistered( EFalse ),  

                                          iGrammarID( 0 ),

                                          iDataLoader( NULL )

    {

    RUBY_DEBUG0( "CSIControllerPlugin::CSIControllerPlugin" );

    }

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

// CSIControllerPlugin::ConstructL

// Symbian 2nd phase constructor can leave.

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

// 

void CSIControllerPlugin::ConstructL()

    {

    RUBY_DEBUG_BLOCK( "CSIControllerPlugin::ConstructL" );

    iResourceHandler = CSIResourceHandler::NewL();

    //  Data loader

    iDataLoader = CDataLoader::NewL( *(iResourceHandler->iDataFilenamePrefix), 

        *(iResourceHandler->iDataFilenameSeperator),

        *(iResourceHandler->iDataFilenamePostfix ) );

    TFileName dbFileName( *(iResourceHandler->iDbFileName ));

    // Database instances

    iSIDatabase = CSIDatabase::NewL( dbFileName );

    RDbNamedDatabase& database = iSIDatabase->SIDatabase();

    RDbs& dbSession = iSIDatabase->DbSession();

    TInt drive = iSIDatabase->DbDrive();

    iSIGrammarDB = CSIGrammarDB::NewL( database, dbSession, drive );

    iSILexiconDB = CSILexiconDB::NewL( database, dbSession, drive );

    iSIModelBankDB = CSIModelBankDB::NewL( database, dbSession, drive );

    iSIDatabase->BeginTransactionL();    

    if ( !( iSIDatabase->DoesLockTableExistL() ) )

        {

        iSIDatabase->CreateLockTableL();

        }

    // Need to create all 3 ID tables at single transaction

    // Create tables if they don't already exist    

    if ( !( iSIDatabase->DoesModelBankTableExistL() ) )

        { 

        iSIModelBankDB->CreateIDTableL();

        }

    if ( !( iSIDatabase->DoesLexiconTableExistL() ) )

        { 

        iSILexiconDB->CreateIDTableL();

        }

    if ( !( iSIDatabase->DoesGrammarTableExistL() ) )

        { 

        iSIGrammarDB->CreateIDTableL();

        }

    iSIDatabase->CommitChangesL( ETrue );

    iSITtpWordList = CSITtpWordList::NewL();

    iDevASR = CDevASR::NewL( *this );

    RUBY_DEBUG2( "[%d] CSIControllerPlugin::ConstructL - DevASR[%d]", this, iDevASR );

#ifdef __SINDE_TRAINING 		

    iSindeTrainer = CSindeTrainer::NewL( *iDevASR, iControllerIf, *this, 

                                         *iSIDatabase, *iSIGrammarDB, *iSILexiconDB );

#endif // __SINDE_TRAINING    

    // Add active object to active scheduler

    CActiveScheduler::Add( this );

    }

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

// CSIControllerPlugin::NewL

// Two-phased constructor.

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

//

CSIControllerPlugin* CSIControllerPlugin::NewL( CSIControllerPluginInterface& aControllerIf )

    {

    RUBY_DEBUG_BLOCK( "CSIControllerPlugin::NewL" );

    CSIControllerPlugin* self = new( ELeave ) CSIControllerPlugin( aControllerIf );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CSIControllerPlugin::~CSIControllerPlugin

// Destructor

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

//

CSIControllerPlugin::~CSIControllerPlugin()

    {

	RUBY_DEBUG0( "CSIControllerPlugin::~CSIControllerPlugin" );

    RThread().SetPriority( EPriorityNormal );

    Cancel();

    // if there is any outstanding request, cancel it.

    if ( iDevASR )

        {

        iDevASR->Cancel();

        }

    delete iDevASR;

    delete iResourceHandler;

    delete iSIGrammarDB;

    delete iSILexiconDB; // Handled by Grcompiler

    delete iSIModelBankDB;	

    delete iDataLoader;

    delete iSIDatabase;

    delete iSICompiledGrammarRecompile;

	iMaxNPronunsForWord.Close();

    delete iSITtpWordList;

#ifdef __SINDE_TRAINING 		

    delete iSindeTrainer;

#endif // __SINDE_TRAINING

    if ( iTrainArrays != NULL )

        {

        iTrainArrays->ResetAndDestroy();

        iTrainArrays->Close();

        delete iTrainArrays;

        }

    }

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

// CSIControllerPlugin::AddPronunciationL

// Calls the lexicon database handler to add a new pronunciation into the lexicon.

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

//

void CSIControllerPlugin::AddPronunciationL( TSILexiconID /*aLexiconID*/,

                                             TSIModelBankID /*aModelBankID*/,

                                             const TDesC8& /*aPronunciationPr*/,

                                             TSIPronunciationID& /*aPronunciationID*/ )

    {

    RUBY_DEBUG_BLOCK( "CSIControllerPlugin::AddPronunciationL 1" );

    User::Leave( KErrNotSupported );

    }

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

// CSIControllerPlugin::AddPronunciationL

// Calls the lexicon database handler to add a new pronunciation into the lexicon.

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

// 

void CSIControllerPlugin::AddPronunciationL( TSILexiconID /*aLexiconID*/,

                                             TSIModelBankID /*aModelBankID*/,

                                             TSIModelID /*aModelID*/, 

                                             TSIPronunciationID& /*aPronunciationID*/ )

    {

    RUBY_DEBUG_BLOCK( "CSIControllerPlugin::AddPronunciationL 2" );

    User::Leave( KErrNotSupported );	

    }

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

// CSIControllerPlugin::SDLexiconL

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

//   

#ifdef DEVASR_KEEP_SD

CSDLexicon* CSIControllerPlugin::SDLexiconL( TSILexiconID anID )

    {

    RUBY_DEBUG_BLOCK( "CSIControllerPlugin::SDLexiconL" );

    User::Leave( KErrNotSupported );

    return NULL;	

    }

#endif

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

// CSIControllerPlugin::AddRuleL

// Calls the grammar database handler to add a new rule into the grammar.

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

//

void CSIControllerPlugin::AddRuleL( TSIGrammarID aGrammarID,

                                    TSILexiconID aLexiconID,

                                    TSIPronunciationID aPronunciationID,

                                    TSIRuleID& aRuleID )

    {

    RUBY_DEBUG_BLOCK( "CSIControllerPlugin::AddRuleL" );

    if ( IsActive() )

        {

        User::Leave( KErrServerBusy );

        }

    iRequestFunction = KAddRule;

    iGrammarID = aGrammarID;

    iLexiconID = aLexiconID;

    iPronunciationID = aPronunciationID;

    iRuleIDPtr = &aRuleID;

    DoAsynch();

    }

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

// CSIControllerPlugin::HandleAddRule

// This is the asynchronous handle called from the CSIAsyncHandler object.

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

//

void CSIControllerPlugin::HandleAddRuleL( TSIGrammarID /*aGrammarID*/,

                                          TSILexiconID /*aLexiconID*/,

                                          TSIPronunciationID /*aPronunciationID*/,

                                          TSIRuleID& /*aRuleID*/ )

    {

    RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleAddRuleL" );

    User::Leave( KErrNotSupported ); 

    }

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

// CSIControllerPlugin::Cancel

// Cancels the current activity and returns the plugin to Idle state.

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

//

void CSIControllerPlugin::Cancel()

    {

    RUBY_DEBUG1( "CSIControllerPlugin::Cancel (State=%d)", iState );

    this->iSIDatabase->Rollback();

    switch ( iState )

        {

        case ESdPluginTrain:

            iDevASR->Cancel();

            TRAP_IGNORE( 

                iSIDatabase->BeginTransactionL();

                iSIModelBankDB->Reset();

                iSIDatabase->CommitChangesL( ETrue );

                ); // TRAP_IGNORE

            break;

        case ESiPluginRecognize:

            iDevASR->Cancel();

            iState = ESiPluginRecognize; 	

            break;

        case ESiPluginTrainText:

#ifdef __SINDE_TRAINING

        case ESiPluginTrainSinde:

#endif // __SINDE_TRAINING

            iDevASR->Cancel();

            iState = ESiPluginIdle; 	

            break;

        case ESiPluginPlay:

            iDevASR->Cancel();

            break;

        case ESiPluginIdle:

            // Nothing to cancel

            break;

        default:

            // Unknown state - should never be here

            break;

        }

    // Cancel the active object

    CActive::Cancel();

    }

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

// CSIControllerPlugin::CommitChangesL

// Commits (saves) all database changes since the last commit request.

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

//

void CSIControllerPlugin::CommitChangesL( TBool aCommit )

    {

    RUBY_DEBUG_BLOCK( "CSIControllerPlugin::CommitChangesL" );

    iSIDatabase->CommitChangesL( aCommit );

    }

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

// CSIControllerPlugin::CreateGrammarL

// Calls the grammar database handler to create a new grammar.

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

//

void CSIControllerPlugin::CreateGrammarL( TSIGrammarID& aGrammarID )

    {

    RUBY_DEBUG_BLOCK("CSIControllerPlugin::CreateGrammarL");

    if ( IsActive() )

        {

        User::Leave( KErrServerBusy );

        }

    iRequestFunction = KCreateGrammar;

    iGrammarIDPtr = &aGrammarID;

    DoAsynch();

    }

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

// CSIControllerPlugin::HandleCreateGrammarL

// This is the asynchronous handle called from the CSIAsyncHandler object.

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

//

void CSIControllerPlugin::HandleCreateGrammarL( TSIGrammarID& aGrammarID )

    {

    RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleCreateGrammarL" );

    if ( iClientRegistered )

        {

        iSIDatabase->BeginTransactionL();

        // update model banks if they are not valid anymore

        RArray<TSIModelBankID> modelBankIDs;

        CleanupClosePushL( modelBankIDs );

        iSIModelBankDB->GetAllClientModelBankIDsL( iClientUid, modelBankIDs );

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

            {

            iSIModelBankDB->UpdateModelBankIfInvalidL( modelBankIDs[i] );

            }

        CleanupStack::PopAndDestroy( &modelBankIDs );

        aGrammarID = iSIGrammarDB->CreateGrammarL(iClientUid);

        iSIDatabase->CommitChangesL( ETrue );

        }

    else

        {

        User::Leave( KErrAsrNotRegisted );

        }

    }

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

// CSIControllerPlugin::CreateLexiconL

// Calls the lexicon database handler to create a new lexicon.

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

//

void CSIControllerPlugin::CreateLexiconL( TSILexiconID& aLexiconID )

    {

    RUBY_DEBUG_BLOCK("CSIControllerPlugin::CreateLexiconL");

    if ( IsActive() )

        {

        User::Leave( KErrServerBusy );

        }

    iRequestFunction = KCreateLexicon;

    iLexiconIDPtr = &aLexiconID;

    DoAsynch();

    }

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

// CSIControllerPlugin::HandleCreateLexiconL

// This is the asynchronous handle called from the CSIAsyncHandler object.

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

//

void CSIControllerPlugin::HandleCreateLexiconL( TSILexiconID& aLexiconID )

    {

    RUBY_DEBUG_BLOCK("CSIControllerPlugin::HandleCreateLexiconL");

    if ( iClientRegistered )

        {

        iSIDatabase->BeginTransactionL();

        aLexiconID = iSILexiconDB->CreateLexiconL(iClientUid);

        iSIDatabase->CommitChangesL( ETrue );

        }

    else

        {

        User::Leave( KErrAsrNotRegisted );

        }

    }

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

// CSIControllerPlugin::CreateModelBankL

// Calls the model database handler to create a new model bank.

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

//

void CSIControllerPlugin::CreateModelBankL( TSIModelBankID& aModelBankID )

    {

    RUBY_DEBUG_BLOCK("CSIControllerPlugin::CreateModelBankL");

    if ( IsActive() )

        {

        User::Leave(KErrServerBusy);

        }

    iRequestFunction = KCreateModelBank;

    iModelBankIDPtr = &aModelBankID;

    DoAsynch();

    }

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

// CSIControllerPlugin::HandleCreateModelBankL

// This is the asynchronous handle called from the CSIAsyncHandler object.