/*
* 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( © );
}
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(¶m);
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