/*

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

//Error code for bad time

const TInt KErrBadTime = -125;

/**

 * destructor

 */

CLocationInterface :: ~CLocationInterface()

    {

 	 delete iLocationService ;

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

 	 	{

 	 	 delete iHandleCB[iter] ;

 	 	}

 	 iHandleCB.Close();

	 delete iGenericPosition ;

    }

/**

 * Default constructor

 */

CLocationInterface::CLocationInterface()

    {

    //No Implementation Required Here

    }

void CLocationInterface::ConstructL()

    {

    iGenericPosition = HPositionGenericInfo::NewL() ;

    if ( !iGenericPosition )

        {

        User::Leave( KErrNoMemory ) ;

        }

    iLocationService = CLocationService::NewL() ;

    //User::LeaveIfError( iLocationService->GetModuleInfo( iModuleInfo ) );

    //User::LeaveIfError( this->SetSupportedFields() );

    }

/**

 * This function is a static method to create iLocatinInterface object

 * return pointer to constructed object else paincs with symbian painc 

 * code

 */

CLocationInterface* CLocationInterface::NewL()

    {

    CLocationInterface* self = new(ELeave)CLocationInterface();

    CleanupStack::PushL( self ) ;

    self->ConstructL();

    CleanupStack::Pop( self ) ;

    return self;

    }

 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;

			}

		case SErrServiceNotReady:

		    {

                sapiErr = SErrServiceNotReady;

		        break;

			}

		default:

			{

				sapiErr = SErrGeneralError;

			}

    }

    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() ;

    /*

     * To indicate position based parsing for all the parameters

     */

    TBool posBasedFlag = EFalse;

    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() ;

        //Get Callback object curresponding to this transaction Id 

        MLiwNotifyCallback* callBack = NULL;

        TInt ncalls = iHandleCB.Count() ;

        for (TInt iter = 0; iter < ncalls; ++iter)

            {

            if (iHandleCB[iter])

                {

                if (iHandleCB[iter]->GetTransactionId() == transid)

                    {

                    //Get the callback object associated with this Transaction Id

                    callBack = iHandleCB[iter]->GetCallBackobj();

                    }

                }

            }

          if (!callBack)

	          {

	          aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,

                                      TLiwVariant(KCancelInvalidTransactionId)));

              User::Leave(KErrNotFound);	

	          }

        //Cancel the exisiting request

        User::LeaveIfError(iLocationService->CancelService(transid));

          //Send notification about the cancelled state to consumer

          callBack->HandleNotifyL(transid  , KLiwEventCanceled , 

                                    aOutParamList,   aInParamList) ;

        }

    //LastKnownLocation Request is made by consumer

    else if( !(aCmdName.CompareF( KCmdLastLocation )) )

        {

        //Extract Update options from input List

        User::LeaveIfError(iLocationService->GetLastKnownLoc(iPosition)) ;            

        TUint category1 = EBasicInfo;

        iGenericPosition->SetPosition(iPosition);

        GetLocationInfo(aOutParamList, category1) ;

        }

    //GetLocation request is made by consumer

    else if( !( aCmdName.CompareF( 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	

				        }

                    //indicates that position based parsing has been done 

                    posBasedFlag = ETrue;

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

            {

           //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 && posBasedFlag )	

		        {

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

	                	}

                	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 ) && ( infoFlag ) )

	            {

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

	            aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,

                                      TLiwVariant(KGetLocationCategoryInfo)));

                User::Leave(KErrArgument);	

	            }

            //Extract EnableHighAccuracy param 

            index = 0;

            const TLiwGenericParam* highaccparam = 

            aInParamList.FindFirst(index , KEnableHighAccuracy) ;

            TBool enableHighAcc = false;

            if ( KErrNotFound == index )

                {

                highaccparam = 0;

                TInt count = aInParamList.Count();

                if ( count >= 3 && posBasedFlag ) 

                    {

                    //Possiblity of Position based parsing

                    highaccparam = &aInParamList[Index2];

                    }

                }

            if( highaccparam )

                {

                if((highaccparam->Value().TypeId()) == EVariantTypeTBool)

                    enableHighAcc = highaccparam->Value().AsTBool();

                else

                    {

                    aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,

                            TLiwVariant(KGetLocationBadEnableHighAcc) ) );

                    User::Leave(KErrArgument);

                    }

                }

            LocationInterfaceCB* callback =

            LocationInterfaceCB::NewL(aCallback,

                    &aInParamList, /*&iModuleInfo,*/ transid) ;

            CleanupStack :: PushL(callback) ;                   

            callback->SetRequestType(KGetLocationCB) ;

            iLocationService->GetLocationL(callback ,category,

                    NULL,updateoptions,enableHighAcc) ;	                    

            //Store the allocatioed address 

            iHandleCB.Append(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 && posBasedFlag)	

		        {

		        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() ;