/*

* 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:  implements interface class for location sapi

*

*/

#include <e32base.h>

#include <LiwCommon.h>

#include <lbs.h>

#include <LbsRequestor.h>

#include <lbscommon.h>

#include <lbssatellite.h>

#include "locationinterface.h"

#include "locationcb.h"

#include "locationservice.h"

#include "locationerrormessage.hrh"

using namespace LIW;

/**

 * KMAXACTIVEOBJ identifies maximum number of entries in callback registration table

 * presently it stores only two entries .

 */

const TInt KMAXACTIVEOBJ = 2;

//Error code for bad time

const TInt KErrBadTime = -125;

/**

 * destructor

 */

CLocationInterface :: ~CLocationInterface()

    {

 	 delete iLocationService ;

 	 iLocationService = NULL ;

 	 for(TInt iter = 0 ; iter < iHandleCB.Count() ; ++iter)

 	 	{

 	 	 delete iHandleCB[iter] ;

 	 	}

 	 iHandleCB.Close();

	 delete iGenericPosInfo ;

    }

/**

 * Default constructor

 */

 CLocationInterface :: CLocationInterface()

    {

 	iGenericPosInfo = HPositionGenericInfo :: NewL() ; 

 	if(!iGenericPosInfo)

 	    {

 		User ::Leave(KErrNoMemory) ;

 	    }

 	for ( TInt count = 0;count < KMAXACTIVEOBJ ; count++)

    	{

		iHandleCB.Insert(NULL,count);

	    }

    }

 TInt  CLocationInterface::ConvertToSapiError(TInt aSymbianErr)

	 {

	 TInt sapiErr(SErrGeneralError);

	 switch (aSymbianErr)

    	{

      //case EPosLmInvalidArgument:

   		case KErrBadName:

    	case KErrPositionIncalculable :

   		case KErrArgument:			

   		    {

   		    sapiErr = SErrBadArgumentType;

   		    break;

   		    }

   		case KErrNotSupported:

   		    {

   		    sapiErr = SErrServiceNotSupported;

   		    break;

   		    }   		

   		case KErrInUse:	

   		    {

   		    sapiErr = SErrServiceInUse;

   		    break;

   		    }

    	case KErrTimedOut:

	    	{

	    	sapiErr = SErrServiceTimedOut;

	    	break;

	    	}

    	case KErrAccessDenied:

	    	{

	    	sapiErr = SErrAccessDenied;

	    	break;	

	    	}

    	case KErrNone:

    		{

    		sapiErr = SErrNone;

    		break;	

    		}

		case KErrNotFound:

    		{

    		sapiErr = SErrNotFound;

    		break;	

    		}

		case SErrMissingArgument:

			{

				sapiErr = SErrMissingArgument;

				break;

			}

    	}

    return sapiErr;

	 }

 /**

  * CLocationInterface::CmdExecuteL, this method is called by CLocationInterface::HandleCmdL()

  * to catch any leaves that might occur during execution of a LiwCommand.This is an private 

  * method of this class.

  */

void CLocationInterface::CmdExecuteL(

         	 			    const TDesC8& aCmdName,

                            const CLiwGenericParamList& aInParamList ,

                            CLiwGenericParamList& aOutParamList,

                            TUint aCmdOptions,

                            MLiwNotifyCallback* aCallback )

    {

    aOutParamList.Reset() ;

    if( aCmdOptions & KLiwOptCancel ) // for cancel asynchronous request

        {

          TInt ret = 0 ;

          const TLiwGenericParam *transidparam = aInParamList.FindFirst(ret , KTransactionId) ;

          if( !transidparam )

            {

            //Possibility of position based parsing

            TInt argCount = aInParamList.Count();

            if( argCount >= 1 )

	            {

	            transidparam = &aInParamList[Index0];	

	            }

	        if ( !transidparam )

		       {

		       aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,

                                      TLiwVariant(KCancelTransactionIdMissing)));

		       User::Leave( KErrArgument );

		       }

            }

          TInt32 transid = (transidparam->Value()).AsTInt32() ;

          MLiwNotifyCallback* callBack = RequestCancel(transid) ;

          if (!callBack)

	          {

	          aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,

                                      TLiwVariant(KCancelInvalidTransactionId)));

              User::Leave(KErrNotFound);	

	          }

          //Send notification about the cancelled state to consumer

          callBack->HandleNotifyL(transid  , KLiwEventCanceled , 

                                    aOutParamList,   aInParamList) ;

        }

    //GetLocation request is made by consumer

    else if(aCmdName == KCmdGetLocation)                         

        {

        TInt ret  =KErrNone ;

        //Extract category of Location Information user is interested in

        TInt index = 0;

        TPtrC posInfoCategory(KLocationBasicinfo);

        TInt32 transid = aCallback->GetTransactionID() ;

        //This flag indicates whether user has supplied a value for category of

        //location information or not

        TBool infoFlag = FALSE;

        const TLiwGenericParam *smapparam = aInParamList.FindFirst(index , KLocationInfoCategory) ;

        //if smapparam is NULL still there exist possibility of position based parsing

        if ( !smapparam )

	        {

	        TInt count = aInParamList.Count();

	        if (count >= 1)	

		        {

		        smapparam = &aInParamList[Index0];

		        if (smapparam && ( smapparam->Name() == KNullDesC8 ) )

			        {

			        TLiwVariant variant =  smapparam->Value();

			        if( variant.TypeId() != LIW::EVariantTypeDesC )

				        {

				        aOutParamList.AppendL( TLiwGenericParam( KErrorMessage,

                                               TLiwVariant( KGetLocationWrongInfoType ) ) );

                        User::Leave( KErrArgument );

				        //Leave with error code	

				        }

	                posInfoCategory.Set( variant.AsDes() );

	                //Set infoFlag to indicate user has supplied category of location information

	                infoFlag = TRUE;

			        }

		        }

	        }

        if(KErrNotFound != index)

            {

            TLiwVariant variant =  smapparam->Value();

            if( variant.TypeId() != LIW::EVariantTypeDesC )

		        {

		        aOutParamList.AppendL( TLiwGenericParam( KErrorMessage,

                                       TLiwVariant( KGetLocationWrongInfoType ) ) );

                User::Leave( KErrArgument );

		        //Leave with error code	

		        }

            posInfoCategory.Set( variant.AsDes() );

            //Set infoFlag to indicate user has supplied category of location information

	        infoFlag = TRUE;

            }

        //if callback is given for this command then it will be a async request

        if( aCallback && ( KLiwOptASyncronous & aCmdOptions ) ) 

            {

            LocationInterfaceCB  *callback = LocationInterfaceCB :: NewL (aCallback ,  &aInParamList , 

            														      &iModuleInfo , transid) ;

            CleanupStack :: PushL(callback) ;														      

            callback->SetRequestType(KGetLocationCB) ;

           //Extract Update options from input List

        	index = 0;

        	const TLiwGenericParam *smapparam = aInParamList.FindFirst(index , KUpdateOptionMap) ;

        	TPositionUpdateOptions *updateoptions = NULL ;

        	TPositionUpdateOptions updateOptionVal;

        	TUint category = EBasicInfo ;

        	//Check for possibility of position based parsing

        	if ( !smapparam )

	        {

	        TInt count = aInParamList.Count();

	        if (count == 2)	

		        {

		        smapparam = &aInParamList[Index1];

		        if (smapparam)

			        {

			        const CLiwMap  *updateOptionMap = (smapparam->Value() ).AsMap() ;

			        if( !updateOptionMap )

				        {

				        aOutParamList.AppendL( TLiwGenericParam( KErrorMessage,

                                               TLiwVariant( KGetLocationWrongupdateMap ) ) );

                        CleanupStack :: Pop( callback ) ;

                        delete callback;

                        User::Leave( KErrArgument );

				        }

                	TInt error = SetUpdateOption(updateOptionVal,updateOptionMap);

                	if( KErrBadTime == error )

	                	{

	                	aOutParamList.AppendL( TLiwGenericParam( KErrorMessage,

                                               TLiwVariant( KGetLocationNegativeTime ) ) );

                        CleanupStack :: Pop( callback ) ;

                        delete callback;

                        User::Leave( KErrArgument );

	                	}

                	updateoptions = &updateOptionVal ;

			        }

		        }

	        }

        	if(KErrNotFound != index)

        	    {

    	        const CLiwMap  *updateOptionMap = (smapparam->Value() ).AsMap() ;

    	        if( !updateOptionMap )

			        {

			        aOutParamList.AppendL( TLiwGenericParam( KErrorMessage,

                                           TLiwVariant( KGetLocationWrongupdateMap ) ) );

                    CleanupStack :: Pop( callback ) ;

                    delete callback;

                    User::Leave( KErrArgument );

			        }

                TInt error = SetUpdateOption(updateOptionVal,updateOptionMap);

            	if( KErrBadTime == error )

                	{

                	aOutParamList.AppendL( TLiwGenericParam( KErrorMessage,

                                           TLiwVariant( KGetLocationNegativeTime ) ) );

                    CleanupStack :: Pop( callback ) ;

                    delete callback;

                    User::Leave( KErrArgument );

                	}

                else if( KErrArgument == error )

	                {

	                aOutParamList.AppendL( TLiwGenericParam( KErrorMessage,

                                           TLiwVariant( KGetLocationBadUpdateOptions ) ) );

                    CleanupStack :: Pop( callback ) ;

                    delete callback;

                    User::Leave( KErrArgument );

	                }

                updateoptions = &updateOptionVal ;

        	    }

            if ( posInfoCategory == KLocationGenericInfo )

                {

                category = EGenericInfo ;

                }

            else if ( ( posInfoCategory != KLocationBasicinfo ) && ( infoFlag ) )

	            {

	            //this indicates a wrong supplied location info category by the user

	            aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,

                                      TLiwVariant(KGetLocationCategoryInfo)));

                CleanupStack :: Pop( callback ) ;

                delete callback;

                User::Leave(KErrArgument);	

	            }

            //Extraction of update options and information complete so now send the request 

            //To core dll    

            ret = iLocationService->GetLocationL(callback ,category,iFieldList,updateoptions) ;	

            //aOutParamList.AppendL(TLiwGenericParam(KErrorCode , TLiwVariant((TInt32)ret))) ;

            if(KErrNone != ret)

                {

                    CleanupStack :: Pop(callback) ;

                    delete callback ;

                    User::Leave(ret);

                }

            //Store the allocatioed address 

            iHandleCB[KGetLocationCB] = callback ; 

            //Append Transcationid to out list

            aOutParamList.AppendL(TLiwGenericParam(KTransactionId, TLiwVariant(transid)));

            CleanupStack :: Pop(callback) ;

            }

        // Command is synchronous GetLocationCall    

        else  

            {

            TPosition pos ;

            //Extract Update options from input List

            index = 0;

            const TLiwGenericParam *smapparam = aInParamList.FindFirst(index , KUpdateOptionMap) ;

            TUint category = EBasicInfo ;

            TPositionUpdateOptions updateOptionVal;

            const TPositionUpdateOptions* updateOptions = NULL ;

            //if a smapparam is NULL there exist possibility of position based parsing

            if ( !smapparam )

	        {

	        TInt count = aInParamList.Count();

	        if (count == 2)	

		        {

		        smapparam = &aInParamList[Index1];

		        if (smapparam)

			        {

			        const CLiwMap  *updateOptionMap = (smapparam->Value() ).AsMap() ;

			        if( !updateOptionMap )

				        {

				        aOutParamList.AppendL( TLiwGenericParam( KErrorMessage,

	                                           TLiwVariant( KGetLocationWrongupdateMap ) ) );

	                    User::Leave( KErrArgument );

				        }

                	TInt error = SetUpdateOption(updateOptionVal,updateOptionMap);

                	if( KErrBadTime == error )

	                	{

	                	aOutParamList.AppendL( TLiwGenericParam( KErrorMessage,

                                               TLiwVariant( KGetLocationNegativeTime ) ) );

                        User::Leave( KErrArgument );

	                	}

	                else if( KErrArgument == error )

		                {

		                aOutParamList.AppendL( TLiwGenericParam( KErrorMessage,

	                                           TLiwVariant( KGetLocationBadUpdateOptions ) ) );

	                    User::Leave( KErrArgument );

		                }

                	updateOptions = &updateOptionVal ;

			        }

		        }

	        }

            if( KErrNotFound != index)

                {

                const CLiwMap  *updateOptionMap = (smapparam->Value()).AsMap() ;  

                if( !updateOptionMap )

			        {

			        aOutParamList.AppendL( TLiwGenericParam( KErrorMessage,

                                           TLiwVariant( KGetLocationWrongupdateMap ) ) );

                    User::Leave( KErrArgument );

			        }

                TInt error = SetUpdateOption(updateOptionVal,updateOptionMap);

            	if( KErrBadTime == error )

                	{

                	aOutParamList.AppendL( TLiwGenericParam( KErrorMessage,

                                           TLiwVariant( KGetLocationNegativeTime ) ) );

                    User::Leave( KErrArgument );

                	}

                else if( KErrArgument == error )

	                {

	                aOutParamList.AppendL( TLiwGenericParam( KErrorMessage,

                                           TLiwVariant( KGetLocationBadUpdateOptions ) ) );

                    User::Leave( KErrArgument );

	                }

                updateOptions = &updateOptionVal ;

                }

            if ( posInfoCategory == KLocationGenericInfo )

                {

                category = EGenericInfo ;

                }

            else if( posInfoCategory != KLocationBasicinfo   )

	            {

	            //this indicates a wrong supplied location info category by the user

	            aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,

                                      TLiwVariant(KGetLocationCategoryInfo)));

                User::Leave(KErrArgument);	

	            } 

            ret = iLocationService->GetLocationL(iGenericPosInfo,updateOptions) ; 

            //aOutParamList.AppendL(TLiwGenericParam (KErrorCode , TLiwVariant((TInt32)ret))) ;

            if(KErrNone != ret)

                {

                User::Leave(ret);

                }

            GetLocationInfo(aOutParamList,category) ; 

            } //End of Synchronous getlocationcall

        } //End of KCmdGetLocation

    else if(  ( aCmdName == KCmdTraceLocation ) && ( aCallback ) && ( KLiwOptASyncronous & aCmdOptions ) )	//Trace request is made by consumer

        {

        TInt ret = KErrNone ;

        TInt32 transid  = aCallback->GetTransactionID() ;

        TInt index = 0;

        TPtrC posInfoCategory(KLocationBasicinfo);

        const TLiwGenericParam *smapparam = aInParamList.FindFirst(index , KLocationInfoCategory) ;