diff -r a36b1e19a461 -r 989d2f495d90 serviceproviders/sapi_sensor/src/sensorinterface.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/serviceproviders/sapi_sensor/src/sensorinterface.cpp Fri Jul 03 15:51:24 2009 +0100 @@ -0,0 +1,1115 @@ +/* +* Copyright (c) 2006-2007 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: Provides interface between the Liw FrameWork and Service Provider. +* +*/ + +//system include +#include +#include +#include +#include +#include + +// User Includes +#include "sensorservice.h" +#include "sensorinterface.h" +#include "sensorservice.hrh" +#include "sensorcallback.h" +#include "storeasyncinfo.h" + +inline void CSensorInterface::CheckInputTypeL + ( const TLiwVariant* aSource, + LIW::TVariantTypeId aExpectedtype, + const TDesC8* aErrorArgument ) + { + if( aSource->TypeId() != aExpectedtype ) + { + iErrorString = HBufC::NewL(KMaxMsgSize); + TPtr ptr(iErrorString->Des()); + TBuf buf; + buf.Copy( *aErrorArgument ); + ptr.Append(buf); + ptr.Append( KTypeErr.operator()()); + ptr.Append( KInvalid.operator()()); + User::Leave( KErrArgument ); + } + } + +inline void CSensorInterface::MissingValueL( const TDesC8* aErrorArgument ) + { + iErrorString = HBufC::NewL(KMaxMsgSize); + TPtr ptr(iErrorString->Des()); + TBuf buf; + buf.Copy( *aErrorArgument ); + ptr.Append(buf); + ptr.Append( KMissing.operator()()); + User::Leave( SErrMissingArgument ); + } + + +/* +----------------------------------------------------------------------------- + CSensorInterface::CSensorInterface() + Description : Constructor + Return values : N/A +----------------------------------------------------------------------------- +*/ +CSensorInterface::CSensorInterface() + : iSensorService( NULL ) + { + } + +/* +----------------------------------------------------------------------------- + void CSensorInterface::ConstructL() + Description : Symbian 2nd phase constructor can leave. + Return values : N/A +----------------------------------------------------------------------------- +*/ +void CSensorInterface::ConstructL() + { + iSensorService = CSensorService::NewL(); + } + + +/* +----------------------------------------------------------------------------- + CSensorInterface::ExecuteServiceCommandL() + Description : This is called by the consumer with command to execute. + Return values : N/A +----------------------------------------------------------------------------- +*/ +void CSensorInterface::ExecuteServiceCommandL + ( const TDesC8& aCmdName, + const CLiwGenericParamList& aInParamList, + CLiwGenericParamList& aOutParamList, + TUint aCmdOptions, + MLiwNotifyCallback* aCallback ) + { + + aOutParamList.Reset(); + + TInt position = 0; + TInt32 transId = 0; + + // Start of FindSensorChannel + if ( (aCmdName.CompareF( KCmdFindChannel ) == 0) ) + { + if( aCallback ) + { + iErrorString = KErrSensorInvalidReq.operator()().Alloc(); + User::Leave( SErrInvalidServiceArgument ); + } + + TPtrC searchString; + const TLiwGenericParam* findString = NULL; + findString = aInParamList.FindFirst( position, KSearchCriterion ); + + if ( !findString ) + { + //Position based parsing + if( aInParamList.Count() != 0 ) + { + findString = &aInParamList[EParamIndex0]; + } + else + { + iErrorString = KErrFindSensorChannelMissingSearchCrit.operator()().Alloc(); + User::Leave( SErrMissingArgument ); + } + } + + TInt searchCriterion = 0; + + CheckInputTypeL( &findString->Value(), + LIW::EVariantTypeDesC, + KErrFindSensorChannelBadSrchType.operator&() ); + + // Retrieve channel search condition specified in input parameter list + findString->Value().Get( searchString ); + + if ( searchString == KAll ) + searchCriterion = EFindAll; + else if ( searchString == KAcclmtrAxis ) + searchCriterion = EFindAccelerometerXYZAxisData; + else if ( searchString == KAcclmtrDoubleTapping ) + searchCriterion = EFindAccelerometerDoubleTappingData; + else if ( searchString == KOrientation ) + searchCriterion = EFindOrientationData; + else if ( searchString == KRotation ) + searchCriterion = EFindRotationData; + else + { + iErrorString = KErrFindSensorChannelInvalidSrch.operator()().Alloc(); + User::Leave( SErrInvalidServiceArgument ); + } + + // channelInfoList will be populated by core class API + RSensrvChannelInfoList channelInfoList; + CleanupClosePushL( channelInfoList ); + + iSensorService->FindSensorChannelsL( searchCriterion , + channelInfoList ); + + // Create list instance + CLiwDefaultList* chnlList = CLiwDefaultList::NewL(); + CleanupStack::PushL( chnlList ); + // Obtain channel info list + + AppendChannelInfoL( channelInfoList ,chnlList ); + + // Appending result to the output parameter list + aOutParamList.AppendL( TLiwGenericParam( KReturnValue, + TLiwVariant( chnlList ) ) ); + + CleanupStack::Pop( chnlList ); + CleanupStack::PopAndDestroy( &channelInfoList ); + chnlList->DecRef(); + + }//end of FindSensorChannel + //Start of RegisterForNotification + else if ( ( aCmdName.CompareF( KCmdRegisterForNotification ) == 0 ) ) + { + + if( ( aCallback && ( KLiwOptASyncronous & aCmdOptions ) ) ) + { + + transId = aCallback->GetTransactionID(); + + TPtrC listeningStrPtr; + const TLiwGenericParam* listeningString = NULL; + const TLiwGenericParam* chnlInfoParam = NULL; + CStoreAsyncInfo* info = NULL; + TSensrvChannelInfo channelInfo; + + if( aInParamList.Count() < 2 ) + { + iErrorString = KErrRegNotEnoughParams.operator()().Alloc(); + User::Leave( SErrMissingArgument ); + } + + position = 0; + listeningString = aInParamList.FindFirst( position, KListeningType ); + position = 0; + chnlInfoParam = aInParamList.FindFirst( position, KChnlInfoMap ); + if( !listeningString ) + { + //position based parsing + listeningString = &aInParamList[EParamIndex0]; + if ( ( !listeningString ) ) + { + iErrorString = KErrRegNotifyMissingListening.operator()().Alloc(); + User::Leave( SErrMissingArgument ); + } + + chnlInfoParam = &aInParamList[EParamIndex1]; + if ( ( !chnlInfoParam ) ) + { + iErrorString = KErrMissingChnlMap.operator()().Alloc(); + User::Leave( SErrMissingArgument ); + } + } + + CheckInputTypeL( &listeningString->Value(), + LIW::EVariantTypeDesC, + KErrRegNotifyInvalidListeningType.operator&() ); + + CheckInputTypeL( &chnlInfoParam->Value(), + LIW::EVariantTypeMap, + KChnlInfoMap.operator&() ); + + // Retrieve Listening Type + listeningString->Value().Get( listeningStrPtr ); + + //Leave if there is no listening type or is invalid + if( listeningStrPtr != KChnlData ) + { + iErrorString = KErrRegNotifyInvalidListening.operator()().Alloc(); + User::Leave( SErrInvalidServiceArgument ); + } + + const CLiwMap* chnlInfoMap = ( chnlInfoParam->Value() ).AsMap(); + //Retrieve channel information from input List + GetChannelInfoL( channelInfo ,chnlInfoMap ); + + //Create CallBack + CSensorCallback* callBack = CSensorCallback::NewL( aCallback, + transId ); + CleanupStack::PushL( callBack ); + TAsyncType asyncType(EInvalid); + TInt notificationErr(0); + //Data notification + if ( listeningStrPtr == KChnlData ) + { + TRAP( notificationErr, iSensorService->GetDataNotificationL + ( channelInfo, + callBack ) ); + + if( notificationErr != KErrNone ) + { + iErrorString = KErrInvalidNotif.operator()().Alloc(); + User::Leave( KErrInUse ); + } + + asyncType = EData; + } + else + { + iErrorString = KErrRegNotifyInvalidListening.operator()().Alloc(); + User::Leave( SErrInvalidServiceArgument ); + } + + // Store information about this async call + info = CStoreAsyncInfo::NewL( asyncType, + transId, + callBack, + channelInfo.iChannelId ); + iAsyncInfo.Append( info ); + + //Appending trans id to the output parameter list + aOutParamList.AppendL( TLiwGenericParam( KTransactionId , + TLiwVariant ( ( TInt32 )transId ) ) ); + + CleanupStack::Pop( callBack ); + + } + else + { + iErrorString = KErrRegNotifyAsyncbit.operator()().Alloc(); + User::Leave( SErrMissingArgument ); + } + + }//End of RegisterForNotification + // Start of StopNotification + else if ( ( aCmdName.CompareF( KStopNotification ) == 0 ) ) + { + + if( aCallback ) + { + iErrorString = KErrSensorInvalidReq.operator()().Alloc(); + User::Leave( SErrInvalidServiceArgument ); + } + + if( ! ( KLiwOptCancel & aCmdOptions) ) + { + iErrorString = KErrStopNotifCancelBit.operator()().Alloc(); + User::Leave( SErrMissingArgument ); + } + + TInt32 transId = 0; + const TLiwGenericParam* transIdParam = NULL; + TAsyncType asyncType; + TUint chnlId = 0; + TInt asyncCount = 0; + CStoreAsyncInfo* info = NULL; + TInt i = 0; + TBool transFound = FALSE; + + position = 0; + transIdParam = aInParamList.FindFirst( position , KTransactionId ); + position = 0; + + if ( !transIdParam ) + { + if( aInParamList.Count() != 0 ) + { + transIdParam = &aInParamList[EParamIndex0]; + } + else + { + iErrorString = KErrStopNotifMissingTransId.operator()().Alloc(); + User::Leave( SErrMissingArgument ); + } + } + + CheckInputTypeL( &transIdParam->Value(), + LIW::EVariantTypeTInt32, + KTransactionId.operator&() ); + + // Obtain transaction id from input list + transIdParam->Value().Get( transId ); + + // Get count of async calls + asyncCount = iAsyncInfo.Count(); + + // Search within the async call list for the transaction ID + for( i = 0; i < asyncCount; i++ ) + { + info = iAsyncInfo[i]; + if( transId == ( info->iTransactionId ) ) + { + // Transaction id is found + transFound = TRUE; + break; + } + } + // If found then cancel the request for notification on service class + if( transFound ) + { + asyncType = info->iAsyncType; + chnlId = info->ichnlId; + + switch( asyncType ) + { + case EData: // To stop data notification + iSensorService->StopNotificationL( EStopData,chnlId ); + break; + } + + //Remove this from the store of async functions + iAsyncInfo.Remove( i ); + delete info->iCallback; + delete info; + info = NULL; + } + else + { + // Incorrect transaction id + iErrorString = KErrStopNotifInvalidTransId.operator()().Alloc(); + User::Leave( SErrInvalidServiceArgument ); + } + + }//End of command StopNotification + // Start of GetChannelProperty + else if ( ( aCmdName.CompareF( KCmdGetChnlProperty ) == 0 ) ) + { + + if( aCallback ) + { + iErrorString = KErrSensorInvalidReq.operator()().Alloc(); + User::Leave( SErrInvalidServiceArgument ); + } + + const TLiwGenericParam* channelParam = NULL; + const TLiwGenericParam* propertyIdParam= NULL; + //Retreive property id for filling output map + TSensrvPropertyId propertyId = 0; + TPtrC propertyIdStr; + + if( aInParamList.Count() < 2) + { + iErrorString = KErrRegNotEnoughParams.operator()().Alloc(); + User::Leave( SErrMissingArgument ); + } + + channelParam = aInParamList.FindFirst( position, KChnlInfoMap ); + position = 0; + propertyIdParam = aInParamList.FindFirst( position, KPropId ); + + if ( !channelParam ) + { + channelParam = &aInParamList[EParamIndex0]; + if ( !channelParam ) + { + iErrorString = KErrMissingChnlMap.operator()().Alloc(); + User::Leave( SErrMissingArgument ); + } + propertyIdParam = &aInParamList[EParamIndex1]; + if ( !propertyIdParam ) + { + iErrorString = KErrMissingPropId.operator()().Alloc(); + User::Leave( SErrMissingArgument ); + } + } + + // Obtain channel info from input map + CheckInputTypeL( &channelParam->Value(), + LIW::EVariantTypeMap, + KChnlInfoMap.operator&() ); + + CheckInputTypeL( &propertyIdParam->Value(), + LIW::EVariantTypeDesC, + KPropId.operator&() ); + + TSensrvChannelInfo channelInfo; + const CLiwMap* chnlInfoMap = ( channelParam->Value() ).AsMap(); + //Retreive Channel Info + GetChannelInfoL( channelInfo , chnlInfoMap ); + + propertyIdParam->Value().Get( propertyIdStr ); + propertyId = PropertyIdInfoL( propertyIdStr ); + + // Obtain property list from service class + RSensrvPropertyList propertyList; + CleanupClosePushL( propertyList ); + TRAPD( getPropErr, iSensorService->GetChannelPropertyL + ( channelInfo, + propertyList ) ); + + if( getPropErr != KErrNone ) + { + CleanupStack::PopAndDestroy( &propertyList ); + iErrorString = KErrInvalidChnlMap.operator()().Alloc(); + User::Leave(KErrArgument); + } + + // Create output map + CLiwDefaultMap* outMap = CLiwDefaultMap::NewL(); + CleanupStack::PushL( outMap ); + + // Append property from list to output map + TRAPD( findPropErr ,AppendPropertyToMapL( propertyList, + outMap, + propertyId ) ); + + if( findPropErr != KErrNone ) + { + iErrorString = KErrPropNotSupported.operator()().Alloc(); + CleanupStack::Pop( outMap ); + CleanupStack::PopAndDestroy( &propertyList ); + outMap->DecRef(); + User::Leave(KErrNotFound); + } + + //Appending result to the output parameter list + aOutParamList.AppendL( TLiwGenericParam( KReturnValue , + TLiwVariant( outMap ) ) ); + + CleanupStack::Pop( outMap ); + CleanupStack::PopAndDestroy( &propertyList ); + outMap->DecRef(); + + }//end of GetChannelProperty + else + { + iErrorString = KErrSensorInvalidCmd.operator()().Alloc(); + User::Leave( KErrNotSupported ); + } + } + +/* +----------------------------------------------------------------------------- + CSensorInterface* CSensorInterface::NewL() + Description : Two-phased constructor. + Return values : CSensorInterface object pointer + +----------------------------------------------------------------------------- +*/ +CSensorInterface* CSensorInterface::NewL() + { + CSensorInterface* self = new ( ELeave ) CSensorInterface(); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } +/* +----------------------------------------------------------------------------- + CSensorInterface::~CSensorInterface() + Description : Destructor, free allocated resources + Return values : N/A +----------------------------------------------------------------------------- +*/ +CSensorInterface::~CSensorInterface() + { + + TInt count = iAsyncInfo.Count(); + CStoreAsyncInfo* info = NULL; + + TAsyncType asyncType = EInvalid; + TInt stopErr; + TUint chnlId = 0; + + //Cleanup async info store + for( TInt i = 0; i< count; i++) + { + info = iAsyncInfo[i]; + if( info ) + { + asyncType = info->iAsyncType; + chnlId = info->ichnlId; + } + + switch( asyncType ) + { + case EData: // To stop data notification + { + if( iSensorService ) + { + TRAP( stopErr, + iSensorService->StopNotificationL( EStopData, + chnlId ) ); + } + break; + } + } + + if( info->iCallback ) + { + delete info->iCallback; + info->iCallback = NULL; + } + + + if( info ) + { + delete info; + info = NULL; + } + } + + iAsyncInfo.Reset(); + + if( iSensorService ) + delete iSensorService; + + if( iErrorString ) + delete iErrorString; + + } + +/* +----------------------------------------------------------------------------- + CSensorInterface::GetSapiErrorCode() + Description : Returns the Sapi Error Code. + Return values : SapiErrors +----------------------------------------------------------------------------- +*/ +SapiErrors CSensorInterface:: GetSapiErrorCode( TInt aError ) + { + SapiErrors sapiErr = SErrNone; + switch ( aError ) + { + case KErrArgument: + { + sapiErr = SErrBadArgumentType; + break; + } + case KErrNotSupported: + { + sapiErr = SErrServiceNotSupported; + break; + } + case KErrNone: + { + sapiErr= SErrNone; + break; + } + case KErrNotFound: + { + sapiErr= SErrNotFound; + break; + } + case SErrMissingArgument: + { + sapiErr = SErrMissingArgument; + break; + } + case SErrInvalidServiceArgument: + { + sapiErr = SErrInvalidServiceArgument; + break; + } + case KErrInUse: + { + sapiErr = SErrServiceInUse; + break; + } + } + return sapiErr; + } + +/* +----------------------------------------------------------------------------- + CSensorInterface::ExecuteCmdL() + Description : This is called by the consumer with command to execute. + Return values : N/A +----------------------------------------------------------------------------- +*/ +void CSensorInterface::ExecuteCmdL( const TDesC8& aCmdName, + const CLiwGenericParamList& aInParamList, + CLiwGenericParamList& aOutParamList, + TUint aCmdOptions, + MLiwNotifyCallback* aCallback ) + { + TRAPD( err, ExecuteServiceCommandL( aCmdName, + aInParamList, + aOutParamList, + aCmdOptions, + aCallback ) ); + if( err != KErrNone ) + { + + if( iErrorString ) + { + TBuf errorMessage; + errorMessage.Append( KMsgErr.operator()() ); + TBuf commandName; + commandName.Copy( aCmdName ); + errorMessage.Append( commandName ); + errorMessage.Append( KColon.operator()()); + errorMessage.Append( iErrorString->Des() ); + + aOutParamList.AppendL(TLiwGenericParam( KErrorMessage, + TLiwVariant( errorMessage ))); + } + } + + TInt32 returnCode = CSensorInterface::GetSapiErrorCode( err ); + aOutParamList.AppendL( TLiwGenericParam( KErrorCode, + TLiwVariant( ( TInt32 ) returnCode ) ) ); + + } + +/* +----------------------------------------------------------------------------- + CSensorInterface::Close() + Description : This is called by the consumer to delete the handle. + Return values : N/A +----------------------------------------------------------------------------- +*/ +void CSensorInterface::Close() + { + delete this; + } + +/* +----------------------------------------------------------------------------- + CSensorInterface::AppendChannelInfoL() + Description : Internal function used to append result of found sensor + channel to the outputlist + Return values : N/A +----------------------------------------------------------------------------- +*/ +void CSensorInterface::AppendChannelInfoL + ( const RSensrvChannelInfoList& aChannelInfoList, + CLiwDefaultList* aList) + { + // Obtain channel count + TInt channelCount = aChannelInfoList.Count(); + + for(TInt i = 0; i < channelCount; i++) + { + + TInt32 chnlType = (TInt32)aChannelInfoList[i].iChannelType; + + switch(chnlType) + { + case EFindAccelerometerXYZAxisData: + case EFindAccelerometerDoubleTappingData: + case EFindOrientationData: + case EFindRotationData: + { + // Map to be appended to the list + CLiwDefaultMap* chnlMap = CLiwDefaultMap::NewL() ; + CleanupStack::PushL( chnlMap ); + + //Retreive channel information + TInt32 chnlId = (TInt32)aChannelInfoList[i].iChannelId; + TInt32 contextType = aChannelInfoList[i].iContextType; + TInt32 quantity = aChannelInfoList[i].iQuantity; + TBuf8 location( aChannelInfoList[i].iLocation ); + TBuf8 vendorId( aChannelInfoList[i].iVendorId ); + TInt32 dataItemSize = aChannelInfoList[i].iDataItemSize; + TInt32 chnlDataTypeId = (TInt32)aChannelInfoList[i].iChannelDataTypeId; + + _LIT( KDummyLoc, "Unknown" ); + TBufC dummyLoc( KDummyLoc ); + TPtr location16 = dummyLoc.Des(); + CnvUtfConverter::ConvertToUnicodeFromUtf8( location16, location ); + + _LIT( KDummyVen, "Unknown" ); + TBufC dummyVen( KDummyVen ); + TPtr vendor16 = dummyVen.Des(); + CnvUtfConverter::ConvertToUnicodeFromUtf8( vendor16, vendorId ); + + // Insert channel info to the map + chnlMap->InsertL( KChnlId ,TLiwVariant( (TInt32)chnlId ) ); + chnlMap->InsertL( KContextType ,TLiwVariant( (TInt32)contextType ) ); + chnlMap->InsertL( KQuantity ,TLiwVariant( (TInt32)quantity ) ); + chnlMap->InsertL( KChannelType ,TLiwVariant( (TInt32)chnlType ) ); + chnlMap->InsertL( KLocation , TLiwVariant( location16 ) ); + chnlMap->InsertL( KVendorId , TLiwVariant( vendor16 ) ); + chnlMap->InsertL( KDataItemSize ,TLiwVariant( (TInt32)dataItemSize ) ); + chnlMap->InsertL( KChnlDataTypeId ,TLiwVariant( (TInt32)chnlDataTypeId ) ); + + //Append it to the list + aList->AppendL( TLiwVariant( chnlMap ) ); + CleanupStack::Pop( chnlMap ); + + //done with the map + chnlMap->DecRef(); + break; + } + default: + break; + + } + } + } + +/* +----------------------------------------------------------------------------- + CSensorInterface::AppendPropertyToMapL() + Description : Internal function used to append result of get property + to the output map + Return values : N/A +----------------------------------------------------------------------------- +*/ +void CSensorInterface::AppendPropertyToMapL + ( const RSensrvPropertyList& aPropertyList, + CLiwDefaultMap* aMap, + const TUint aPropertyId) + { + // Obtain property count + TInt propCount = aPropertyList.Count(); + + // If no properties listed then leave with error - Not found + if( propCount == 0 ) + { + User::Leave( KErrNotFound ); + } + + TInt i = 0; // Loop variable + TSensrvProperty tempProperty; // Property for copy from property list + TSensrvProperty tempProperty1;// Property for obtaining value in array + + TBool found = FALSE; + + TInt propType = 0; + TInt intVal; + TReal rValue; + TBuf8 bufValue; + TInt32 itemIndex; + + // Search within property list and fill output map + for ( i = 0; i < propCount; i++ ) + { + tempProperty = aPropertyList[i]; + + if( aPropertyId == ( tempProperty.GetPropertyId() ) ) + { + // Property has been found + found = TRUE; + TPtrC propertyStr = PropertyStrL( aPropertyId ); + aMap->InsertL( KPropId ,TLiwVariant( propertyStr ) ); + + // Obtain item index,property type and read only + itemIndex = tempProperty.PropertyItemIndex(); + propType = tempProperty.PropertyType(); + + // Insert item index,property type and read only into output map + aMap->InsertL( KPropertyDataType ,TLiwVariant( (TInt32) ( propType - 1 ) ) ); + aMap->InsertL( KItemIndex ,TLiwVariant( (TInt32) itemIndex ) ); + aMap->InsertL( KReadOnly ,TLiwVariant(1) ); + + // For single property,just fill the actual values + if( ESensrvSingleProperty == ( tempProperty.GetArrayIndex() ) ) + { + + // Obtain values for integer property + if( propType == ESensrvIntProperty ) + { + tempProperty.GetValue( intVal ); + aMap->InsertL( KPropertyValue ,TLiwVariant( (TInt32) intVal ) ); + } + // Obtain values for real property + else if( propType == ESensrvRealProperty ) + { + tempProperty.GetValue( rValue ); + aMap->InsertL( KPropertyValue ,TLiwVariant( rValue ) ); + } + // Obtain values for string property + else if( propType == ESensrvBufferProperty ) + { + tempProperty.GetValue( bufValue ); + _LIT( KDummyDesc, "Unknown" ); + TBufC dummyDesc( KDummyDesc ); + TPtr description16 = dummyDesc.Des(); + CnvUtfConverter::ConvertToUnicodeFromUtf8( description16, bufValue ); + + aMap->InsertL( KPropertyValue ,TLiwVariant( description16 ) ); + } + break; + } + // If array property then get values from the actual listed props + else if( ESensrvArrayPropertyInfo == ( tempProperty.GetArrayIndex() ) ) + { + // For integer property + if( propType == ESensrvIntProperty ) + { + TInt indexVal; + tempProperty.GetValue( indexVal ); + tempProperty1 = aPropertyList[ i + indexVal ]; + tempProperty1.GetValue( intVal ); + aMap->InsertL( KPropertyValue ,TLiwVariant( (TInt32) intVal ) ); + } + // For real property + else if( propType == ESensrvRealProperty ) + { + TReal indexVal; + tempProperty.GetValue( indexVal ); + tempProperty1 = aPropertyList[ i + indexVal ]; + tempProperty1.GetValue( rValue ); + aMap->InsertL( KPropertyValue ,TLiwVariant( rValue ) ); + } + break; + } + + } + else + continue; + } + + // If property not found then leave with error - not found + if( found == FALSE ) + { + User::Leave( KErrNotFound ); + } + + } + + +/* +----------------------------------------------------------------------------- + CSensorInterface::GetChannelInfoL() + Description : Internal function used to extract channel info from the + : Input + Return values : N/A +----------------------------------------------------------------------------- +*/ +void CSensorInterface::GetChannelInfoL( TSensrvChannelInfo& aChannelInfo, + const CLiwMap* aChnlInfoMap ) + { + TLiwVariant infoVariant; + + if( aChnlInfoMap->FindL( KChnlId , infoVariant ) ) + { + CheckInputTypeL( &infoVariant, + LIW::EVariantTypeTInt32, + KChnlId.operator&() ); + + aChannelInfo.iChannelId = infoVariant.AsTInt32(); + } + else + { + infoVariant.Reset(); + MissingValueL( KChnlId.operator&() ); + } + + if( aChnlInfoMap->FindL( KContextType , infoVariant ) ) + { + CheckInputTypeL( &infoVariant, + LIW::EVariantTypeTInt32, + KContextType.operator&() ); + + aChannelInfo.iContextType = infoVariant.AsTInt32(); + } + else + { + infoVariant.Reset(); + MissingValueL( KContextType.operator&() ); + } + + if( aChnlInfoMap->FindL( KQuantity , infoVariant ) ) + { + CheckInputTypeL( &infoVariant, + LIW::EVariantTypeTInt32, + KQuantity.operator&() ); + + aChannelInfo.iQuantity = infoVariant.AsTInt32(); + } + else + { + infoVariant.Reset(); + MissingValueL( KQuantity.operator&() ); + } + + if( aChnlInfoMap->FindL( KChannelType , infoVariant ) ) + { + CheckInputTypeL( &infoVariant, + LIW::EVariantTypeTInt32, + KChannelType.operator&() ); + + aChannelInfo.iChannelType = infoVariant.AsTInt32(); + } + else + { + infoVariant.Reset(); + MissingValueL( KChannelType.operator&() ); + } + + if( aChnlInfoMap->FindL( KLocation , infoVariant ) ) + { + CheckInputTypeL( &infoVariant, + LIW::EVariantTypeDesC, + KLocation.operator&() ); + + TPtrC location16 = infoVariant.AsDes(); + TBuf8 location8; + CnvUtfConverter::ConvertFromUnicodeToUtf8( location8, location16 ); + + aChannelInfo.iLocation = location8; + } + else + { + infoVariant.Reset(); + MissingValueL( KLocation.operator&() ); + } + + if( aChnlInfoMap->FindL( KVendorId , infoVariant ) ) + { + CheckInputTypeL( &infoVariant, + LIW::EVariantTypeDesC, + KVendorId.operator&() ); + + TPtrC vendorId16 = infoVariant.AsDes(); + TBuf8 vendorId8; + CnvUtfConverter::ConvertFromUnicodeToUtf8( vendorId8, vendorId16 ); + + aChannelInfo.iVendorId = vendorId8; + } + else + { + infoVariant.Reset(); + MissingValueL( KVendorId.operator&() ); + } + + if( aChnlInfoMap->FindL( KDataItemSize , infoVariant ) ) + { + CheckInputTypeL( &infoVariant, + LIW::EVariantTypeTInt32, + KDataItemSize.operator&() ); + + aChannelInfo.iDataItemSize = infoVariant.AsTInt32(); + } + else + { + infoVariant.Reset(); + MissingValueL( KDataItemSize.operator&() ); + } + + if( aChnlInfoMap->FindL( KChnlDataTypeId , infoVariant ) ) + { + CheckInputTypeL( &infoVariant, + LIW::EVariantTypeTInt32, + KChnlDataTypeId.operator&() ); + + aChannelInfo.iChannelDataTypeId = infoVariant.AsTInt32(); + } + else + { + infoVariant.Reset(); + MissingValueL( KChnlDataTypeId.operator&() ); + } + infoVariant.Reset(); + } + +/* +----------------------------------------------------------------------------- + CSensorInterface::PropertyStr() + Description : Internal function used to extract property string from + : the input property id + Return values : N/A +----------------------------------------------------------------------------- +*/ +TPtrC CSensorInterface::PropertyStrL( TSensrvPropertyId aPropertyId ) + { + + TPtrC ptr; + + switch( aPropertyId ) + { + case KSensrvPropIdDataRate: + ptr.Set( KDataRate ); + break; + + case KSensrvPropIdAvailability: + ptr.Set( KAvailability ); + break; + + case KSensrvPropIdMeasureRange: + ptr.Set( KMeasureRange ); + break; + + case KSensrvPropIdChannelDataFormat: + ptr.Set( KChannelDataFormat ); + break; + + case KSensrvPropIdChannelAccuracy: + ptr.Set( KChannelAccuracy ); + break; + + case KSensrvPropIdChannelScale: + ptr.Set( KChannelScale ); + break; + + case KSensrvPropIdScaledRange: + ptr.Set( KScaledRange ); + break; + + case KSensrvPropIdChannelUnit: + ptr.Set( KChannelUnit ); + break; + + case KSensrvSensorModel: + ptr.Set( KSensorModel ); + break; + + case KSensrvSensorConnectionType: + ptr.Set( KConnectionType ); + break; + + case KSensrvSensorDescription: + ptr.Set( KSensorDescription ); + break; + + default: + User::Leave( KErrNotSupported ); + } + return ptr; + } + +/* +----------------------------------------------------------------------------- + CSensorInterface::PropertyIdInfoL() + Description : Internal function used to extract property id info from + : the Input + Return values : N/A +----------------------------------------------------------------------------- +*/ +TSensrvPropertyId CSensorInterface::PropertyIdInfoL( const TDesC& aPropertyIdStr ) + { + TSensrvPropertyId propId = 0; + + if( aPropertyIdStr == KDataRate ) + propId = KSensrvPropIdDataRate; + else if( aPropertyIdStr == KAvailability ) + propId = KSensrvPropIdAvailability; + else if( aPropertyIdStr == KMeasureRange ) + propId = KSensrvPropIdMeasureRange; + else if( aPropertyIdStr == KChannelDataFormat ) + propId = KSensrvPropIdChannelDataFormat; + else if( aPropertyIdStr == KChannelAccuracy ) + propId = KSensrvPropIdChannelAccuracy; + else if( aPropertyIdStr == KChannelScale ) + propId = KSensrvPropIdChannelScale; + else if( aPropertyIdStr == KScaledRange ) + propId = KSensrvPropIdScaledRange; + else if( aPropertyIdStr == KChannelUnit ) + propId = KSensrvPropIdChannelUnit; + else if( aPropertyIdStr == KSensorModel ) + propId = KSensrvSensorModel; + else if( aPropertyIdStr == KConnectionType ) + propId = KSensrvSensorConnectionType; + else if( aPropertyIdStr == KSensorDescription ) + propId = KSensrvSensorDescription; + else + { + iErrorString = KErrPropInvalidPropId.operator()().Alloc(); + User::Leave( SErrInvalidServiceArgument ); + } + return propId; + }