/*

* 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>

// 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

      	{

       	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];