/*

* Copyright (c) 2007-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:   ?Description

*

*/

#include <xmlengdom.h>

#include <liwservicehandler.h>

#include "hnservicehandler.h"

#include "hnliwutils.h"

#include "hnglobals.h"

#include "hnmdbasekey.h"

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

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

//

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

//

void CHnServiceHandler::ConstructL(

        const TDesC8& aService, const TDesC8& aInterface,

        const TDesC8& aCommand,

        CLiwGenericParamList* aConstructor,

        CLiwGenericParamList* aServiceCommand )

    {

    iServiceName.CreateL( aService );

    iInterfaceName.CreateL( aInterface );

    iCommandName.CreateL( aCommand );

    iServiceHandler = CLiwServiceHandler::NewL();

    iInput = CLiwGenericParamList::NewL();

    iOutputForAS = CLiwGenericParamList::NewL();

    iServiceInterface = NULL;

    SetServiceInterfaceL( aConstructor );

    // Please note that by setting these two member variables

    // we take ownership of aConstructor and aServiceCommand.

    // No leaving functions may be called in ConstructL from

    // now on.

    iConstructor = aConstructor;

    iCommand = aServiceCommand;

    }

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

//

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

//

EXPORT_C CHnServiceHandler* CHnServiceHandler::NewL(

        const TDesC8& aService, const TDesC8& aInterface,

        const TDesC8& aCommand, TServiceMode aMode,

        CLiwGenericParamList* aConstructor,

        CLiwGenericParamList* aServiceCommand )

    {

    CHnServiceHandler* self = CHnServiceHandler::NewLC( aService, aInterface,

            aCommand, aMode,  aConstructor, aServiceCommand );

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

//

EXPORT_C CHnServiceHandler* CHnServiceHandler::NewLC(

        const TDesC8& aService, const TDesC8& aInterface,

        const TDesC8& aCommandName, TServiceMode aMode,

        CLiwGenericParamList* aConstructor,

        CLiwGenericParamList* aServiceCommand )

    {

    CHnServiceHandler* self =  new( ELeave ) CHnServiceHandler( aMode );

    CleanupStack::PushL( self );

    self->ConstructL( aService, aInterface, aCommandName, aConstructor,

            aServiceCommand );

    return self;

    }

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

//

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

//

CHnServiceHandler::CHnServiceHandler( TServiceMode aMode ) :

        iMode( aMode )

    {

    }

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

//

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

//

EXPORT_C CHnServiceHandler::~CHnServiceHandler()

    {

    iServiceName.Close();

    iInterfaceName.Close();

    iCommandName.Close();

    if ( iServiceInterface )

        {

        iServiceInterface->Close();

        }

    delete iInput;

    delete iConstructor;

    delete iCommand;

    delete iOutputForAS;

    if ( iServiceHandler )

        {

        iServiceHandler->Reset();

        delete iServiceHandler;

        }

    }

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

//

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

//

EXPORT_C TBool CHnServiceHandler::ServiceHandlerMatchesModel(

    const TDesC8& aService,

    const TDesC8& aInterface,

    const CLiwGenericParamList* aConstructor ) const

    {

    __ASSERT_DEBUG( aConstructor, User::Invariant() );

    TBool ret = ( aInterface == iInterfaceName && aService == iServiceName );

    if ( ret )

        {

        const TInt count = iConstructor->Count();

        ret = ( count == aConstructor->Count() );

        for ( TInt i = 0; ret && i < count; ++i )

            {

            ret = ( ( *iConstructor )[i] == ( *aConstructor )[i] );

            }

        }

    return ret;

    }

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

//

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

//

EXPORT_C void CHnServiceHandler::PrepareForNextExecutionL(

        const TDesC8& aCommand, TServiceMode aMode,

        CLiwGenericParamList* aServiceCommand )

    {

    __ASSERT_DEBUG( aServiceCommand && aServiceCommand != iCommand,

            User::Invariant() );

        { // braces for scope only

        RBuf8 copy;

        CleanupClosePushL( copy );

        copy.CreateL( aCommand );

        iCommandName.Swap( copy );

        CleanupStack::PopAndDestroy( &copy );

        }

    iMode = aMode;

    delete iCommand;

    iCommand = aServiceCommand;

    // Ownership of aServiceCommand has been taken. Do not add any piece of

    // code that could leave after this line.

    }

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

//

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

//

EXPORT_C TInt CHnServiceHandler::ExecuteL( MLiwNotifyCallback* aCallback,

        TInt aCmdOptions)

    {

    TInt err( KErrNotSupported );

    if( iServiceInterface )

        {

        err = KErrNotSupported;

        iOutputForAS->Reset();

        iInput->Reset();

        iInput->AppendL( *iCommand );

        switch( iMode )

            {

            case EServiceModeAsynchronous:

                {

                __ASSERT_DEBUG( aCallback , User::Panic( KMatrixPanic , 0 ) );

                TRAP(err, iServiceInterface->ExecuteCmdL(

                 iCommandName, *iInput, *iOutputForAS, aCmdOptions, aCallback ) );

                }

                break;

            case EServiceModeSynchronous:

                {

                TRAP(err, iServiceInterface->ExecuteCmdL(

                 iCommandName, *iInput, *iOutputForAS, aCmdOptions, NULL ) );

                }

                break;

            }

        }

    return err;

    }

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

//

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

//

EXPORT_C TInt CHnServiceHandler::ExecuteL(

        CLiwGenericParamList& aOutParamList, TRequestStatus& aStatus )

    {

    iClientStatus = &aStatus;

    (*iClientStatus) = KRequestPending;

    iOutputForAO = &aOutParamList;

    TInt err( KErrNotSupported );

    if( iServiceInterface )

        {

        err = KErrNone;

        iInput->Reset();

        iInput->AppendL( *iCommand );

        switch (iMode)

            {

            case EServiceModeAsynchronous:

                {

                TRAP(err, iServiceInterface->ExecuteCmdL(

                     iCommandName, *iInput, *iOutputForAO, 0, this ) );

                if ( err != KErrNone )

                	{

                	User::RequestComplete( iClientStatus, err );

                	}

                }

                break;

            case EServiceModeSynchronous:

                 {

                 TRAP(err, iServiceInterface->ExecuteCmdL(

                     iCommandName, *iInput, *iOutputForAO ) );

                 User::RequestComplete( iClientStatus, KErrNone );

                 }

                 break;

            default:

                break;

            }

        }

    else

    	{

    	// KErrNone ensures that CHnQueryResultCollector::HandleQueryResultsL()

    	// is called, empty results are added to list, and

    	// CHnMdItem::ResultsCollectedL doesn't get confused

    	User::RequestComplete( iClientStatus, KErrNone );

    	}

    return err;

    }

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

//

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

EXPORT_C TInt CHnServiceHandler::HandleNotifyL(

        TInt /*aCmdId*/,

        TInt /*aEventId*/,

        CLiwGenericParamList& aEventParamList,

        const CLiwGenericParamList& /*aInParamList*/ )

    {

    // reset

    if( iOutputForAO )

        {

        iOutputForAO->Reset();

        iOutputForAO->AppendL( aEventParamList );

        TLiwGenericParam param;

        TInt error(KErrNone);

        param.PushL();

        for (TInt i = 0; i < aEventParamList.Count(); i++)

            {

            if ( param.Name().Compare( KErrorCode8 ) == 0

            		&& param.Value().AsTInt32() == KSErrNoMemory )

            	{

            	error = KErrNoMemory;

            	break;

            	}

            }

        CleanupStack::PopAndDestroy(&param);

        User::RequestComplete( iClientStatus, error);

        }

    return KErrNone;

    }

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

//

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

TInt CHnServiceHandler::SetServiceInterfaceL(

        CLiwGenericParamList* aConstructor )

    {

    CLiwGenericParamList& inParam = iServiceHandler->InParamListL();

    CLiwGenericParamList& outParam = iServiceHandler->OutParamListL();

    CLiwCriteriaItem* critItem = CLiwCriteriaItem::NewLC( KLiwCmdAsStr,

        iInterfaceName, iServiceName );

    critItem->SetServiceClass( TUid::Uid( KLiwClassBase ) );

    RCriteriaArray critArr;

    CleanupClosePushL( critArr );

    critArr.AppendL( critItem );

    iServiceHandler->AttachL( critArr );

    inParam.AppendL( *aConstructor );

    iServiceHandler->ExecuteServiceCmdL( *critItem, inParam, outParam );

    CleanupStack::PopAndDestroy( &critArr );

    CleanupStack::PopAndDestroy( critItem );

    TInt pos( KErrNone );

    outParam.FindFirst( pos, iInterfaceName );

    if ( pos != KErrNotFound )

        {

        iServiceInterface = outParam[pos].Value().AsInterface();

        }

    return pos;

    }

// End of file