/*

* Copyright (c) 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:  Class which hides the dynamic loading of 

*               nsssispeechrecognitionutility.dll

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <nsssiutilitybase.h>

#include "rubydebug.h"

#include "nssvassiutilitywrapper.h"

// CONSTANTS

// DLL name

_LIT( KUtilityFilename, "nsssispeechrecognitionutility.dll" );

// CreateInstanceL function ordinal number

const TInt KFunctionOrdinal = 1;

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

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

// CNssSiUtilityWrapper::NewL

// Two-phased constructor

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

//

CNssSiUtilityWrapper* CNssSiUtilityWrapper::NewL( 

        MSISpeechRecognitionUtilityObserver& aObserver, TUid aClientUid )

    {

    CNssSiUtilityWrapper* self = new ( ELeave ) CNssSiUtilityWrapper( aObserver, aClientUid );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CNssSiUtilityWrapper::~CNssSiUtilityWrapper

// Destructor

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

//

CNssSiUtilityWrapper::~CNssSiUtilityWrapper()

    {

    RUBY_DEBUG0( "CNssSiUtilityWrapper::~CNssSiUtilityWrapper" );

    Cancel();

    delete iUtility;

    // Close RLibrary handle

    iLib.Close();

    }

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

// CNssSiUtilityWrapper::CNssSiUtilityWrapper

// C++ constructor

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

//

CNssSiUtilityWrapper::CNssSiUtilityWrapper( 

        MSISpeechRecognitionUtilityObserver& aObserver, TUid aClientUid ) : 

                                            CActive( EPriorityStandard ), 

                                            iClientUid( aClientUid ), 

                                            iObserver( aObserver )

    {

    // Nothing

    }

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

// CNssSiUtilityWrapper::ConstructL

// Second phase constructor

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

//

void CNssSiUtilityWrapper::ConstructL()

    {

    RUBY_DEBUG_BLOCK( "CNssSiUtilityWrapper::ConstructL" );

    // Load a DLL based on name with RLibrary

    User::LeaveIfError( iLib.Load( KUtilityFilename ) );

    // Find the TAny* CreateInstanceL() function

    TLibraryFunction entry = iLib.Lookup( KFunctionOrdinal );

    if ( !entry )

        {

        User::Leave( KErrNotFound );

        }    

    // Call CreateInstanceL  

    // Cannot use static_cast since entry() call returns TInt    

    iUtility = ( MSISpeechRecognitionUtilityBase* ) entry();

    // Do the 2nd phase construction

    iUtility->CreateInstanceSecondPhaseL( iClientUid, KNullUid, *this );

    CActiveScheduler::Add( this );

    }

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

// CNssSiUtilityWrapper::Adapt

// Forwards the call to Recognition Utility

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

//

TInt CNssSiUtilityWrapper::Adapt( const CSIClientResultSet& aResultSet,

                                  TInt aCorrect )

    {

    RUBY_DEBUG0( "CNssSiUtilityWrapper::Adapt" );

    return iUtility->Adapt( aResultSet, aCorrect );

    }

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

// CNssSiUtilityWrapper::AddVoiceTags

// Forwards the call to Recognition Utility

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

//

TInt CNssSiUtilityWrapper::AddVoiceTags( const RPointerArray<MDesCArray>& aTextArrayArray,

                                         const RArray<TLanguage>& aLanguageArray,

                                         TSILexiconID aLexiconID,

                                         TSIGrammarID aGrammarID, 

                                         RArray<TSIRuleID>& aRuleIDArray )

    {

    RUBY_DEBUG0( "CNssSiUtilityWrapper::AddVoiceTags" );

    return iUtility->AddVoiceTags( aTextArrayArray, aLanguageArray, 

                                   aLexiconID, aGrammarID, aRuleIDArray );

    }

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

// CNssSiUtilityWrapper::AddVoiceTags

// Forwards the call to Recognition Utility

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

//

TInt CNssSiUtilityWrapper::AddVoiceTags( const RPointerArray<MDesCArray>& aTextArrayArray,

                                         const RArray<RLanguageArray>& aLanguageArray,

                                         TSILexiconID aLexiconID,

                                         TSIGrammarID aGrammarID, 

                                         RArray<TSIRuleID>& aRuleIDArray )

    {

    RUBY_DEBUG0( "CNssSiUtilityWrapper::AddVoiceTags" );

    return iUtility->AddVoiceTags( aTextArrayArray, aLanguageArray, 

                                   aLexiconID, aGrammarID, aRuleIDArray );

    }

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

// CNssSiUtilityWrapper::CancelUtility

// Forwards the call to Recognition Utility

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

//

void CNssSiUtilityWrapper::CancelUtility()

    {

    RUBY_DEBUG0( "CNssSiUtilityWrapper::Cancel" );

    return iUtility->Cancel();

    }

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

// CNssSiUtilityWrapper::CommitChanges

// Forwards the call to Recognition Utility

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

//

TInt CNssSiUtilityWrapper::CommitChanges()

    {

    RUBY_DEBUG0( "CNssSiUtilityWrapper::CommitChanges" );

    return iUtility->CommitChanges();

    }

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

// CNssSiUtilityWrapper::CreateGrammar

// Forwards the call to Recognition Utility

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

//

TInt CNssSiUtilityWrapper::CreateGrammar( TSIGrammarID& aGrammarID )

    {

    RUBY_DEBUG0( "CNssSiUtilityWrapper::CreateGrammar" );

    return iUtility->CreateGrammar( aGrammarID );

    }

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

// CNssSiUtilityWrapper::CreateLexicon

// Forwards the call to Recognition Utility

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

//

TInt CNssSiUtilityWrapper::CreateLexicon( TSILexiconID& aLexiconID )

    {

    RUBY_DEBUG0( "CNssSiUtilityWrapper::CreateLexicon" );

    return iUtility->CreateLexicon( aLexiconID );

    }

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

// CNssSiUtilityWrapper::CreateModelBank

// Forwards the call to Recognition Utility

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

//

TInt CNssSiUtilityWrapper::CreateModelBank( TSIModelBankID& aModelBankID )

    {

    RUBY_DEBUG0( "CNssSiUtilityWrapper::CreateModelBank" );

    return iUtility->CreateModelBank( aModelBankID );

    }

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

// CNssSiUtilityWrapper::EndRecSession

// Forwards the call to Recognition Utility

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

//

TInt CNssSiUtilityWrapper::EndRecSession()

    {

    RUBY_DEBUG0( "CNssSiUtilityWrapper::EndRecSession" );

    return iUtility->EndRecSession();

    }

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

// CNssSiUtilityWrapper::LoadGrammar

// Forwards the call to Recognition Utility

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

//

TInt CNssSiUtilityWrapper::LoadGrammar( TSIGrammarID aGrammarID )

    {

    RUBY_DEBUG0( "CNssSiUtilityWrapper::LoadGrammar" );

    return iUtility->LoadGrammar( aGrammarID );

    }

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

// CNssSiUtilityWrapper::LoadModels

// Forwards the call to Recognition Utility

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

//

TInt CNssSiUtilityWrapper::LoadModels( TSIModelBankID aModelBankID )

    {

    RUBY_DEBUG0( "CNssSiUtilityWrapper::LoadModels" );

    return iUtility->LoadModels( aModelBankID );

    }

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

// CNssSiUtilityWrapper::Record

// Forwards the call to Recognition Utility

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

//

TInt CNssSiUtilityWrapper::Record( TTimeIntervalMicroSeconds32 aRecordTime )

    {

    RUBY_DEBUG0( "CNssSiUtilityWrapper::Record" );

    return iUtility->Record( aRecordTime );

    }

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

// CNssSiUtilityWrapper::PreStartSampling

// Forwards the call to Recognition Utility

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

//

TInt CNssSiUtilityWrapper::PreStartSampling()

    {

    RUBY_DEBUG0( "" );

    return iUtility->PreStartSampling();

    }

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

// CNssSiUtilityWrapper::Recognize

// Forwards the call to Recognition Utility

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

//

TInt CNssSiUtilityWrapper::Recognize( CSIClientResultSet& aResultSet )

    {

    RUBY_DEBUG0( "CNssSiUtilityWrapper::Recognize" );    

    return iUtility->Recognize( aResultSet ); 

    }

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

// CNssSiUtilityWrapper::RemoveGrammar

// Forwards the call to Recognition Utility

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

//

TInt CNssSiUtilityWrapper::RemoveGrammar( TSIGrammarID aGrammarID )

    {

    RUBY_DEBUG0( "CNssSiUtilityWrapper::RemoveGrammar" );   

    return iUtility->RemoveGrammar( aGrammarID );

    }

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

// CNssSiUtilityWrapper::RemoveLexicon

// Forwards the call to Recognition Utility

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

//

TInt CNssSiUtilityWrapper::RemoveLexicon( TSILexiconID aLexiconID )

    {

    RUBY_DEBUG0( "CNssSiUtilityWrapper::RemoveLexicon" );  

    return iUtility->RemoveLexicon( aLexiconID );

    }

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

// CNssSiUtilityWrapper::RemoveModelBank

// Forwards the call to Recognition Utility

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

//

TInt CNssSiUtilityWrapper::RemoveModelBank( TSIModelBankID aModelBankID )

    {

    RUBY_DEBUG0( "CNssSiUtilityWrapper::RemoveModelBank" );      

    return iUtility->RemoveModelBank( aModelBankID );

    }

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

// CNssSiUtilityWrapper::RemoveRule

// Forwards the call to Recognition Utility

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

//

TInt CNssSiUtilityWrapper::RemoveRule( TSIGrammarID aGrammarID, TSIRuleID aRuleID )

    {

    RUBY_DEBUG0( "CNssSiUtilityWrapper::RemoveRule" );  

    return iUtility->RemoveRule( aGrammarID, aRuleID );

    }

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

// CNssSiUtilityWrapper::RemoveRules

// Forwards the call to Recognition Utility

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

//

TInt CNssSiUtilityWrapper::RemoveRules( TSIGrammarID aGrammarID, RArray<TSIRuleID>& aRuleIDs )

    {

    RUBY_DEBUG0( "CNssSiUtilityWrapper::RemoveRules" );

    return iUtility->RemoveRules( aGrammarID, aRuleIDs );

    }

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

// CNssSiUtilityWrapper::SetAudioPriority

// Forwards the call to Recognition Utility

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

//

TInt CNssSiUtilityWrapper::SetAudioPriority( TInt aPriority, TInt aTrainPreference, 

                        TInt aPlaybackPreference, TInt aRecognitionPreference )

    {

    RUBY_DEBUG0( "CNssSiUtilityWrapper::SetAudioPriority" );

    return iUtility->SetAudioPriority( aPriority, aTrainPreference, 

                                aPlaybackPreference, aRecognitionPreference );

    }

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

// CNssSiUtilityWrapper::SetEventHandler

// Forwards the call to Recognition Utility

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

//

void CNssSiUtilityWrapper::SetEventHandler( MSISpeechRecognitionUtilityObserver*

                                            aSpeechRecognitionUtilityObserver )

    {

    iObserver = *aSpeechRecognitionUtilityObserver;

    }

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

// CNssSiUtilityWrapper::StartRecSession

// Forwards the call to Recognition Utility

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

//

TInt CNssSiUtilityWrapper::StartRecSession( TNSSRecognitionMode aMode )

    {

    RUBY_DEBUG0( "CNssSiUtilityWrapper::StartRecSession" );

    return iUtility->StartRecSession( aMode );

    }

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

// CNssSiUtilityWrapper::UnloadRule

// Forwards the call to Recognition Utility

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

//

TInt CNssSiUtilityWrapper::UnloadRule( TSIGrammarID aGrammarID, TSIRuleID aRuleID )

    {

    RUBY_DEBUG0( "CNssSiUtilityWrapper::UnloadRule" );

    return iUtility->UnloadRule( aGrammarID, aRuleID );

    }

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

// CNssSiUtilityWrapper::MsruoEvent

// Callback from SI Utility

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

//

void CNssSiUtilityWrapper::MsruoEvent( TUid aEvent, TInt aResult )

    {

    RUBY_DEBUG2( "CNssSiUtilityWrapper::MsruoEvent, event[%d], result[%d]", aEvent, aResult );

    iEvent = aEvent;

    iResult = aResult;

    Ready();

    }

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

// CNssSiUtilityWrapper::Ready

// Sets active object ready to be run

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

//

void CNssSiUtilityWrapper::Ready()

    {

    if ( !IsActive() )

        {

        SetActive();

        TRequestStatus* stat = &iStatus;

        User::RequestComplete( stat, KErrNone );

        }

    }

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

// CNssSiUtilityWrapper::RunL

// From CActive

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

//

void CNssSiUtilityWrapper::RunL()

    {

    // Forwards callback to other parts of VAS

    RUBY_DEBUG2( "CNssSiUtilityWrapper::RunL calling callback function, event[%d], result[%d]", iEvent, iResult );

    iObserver.MsruoEvent( iEvent, iResult );

    RUBY_DEBUG0( "CNssSiUtilityWrapper::RunL callback called" );

    }

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

// CNssSiUtilityWrapper::DoCancel

// From CActive

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

//

void CNssSiUtilityWrapper::DoCancel()

    {

    // Nothing

    }

// End of file