/*
* 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 <liwvariant.h>
#include <liwgenericparam.h>
#include <liwcommon.h>
#include <sensrvchannelinfo.h>
#include <sensrvtypes.h>
#include<e32math.h>
// 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<KMaxKeySize> 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<KMaxKeySize> 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 if( ( aCmdName.CompareF( KCmdGetScaleFactor ) == 0 ) )
         {
         if( aCallback )
             {
             iErrorString = KErrSensorInvalidReq.operator()().Alloc();
             User::Leave( SErrInvalidServiceArgument );
             }
         const TLiwGenericParam* channelInfoParam = NULL;
         channelInfoParam = aInParamList.FindFirst( position, KChnlInfoMap );
         if ( !channelInfoParam )
                     {
                     //Position based parsing
                     if( aInParamList.Count() != 0 )
                         {
                         channelInfoParam =  &aInParamList[EParamIndex0];
                         }
                     else
                        {
                        iErrorString = KErrMissingChnlMap.operator()().Alloc();
                        User::Leave( SErrMissingArgument );
                        }
                     }
         CheckInputTypeL( &channelInfoParam->Value(),
                                  LIW::EVariantTypeMap,
                                  KChnlInfoMap.operator&() );
         
         TSensrvChannelInfo channelInfo;
         const CLiwMap* chnlInfoMap = ( channelInfoParam->Value() ).AsMap();
         //Retreive Channel Info
         GetChannelInfoL( channelInfo , chnlInfoMap );
         
         TSensrvProperty measureProperty;
         TSensrvProperty scaleProperty;
         TRAPD(anErr,iSensorService->GetScaleFactorL( channelInfo ,
                                                       measureProperty,scaleProperty ));
         
         if( anErr != KErrNone )
             {
             iErrorString = KErrInvalidChnlMap.operator()().Alloc();
             User::Leave(KErrArgument);
             }
         TReal scaleFactor ;
         TReal measureValue;
         TInt scaleValue;
         measureProperty.GetValue( measureValue );// 0 or 1
         scaleProperty.GetValue( scaleValue); // 8 or 12
         TReal outputValue;
         TInt errPow;
         errPow = Math::Pow(outputValue,2,scaleValue-1);
         if( errPow == KErrNone )
             {
             if( measureValue == 0 )
               {
               scaleFactor = (2*9.8)/outputValue;
               aOutParamList.AppendL( TLiwGenericParam( KReturnValue ,
                                                                TLiwVariant( scaleFactor ) ) );
               }
            else if(measureValue == 1)
               {
               scaleFactor = (8*9.8)/outputValue;
               aOutParamList.AppendL( TLiwGenericParam( KReturnValue ,
                                                                TLiwVariant( scaleFactor ) ) );
               }
            else
               {
               iErrorString = KErrInvalidMeasureRange.operator()().Alloc();
               User::Leave(KErrArgument);
               }
             }
         else
             {
             iErrorString = KErrInvalidPowValue.operator()().Alloc();
             User::Leave(KErrArgument);
             }
         
         }//end of GetScaleFactor
     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<KErrMessageLen> errorMessage;	
			errorMessage.Append( KMsgErr.operator()() );
			TBuf<KCmdLen> 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<KSensrvLocationLength> location( aChannelInfoList[i].iLocation );
		        TBuf8<KSensrvVendorIdLength> vendorId( aChannelInfoList[i].iVendorId );
		        TInt32 dataItemSize = aChannelInfoList[i].iDataItemSize;
		        TInt32 chnlDataTypeId = (TInt32)aChannelInfoList[i].iChannelDataTypeId;

				_LIT( KDummyLoc, "Unknown" );
				TBufC<KSensrvLocationLength> dummyLoc( KDummyLoc );
				TPtr location16 = dummyLoc.Des();
				CnvUtfConverter::ConvertToUnicodeFromUtf8( location16, location );

				_LIT( KDummyVen, "Unknown" );
				TBufC<KSensrvVendorIdLength> 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<KBufSize> 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<KSensrvLocationLength> 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<KSensrvLocationLength> 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<KSensrvVendorIdLength> 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;
    }
