void CLocationService::ConstructL()

    User :: LeaveIfError(iPosServer.Connect());

    CleanupClosePushL(iPosServer);

    //Get the module id of the default module available

    User :: LeaveIfError(iPosServer.GetDefaultModuleId(iModuleId));

    CleanupStack::Pop(&iPosServer);

/**

 * CLocationService::GetHighAccuracyModule

 * This function returns the module id of highest accuracy 

 * module that is available on the phone currently.

 */

void CLocationService::GetHighAccuracyModuleL(TPositionModuleId* aModId)

    {

    TPositionModuleId moduleId;

    TPositionModuleInfo modInfo;

    TUint numOfModules = 0;

    //Flags used for indicating if a particular module is found

    TInt termInternalFlag = 0;   

    TInt termFlag = 0 ,assisFlag = 0 ,networkFlag = 0,unknownFlag = 0;

    TInt err;

    User::LeaveIfError(iPosServer.GetNumModules(numOfModules));

    for( TInt i=0;i< numOfModules;i++ )

        {

        iPosServer.GetModuleInfoByIndex(i,modInfo);

				if( modInfo.TechnologyType() == modInfo.ETechnologyAssisted  && 

                 modInfo.IsAvailable())

            {

            assisFlag = 1;

            moduleId = modInfo.ModuleId();

						break;

            }

        if( modInfo.TechnologyType() == modInfo.ETechnologyTerminal  && 

                !assisFlag && !termInternalFlag && modInfo.IsAvailable() )

            {

            termFlag = 1;

            moduleId = modInfo.ModuleId();

            //Internal Module takes higher priority than External module 

            if(modInfo.DeviceLocation() == modInfo.EDeviceInternal)

                {

                termInternalFlag = 1;                

                }

            }

        if(modInfo.TechnologyType() == modInfo.ETechnologyNetwork && 

                !assisFlag  && !termFlag && modInfo.IsAvailable())

            {

            networkFlag = 1;

            moduleId = modInfo.ModuleId();

            }

        if( modInfo.TechnologyType() == modInfo.ETechnologyUnknown && 

                !assisFlag  && !termFlag && 

                !networkFlag && modInfo.IsAvailable() )

            {

            unknownFlag = 1;

            moduleId = modInfo.ModuleId();                            

            }

        }

    *aModId =  moduleId;

    }

EXPORT_C void  CLocationService :: GetLocationL( TPositionInfoBase* aInfoBase ,

        const TPositionUpdateOptions* aUpdateOpts,TBool aEnableHighAcc )

    // Open subsession to the position server

    TPositionModuleId ModuleId;

    TInt error;

    if(aEnableHighAcc)

        GetHighAccuracyModuleL(&ModuleId);

        User::LeaveIfError(iPositioner.Open(iPosServer,ModuleId));

        User::LeaveIfError(iPositioner.Open(iPosServer));

        }

    CleanupClosePushL(iPositioner);

    //setting identity for this requestor

    User::LeaveIfError( iPositioner.SetRequestor( CRequestor::ERequestorService,

            CRequestor::EFormatApplication,

            KIdentity ) );

    TRequestStatus status;

    if(aUpdateOpts)

        {

        User::LeaveIfError(iPositioner.SetUpdateOptions(*aUpdateOpts));

        }

    else

        {

        TPositionUpdateOptions updateopts ;

        // Set update interval to one second to receive one position data per second

        updateopts.SetUpdateInterval(TTimeIntervalMicroSeconds(KSUpdateInterval));

        // If position server could not get position

        // In two minutes it will terminate the position request

        updateopts.SetUpdateTimeOut(TTimeIntervalMicroSeconds(KSUpdateTimeOut));

        // Positions which have time stamp below KMaxAge can be reused

        updateopts.SetMaxUpdateAge(TTimeIntervalMicroSeconds(KSMaxAge));

        // Enables location framework to send partial position data

        updateopts.SetAcceptPartialUpdates(FALSE);

    CleanupStack::PopAndDestroy(&iPositioner);

    User::LeaveIfError(status.Int());

EXPORT_C void CLocationService :: GetLocationL( MLocationCallBack* aCallBackObj ,

        TInt aLocationInfoCategory,

        TPositionFieldIdList aFieldList ,

        const TPositionUpdateOptions* aUpateOptions,

        TBool aEnableHighAcc 

)

    {  

    TPositionModuleId ModuleId;

    if(aEnableHighAcc)

        GetHighAccuracyModuleL(&ModuleId);

        }

    else

        {

        //Indicates that when opening the subsession ,moudleId need not be specified

        ModuleId.iUid = 0;       

    TInt err = KErrGeneral;

    CGetLoc* activeGetLoc = CGetLoc :: NewL(iPosServer ,

            aFieldList ,

            KGetLocationRequest,

            aLocationInfoCategory,

            ModuleId) ;

    err = activeGetLoc->GetLocationUpdates(this,aCallBackObj,aUpateOptions);

    if ( KErrNone == err )

        {

        iRegTable.Append(activeGetLoc);

    else

        delete activeGetLoc; //Clean up

        User::Leave(err);

        }

EXPORT_C void CLocationService :: TraceL( MLocationCallBack* aCallBackObj ,

        TInt aLocationInfoCategory,

        TPositionFieldIdList aFiledList ,

        const TPositionUpdateOptions* aUpateOptions,

        TBool aEnableHighAcc )

    TPositionModuleId ModuleId;

    if(aEnableHighAcc)

        {

        GetHighAccuracyModuleL(&ModuleId);

        if(ModuleId.iUid == NULL)

            {

            User::Leave(KErrGeneral);

            }

        }

    else

        //Indicates that when opening the subsession ,moudleId need not be specified

        ModuleId.iUid = 0;          

        }

    CGetLoc* activeTrace = CGetLoc :: NewL(iPosServer ,

            aFiledList ,

            KTraceRequest,

            aLocationInfoCategory,

            ModuleId) ;

    TInt ret = activeTrace->GetLocationUpdates(this,aCallBackObj , aUpateOptions);

    if (ret == KErrNone)

        {        

        iRegTable.Append(activeTrace);

        }

    else

        { 

        //Cleanup the allocated object

        delete activeTrace;

        User::Leave(ret);

EXPORT_C TInt CLocationService :: GetLastKnownLoc( TPosition& aResultPos )

    TInt error = iPositioner.Open(iPosServer);

    // The opening of a subsession failed

    if ( KErrNone != error )

        {

        iPosServer.Close();

        return error ;

        }

    //setting identity for this requestor

    error = iPositioner.SetRequestor( CRequestor::ERequestorService,

            CRequestor::EFormatApplication,

            KIdentity ) ;

	  if ( KErrNone != error )

        {

        iPositioner.Close();

        return error ;

        }

    iPositioner.Close();

        TInt i;

        for( i = 0; i< iRegTable.Count(); i++)

            if(iRegTable[i] )

                if((((iRegTable[i]->GetCallBackobj())->GetRequestType()) == 

                KGetLocationReq) && (aCancelparam == ECancelGetLocation ))              

                    {                  

                    if(iRegTable[i]->IsAdded())

                        {         

                        iRegTable[i]->Deque();

                        }

                    delete iRegTable[i];

                    iRegTable[i] = NULL;

                    return KErrNone;

                    }

                else if ((((iRegTable[i]->GetCallBackobj())->GetRequestType()) == 

                KTraceReq) &&  (aCancelparam == ECancelTrace ))

                    {

                    if(iRegTable[i]->IsAdded())

                        {

                        iRegTable[i]->Deque();

                        }

                    iRegTable[i]->SetStatusComplete();

                    delete iRegTable[i];

                    iRegTable[i] = NULL;

                    return KErrNone;

                    }

                }  

            }    

        return KErrNotFound;

/**

 * CancelService : Cancels Requested asynchronous requests,

 * Input : TransactionId returned by the Async request,

 * Returns success(KErrNone) if service canceled or else error if 

 * input parameter is invalid

 */

EXPORT_C TInt CLocationService::CancelService( TInt aTransId)

    {

    TInt i;

    for( i = 0; i< iRegTable.Count(); i++)

        {

        if(iRegTable[i])

            {

            if(aTransId == 

            (iRegTable[i]->GetCallBackobj())->GetTransactionId())

                {

                if(iRegTable[i]->IsAdded())

                    {

                    iRegTable[i]->Deque();

                    }

                if(((iRegTable[i]->GetCallBackobj())->GetRequestType()) == 

                KTraceReq)

                    {

                    iRegTable[i]->SetStatusComplete();

                    }

                delete iRegTable[i];

                iRegTable[i] = NULL;

                return KErrNone;

                }

            }

        }

    return KErrNotFound;

    }