/*
* 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 nssttsutility.dll
*
*/


// INCLUDE FILES
#include <e32std.h>
#include <nssttsutilitybase.h>
#include "rubydebug.h"
#include "nssvasttsutilitywrapper.h"

// CONSTANTS
// DLL name
_LIT( KUtilityFilename, "nssttsutility.dll" );
// CreateInstanceL function ordinal number
const TInt KFunctionOrdinal = 1;

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

// ---------------------------------------------------------
// CNssTtsUtilityWrapper::NewL
// Two-phased constructor
// ---------------------------------------------------------
//
CNssTtsUtilityWrapper* CNssTtsUtilityWrapper::NewL( MTtsClientUtilityObserver& aObserver,
                                                    TInt aPriority,
                                                    TMdaPriorityPreference aPref )
    {
    CNssTtsUtilityWrapper* self = new ( ELeave ) CNssTtsUtilityWrapper( 
                                                 aObserver, aPriority, aPref );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------
// CNssTtsUtilityWrapper::~CNssTtsUtilityWrapper
// Destructor
// ---------------------------------------------------------
//
CNssTtsUtilityWrapper::~CNssTtsUtilityWrapper()
    {
    RUBY_DEBUG0( "CNssTtsUtilityWrapper::~CNssTtsUtilityWrapper" );
    if ( IsActive() )
        {
        Cancel();
        }
    delete iUtility;
    // Close RLibrary handle    
    iLib.Close();
    }

// ---------------------------------------------------------
// CNssTtsUtilityWrapper::CNssTtsUtilityWrapper
// C++ constructor
// ---------------------------------------------------------
//
CNssTtsUtilityWrapper::CNssTtsUtilityWrapper( MTtsClientUtilityObserver& aObserver,
                                              TInt aPriority,
                                              TMdaPriorityPreference aPref ) :
                                              CActive( EPriorityStandard ),
                                              iObserver( aObserver ),
                                              iPriority( aPriority ),
                                              iPref( aPref )
    {
    // Nothing
    }

// ---------------------------------------------------------
// CNssTtsUtilityWrapper::ConstructL
// Second phase constructor
// ---------------------------------------------------------
//
void CNssTtsUtilityWrapper::ConstructL()
    {
    RUBY_DEBUG_BLOCK( "CNssTtsUtilityWrapper::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 = ( MTtsUtilityBase* ) entry();
    
    // Do the 2nd phase construction
    iUtility->CreateInstanceSecondPhaseL( *this );
    
    CActiveScheduler::Add( this );
    }

// ---------------------------------------------------------
// CNssTtsUtilityWrapper::AddStyleL
// Forwards call to TTS Utility
// ---------------------------------------------------------
//
TTtsStyleID CNssTtsUtilityWrapper::AddStyleL( const TTtsStyle& aStyle )
    {
    return iUtility->AddStyleL( aStyle );
    }
        
// ---------------------------------------------------------
// CNssTtsUtilityWrapper::OpenAndPlayParsedTextL
// Forwards call to TTS Utility
// ---------------------------------------------------------
//
void CNssTtsUtilityWrapper::OpenAndPlayParsedTextL( CTtsParsedText& aText, 
                                                    TInt /*aPriority*/, 
                                                    TMdaPriorityPreference /*aPref*/ )
    {
    iUtility->OpenAndPlayParsedTextL( aText );
    }
                                     
// ---------------------------------------------------------
// CNssTtsUtilityWrapper::Stop
// Forwards call to TTS Utility
// ---------------------------------------------------------
//
void CNssTtsUtilityWrapper::Stop()
    {
    iUtility->Stop();
    }
        
// ---------------------------------------------------------
// CNssTtsUtilityWrapper::Play
// Forwards call to TTS Utility
// ---------------------------------------------------------
//
void CNssTtsUtilityWrapper::Play()
    {
    iUtility->Play();
    }
        
// ---------------------------------------------------------
// CNssTtsUtilityWrapper::Close
// Forwards call to TTS Utility
// ---------------------------------------------------------
//
void CNssTtsUtilityWrapper::Close()
    {
    iUtility->Close();
    }

// ---------------------------------------------------------
// CNssTtsUtilityWrapper::MapcCustomCommandEvent
// Callback from TTS Utility
// ---------------------------------------------------------
//
void CNssTtsUtilityWrapper::MapcCustomCommandEvent( TInt /*aEvent*/, 
                                                    TInt /*aError*/ )
    {
    // Nothing
    }
	    
// ---------------------------------------------------------
// CNssTtsUtilityWrapper::MapcInitComplete
// Callback from TTS Utility
// ---------------------------------------------------------
//
void CNssTtsUtilityWrapper::MapcInitComplete( TInt aError, 
                                              const TTimeIntervalMicroSeconds& aDuration )
    {
    RUBY_DEBUG1( "CNssTtsUtilityWrapper::MapcInitComplete, aError[%d]", aError );    
    iError = aError;
    iDuration = aDuration;
    iState = EInitComplete;
    Ready();
    }
    
// ---------------------------------------------------------
// CNssTtsUtilityWrapper::MapcPlayComplete
// Callback from TTS Utility
// ---------------------------------------------------------
//
void CNssTtsUtilityWrapper::MapcPlayComplete( TInt aError )
    {
    RUBY_DEBUG1( "CNssTtsUtilityWrapper::MapcPlayComplete, aError[%d]", aError );       
    iError = aError;
    iState = EPlayComplete;
    Ready();
    }

// ---------------------------------------------------------
// CNssTtsUtilityWrapper::Ready
// Sets active object ready to be run
// ---------------------------------------------------------
//    
void CNssTtsUtilityWrapper::Ready()
    {
    if ( !IsActive() )
        {
        SetActive();
        TRequestStatus* stat = &iStatus;
        User::RequestComplete( stat, KErrNone );
        }
    }

// ---------------------------------------------------------
// CNssTtsUtilityWrapper::RunL
// From CActive
// ---------------------------------------------------------
//
void CNssTtsUtilityWrapper::RunL()
    {
    // Forwards callback to other parts of VAS    
    RUBY_DEBUG_BLOCK( "CNssTtsUtilityWrapper::RunL" );    
    switch ( iState )
        {
        case EInitComplete:
            iObserver.MapcInitComplete( iError, iDuration );
            break;
            
        case EPlayComplete:
            iObserver.MapcPlayComplete( iError );
            break;
            
        default:
            RUBY_ERROR1( "CNssTtsUtilityWrapper::RunL unexpected state %d", iState );
            break;
        }
    }
	    
// ---------------------------------------------------------
// CNssSiUtilityWrapper::DoCancel
// From CActive
// ---------------------------------------------------------
//
void CNssTtsUtilityWrapper::DoCancel()
    {
    // Nothing
    }    

// End of file