/*
* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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:
*
*/
#include "serviceinterface.h"
// Including a copy of common constants for this compilation unit
#include "serviceregistryservice.hrh"
// Including utilities
#include "serviceregistryutilities.h"
#include "serviceregistryiterator.h"
#include<hal.h>
//constants for default and invalid versions
const TReal KUnSpMaxVersion = 0.0;
const TReal KDefaultMinVersion = 1.0;
//thread name
_LIT(KThreadName,"ListThread");
// -----------------------------------------------------------------------------
// CServiceInterface::NewLC
// Returns the instance of CServiceInterface.
// -----------------------------------------------------------------------------
//
CServiceInterface* CServiceInterface::NewL()
{
CServiceInterface* self = new(ELeave) CServiceInterface();
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(self);
return self;
}
// -----------------------------------------------------------------------------
// CServiceInterface::~CServiceInterface
// Destructor of class
// -----------------------------------------------------------------------------
//
CServiceInterface::~CServiceInterface()
{
Cancel();
iThread.Close();
delete iServiceHandler;
iServiceHandler = NULL;
delete iServiceName;
iServiceName = NULL;
delete iInterfaceName;
iInterfaceName = NULL;
}
void CServiceInterface :: RCriteriaArrayCleanup(TAny* aParam)
{
RCriteriaArray* ptr = reinterpret_cast<RCriteriaArray*>(aParam);
ptr->ResetAndDestroy();
delete ptr;
}
// -----------------------------------------------------------------------------
// CServiceInterface::ExecuteCmdL
// Request handler method of interface class
// -----------------------------------------------------------------------------
//
void CServiceInterface::ExecuteCmdL(const TDesC8& aCmdName,
const CLiwGenericParamList& aInParamList,
CLiwGenericParamList& aOutParamList,
TUint aCmdOptions ,
MLiwNotifyCallback* aCallBack)
{
TInt errCode(KErrNone);
// Process the command.
TRAP( errCode, ProcessCommandL(aCmdName,
aInParamList,
aOutParamList,
aCmdOptions,
aCallBack));
// Checking error code in here.
// If any error has been occurred then it is inserted into output list.
if(errCode != KErrNone)
{
TServiceRegistryUtilities utils;
TLiwVariant retErrCode;
retErrCode.Set(TInt32(utils.GetSapiErrorCode(errCode)));
TLiwGenericParam errTypeParam(KErrorCode, retErrCode);
aOutParamList.AppendL(errTypeParam);
}
}
// -----------------------------------------------------------------------------
// CServiceInterface::ExecuteServiceCommandL
// Request handler method of interface class
// -----------------------------------------------------------------------------
//
void CServiceInterface::ExecuteServiceCommandL(const TDesC8& aCmdName,
const CLiwGenericParamList& aInParamList,
CLiwGenericParamList& aOutParamList,
TUint aCmdOptions ,
MLiwNotifyCallback* aCallBack)
{
ExecuteCmdL(aCmdName,
aInParamList,
aOutParamList,
aCmdOptions,
aCallBack);
}
// -----------------------------------------------------------------------------
// CServiceInterface::ProcessCommandL
// Method that processes calls of interface class
// -----------------------------------------------------------------------------
//
void CServiceInterface::ProcessCommandL(const TDesC8& aCmdName,
const CLiwGenericParamList& aInParamList,
CLiwGenericParamList& aOutParamList,
TUint aCmdOptions ,
MLiwNotifyCallback* aCallBack)
{
TInt32 transactionID(aCallBack->GetTransactionID());
if(aCmdName.CompareF(KGetList) == 0)
{
// If requesting asynchronous service
if (aCmdOptions & KLiwOptASyncronous) // Asynchronous request
{
// Asynchronous request is supported
if (aCallBack) // Callback object must be passed
{
GetListL(aInParamList, aOutParamList, transactionID, aCallBack);
}
else
{
// Asynchronous request did not have callback object available
User::Leave(KErrArgument);
}
}
else
{
// Synchronous request
GetListL(aInParamList, aOutParamList, transactionID, aCallBack);
}
}//GetList
else if(aCmdName.CompareF(KCmdCancel) == 0)
{
// TServiceRegistryUtilities utility class instance
TServiceRegistryUtilities utils;
TInt32 transID(utils.ConvertInputInt32L(aInParamList,
KTransactionId));
if(KLiwOptCancel & aCmdOptions)
{
if(transID != iTransactionId)
{
User::Leave(KErrNotFound);
}
Cancel();
aOutParamList.AppendL(TLiwGenericParam(KErrorCode,
TLiwVariant((TInt32)SErrNone)));
}
else
{
User::Leave(KErrNotSupported);
}
}//Cancel
else
{
User::Leave(KErrNotSupported);//Command is not supported
}
// Sending transaction ID back to the client in case of an successful asynchronous call
if (aCallBack && aCmdOptions == KLiwOptASyncronous)
{
aOutParamList.AppendL(TLiwGenericParam(KTransactionId,
TLiwVariant((TInt32)transactionID)));
}
}
// -----------------------------------------------------------------------------
// CServiceInterface::CServiceInterface
// Constructor of class
// -----------------------------------------------------------------------------
//
CServiceInterface::CServiceInterface()
:CActive(EPriorityStandard),
iTransactionId(0),
iServiceName(NULL),
iInterfaceName(NULL),
iMinVersion(KUnSpMaxVersion),
iMaxVersion(KUnSpMaxVersion),
iInParamList(NULL),
iServiceHandler(NULL)
{
CActiveScheduler::Add(this);
}
// -----------------------------------------------------------------------------
// CServiceInterface::ConstructL
// Two-phased constructor of class
// -----------------------------------------------------------------------------
//
void CServiceInterface::ConstructL()
{
iServiceHandler = CLiwServiceHandler :: NewL();
iServiceName = KNullDesC8().Alloc();
iInterfaceName = KNullDesC8().Alloc();
}
// -----------------------------------------------------------------------------
// CServiceInterface::ListServiceProvidersL
// This class is called once the async request is complete
// It puts the iterator into the ouputlist and calls the HnadleNotifyL.
// -----------------------------------------------------------------------------
//
void CServiceInterface :: ListServiceProvidersL(TInt32 aError)
{
CLiwGenericParamList* eventParamList = CLiwGenericParamList::NewL();
CleanupStack::PushL(eventParamList);
TInt event = KLiwEventError;
eventParamList->AppendL(TLiwGenericParam(KErrorCode,
TLiwVariant(aError)));
if(aError == KErrNone)
{
event = KLiwEventCompleted;
eventParamList->AppendL(TLiwGenericParam(KReturnValue,
TLiwVariant(iIterator)));
iIterator->DecRef();
}
TRAPD(err, iCallback->HandleNotifyL((TInt32)iTransactionId,
event,
*eventParamList,
*iInParamList));
//eventParamList->Reset();
CleanupStack::PopAndDestroy(eventParamList);
}
// -----------------------------------------------------------------------------
// This funtion runs as a part of the thread and fetches the list of providers
// creates the iterator to the list.
// -----------------------------------------------------------------------------
//
void GetListProviderL(CServiceInterface* aInterface)
{
CLiwMap* pMetaDataMap = NULL; // map with key as "range" and value as a List
CLiwList* pRangeList = NULL;
RCriteriaArray* interest = new(ELeave) RCriteriaArray;
RCriteriaArray* providerList = new(ELeave) RCriteriaArray;
CleanupStack::PushL(TCleanupItem(CServiceInterface::RCriteriaArrayCleanup, interest));
CleanupStack::PushL(TCleanupItem(CServiceInterface::RCriteriaArrayCleanup, providerList));
if(aInterface->iServiceName->CompareF(KNullDesC8) == 0)
{
delete aInterface->iServiceName;
aInterface->iServiceName = KWild().Alloc();
}
if(aInterface->iInterfaceName->CompareF(KNullDesC8) == 0)
{
delete aInterface->iInterfaceName;
aInterface->iInterfaceName = KWild().Alloc();
}
//To Query for a list of all the LIW providers present.
CLiwCriteriaItem* criteria = CLiwCriteriaItem::NewL(1,
*aInterface->iInterfaceName,
*aInterface->iServiceName);
//delete the member variables so that they cab be used again
// for the next call.
delete aInterface->iServiceName;
aInterface->iServiceName = KNullDesC8().Alloc();
delete aInterface->iInterfaceName;
aInterface->iInterfaceName = KNullDesC8().Alloc();
CleanupStack::PushL(criteria);
if(aInterface->iMinVersion != KUnSpMaxVersion || aInterface->iMaxVersion != KUnSpMaxVersion)
{
pMetaDataMap = CLiwDefaultMap::NewL(); // map with key as "range" and value as a List
CleanupStack::PushL(pMetaDataMap);
pRangeList = CLiwDefaultList::NewL(); // List where the values such as "ver" , minimum and maximum will be stored
CleanupStack::PushL(pRangeList);
pRangeList->AppendL(TLiwVariant(KVersion)); // "ver" is the string representing VERSION information in metadata
pRangeList->AppendL(TLiwVariant(aInterface->iMinVersion)); // minimum range - The service should contain version only above this
pRangeList->AppendL(TLiwVariant(aInterface->iMaxVersion)); // maximum range - The service should contain version only below this
pMetaDataMap->InsertL(KRange, pRangeList); // "range" is set as key and the value is the List created above
criteria->SetMetaDataOptions(pMetaDataMap);
pRangeList->DecRef(); // Decrementing the reference of the List
pMetaDataMap->DecRef(); // Decrementing the reference of the Map
CleanupStack::Pop(pRangeList);
CleanupStack::Pop(pMetaDataMap);
}
//reset the version members to unspecified.
aInterface->iMinVersion = KUnSpMaxVersion;
aInterface->iMaxVersion = KUnSpMaxVersion;
//Presently this value is changed to differentiate LIW Providers from other Ecom plug-ins.
criteria->SetServiceClass(TUid::Uid(KLiwClassBase));
interest->AppendL(criteria);
CleanupStack::Pop(criteria);
aInterface->iServiceHandler->QueryImplementationL(*interest, *providerList);
aInterface->iIterator = CSvcRegIterator :: NewL();
aInterface->iIterator->SetProviderDataList(providerList);
CleanupStack::Pop(providerList);
CleanupStack::PopAndDestroy(interest);
}
// -----------------------------------------------------------------------------
// Thread Function which calls the GetListProviderL
// -----------------------------------------------------------------------------
//
TInt ThreadListProvider(TAny* aData)
{
CTrapCleanup* cleanup=CTrapCleanup::New(); // get clean-up stack
CServiceInterface* svcifc = reinterpret_cast<CServiceInterface*> (aData);
TRAPD(err, GetListProviderL(svcifc));
delete cleanup;
User::Exit(err);
return 0;
}
// -----------------------------------------------------------------------------
// CServiceInterface::GetListL
// Gets the list of ServiceProviders.
// -----------------------------------------------------------------------------
//
void CServiceInterface::GetListL(const CLiwGenericParamList& aInParamList,
CLiwGenericParamList& aOutParamList,
TInt32 aTransactionId,
MLiwNotifyCallback* aCallBack)
{
TInt pos = 0;
TLiwVariant minver;
TLiwVariant maxver;
TLiwVariant serviceName;
TLiwVariant interfaceName;
const CLiwMap* pMap = NULL;
const TLiwGenericParam* paramFilterMap = NULL;
iCallback = aCallBack;
iTransactionId = aTransactionId;
paramFilterMap = aInParamList.FindFirst(pos, KParamFilter);
if(paramFilterMap)
{
pMap = paramFilterMap->Value().AsMap();
if(pMap)
{
if( pMap->FindL(KServiceName, serviceName))
{
if ( serviceName.TypeId() != LIW::EVariantTypeDesC )
{
serviceName.Reset();
User::Leave( KErrArgument );
}
delete iServiceName;
iServiceName = NULL;
iServiceName = HBufC8::NewL(serviceName.AsDes().Length());
iServiceName->Des().Copy(serviceName.AsDes());
}
if( pMap->FindL(KInterfaceName, interfaceName))
{
if ( interfaceName.TypeId() != LIW::EVariantTypeDesC )
{
serviceName.Reset();
interfaceName.Reset();
User::Leave( KErrArgument );
}
delete iInterfaceName;
iInterfaceName = NULL;
iInterfaceName = HBufC8::NewL(interfaceName.AsDes().Length());
iInterfaceName->Des().Copy(interfaceName.AsDes());
}
if( pMap->FindL(KMinVersion, minver))
{
if ( minver.TypeId() != LIW::EVariantTypeTReal && minver.TypeId() != LIW::EVariantTypeTInt32)
{
minver.Reset();
serviceName.Reset();
interfaceName.Reset();
User::Leave( KErrArgument );
}
iMinVersion = minver.AsTReal();
}
if( pMap->FindL(KMaxVersion, maxver))
{
if ( maxver.TypeId() != LIW::EVariantTypeTReal && maxver.TypeId() != LIW::EVariantTypeTInt32 )
{
minver.Reset();
maxver.Reset();
serviceName.Reset();
interfaceName.Reset();
User::Leave( KErrArgument );
}
iMaxVersion = maxver.AsTReal();
//set the min version to default only if max version is specified.
if(iMinVersion == KUnSpMaxVersion)
iMinVersion = KDefaultMinVersion;
}
if(iMaxVersion != KUnSpMaxVersion)
{
if(iMaxVersion < iMinVersion)
{
minver.Reset();
maxver.Reset();
serviceName.Reset();
interfaceName.Reset();
User::Leave(KErrArgument);
}
}
}
else
{
minver.Reset();
maxver.Reset();
serviceName.Reset();
interfaceName.Reset();
User::Leave(KErrArgument);
}
}
minver.Reset();
maxver.Reset();
serviceName.Reset();
interfaceName.Reset();
if(aCallBack)
{
if(!IsActive())
{
User::LeaveIfError(iThread.Create(KThreadName,
ThreadListProvider,
KDefaultStackSize,
&User::Allocator(),
this));
}
else
{
User::Leave(KErrInUse);
}
iStatus = KRequestPending;
SetActive();
iThread.Resume();
iThread.Logon(iStatus);
// append the error code to the outputlist.
aOutParamList.AppendL(TLiwGenericParam(KErrorCode,
TLiwVariant(TInt32(SErrNone))));
}
else
{
GetListProviderL(this);
aOutParamList.AppendL(TLiwGenericParam(KErrorCode,
TLiwVariant(TInt32(SErrNone))));
aOutParamList.AppendL(TLiwGenericParam(KReturnValue,
TLiwVariant(iIterator)));
iIterator->DecRef();
iIterator = NULL;
}
}
void CServiceInterface :: DoCancel()
{
iThread.Kill(KErrNone);
iThread.Close();
}
void CServiceInterface :: RunL()
{
iThread.Close();
ListServiceProvidersL(iStatus.Int());
}