extern "C" WPSPROXY_API void SetServerUrl(const LPWSTR url)
{
    //Convert unicode string to ANSI string. 
    //this call allocates memory
    LPSTR szUrl = wcstombs(url);
 
    //call WPSAPI function with ANSI string
    WPS_set_server_url(szUrl);
 
    //Free the ANSI string
    delete szUrl;
}

extern "C" WPSPROXY_API WPS_ReturnCode PeriodicLocation(
    LPWSTR userName, 
    LPWSTR realm, 
    WPS_StreetAddressLookup lookupType, 
    unsigned long period, 
    unsigned long iterations, 
    WiFiLocationDelegate* callback
    //This is the delegate passed in from managed code
    )
{
    //perform conversion from double byte strings to single byte strings
    WPS_SimpleAuthentication simpleAuthentication;
    simpleAuthentication.realm = wcstombs(realm);
    simpleAuthentication.username = wcstombs(userName);
    WPS_ReturnCode result;
 
    result = WPS_periodic_location(
        &simpleAuthentication, 
        lookupType,period, 
        iterations, 
        WiFiLocationCallback,        //Function predefined within WPSAPI
        callback                    //managed delegate. Passed as data parameter
        );                    
    //delete userName;
    //delete realm;
    return result;
}

WPS_Continuation WiFiLocationCallback(void*  arg, WPS_ReturnCode result, 
                 const WPS_Location* location)
{
    WPS_Continuation retCode;
    retCode = WPS_STOP;
    if(arg!=NULL) // if a callback function has been passed
    {
        WiFiLocationDelegate delegateMethod = (WiFiLocationDelegate)arg;
        
        //Code deleted from here for clarity. At the end of the work that is
        //performed by the code that I've deleted here the callback function
        //is called.
        
        retCode = delegateMethod(result,location->latitude, location->longitude, 
                                 location->hpe, location->nap, location->speed, 
                                 location->bearing, streetNumber, addressLine, 
                                 city, stateName, stateCode, postalCode, county, region, 
                                 countryName, countryCode,province);
    }/*arg!=null*/
    return retCode;
}

// From the project SimpleClient
        
Wps _wps = new Wps(_userName, _realm);
 
void UpdatePosition(WiFiLocation position)
{
   //...this function list out the values of the fields on the WiFiLocation
   //object passed to it. 
}
private void miFullAddress_Click(object sender, EventArgs e)
{
    WiFiLocation loc = _wps.GetWiFiLocation(StreetAddressLookupType.FullStreet);
    this.UpdatePosition(loc);
}
 
void miPosition_Click()
{
    WiFiLocation loc = _wps.GetWiFiLocation(StreetAddressLookupType.NoStreet);
    this.UpdatePosition(loc);
}

//These methods will throw an exception if a location cannot be acquired
public WiFiLocation GetWiFiLocation(StreetAddressLookupType lookupType);
public IPLocation GetIPLocation(StreetAddressLookupType lookupType)
 
//These methods will return an error code if a location cannot be acquired
public ResultCode GetWiFiLocation(StreetAddressLookupType lookupType, 
                                  out WiFiLocation location)
public ResultCode GetIPLocation(StreetAddressLookupType lookupType, 
                                out IPLocation location)

ResultCode rc = _wps.BeginPeriodicLocation(
        StreetAddressLookupType.NoStreet, //leve of positioning detail required
        5000,   //period (in milliseconds) desired between updates
        10      //The number of times that a position is to be reported
);

rc = _wps.BeginTiling("\\temp\\", 500000, 4000000);

private void miSearch_Click(object sender, EventArgs e)
{
    MapPoint.Service.FindServiceSoap findService = 
             new MapPoint.SimpleClient.MapPoint.Service.FindServiceSoap();
 
    //To prevent to annoying URI Exception in the debug output. Optional.
    findService.Proxy = System.Net.GlobalProxySelection.GetEmptyWebProxy(); 
 
    //Specify our credentials for authorization
    findService.Credentials = new NetworkCredential(
                                      _registrySettings.MapPointAppID, 
                                      _registrySettings.MapPointPassword
                                      );
    findService.PreAuthenticate = true;
 
    FindFilter findFilter = new FindFilter();
 
    //http://msdn.microsoft.com/en-us/library/cc534903.aspx
    findFilter.EntityTypeName = _entityDictionary[dupQuery.Text]; 
    
    //only display the display name for each search result
    findFilter.PropertyNames = new string[]{"DisplayName"};
 
    MapPoint.Service.LatLong latLong = new MapPoint.Service.LatLong();
    latLong.Latitude = Double.Parse(txtLatitude.Text);
    latLong.Longitude = Double.Parse(txtLongitude.Text);
 
 
    MapPoint.Service.FindNearbySpecification findSpecification = 
                     new MapPoint.Service.FindNearbySpecification();
    findSpecification.DataSourceName = _registrySettings.MapPointDataSource;
    //If the user has not selected a datasource then we will
    //use the NavTech North American datasource
    if (findSpecification.DataSourceName.Length == 0)
        findSpecification.DataSourceName = "NavTech.NA";
    findSpecification.LatLong = latLong;
    findSpecification.Distance = 100;
    findSpecification.Filter = findFilter;
 
    FindResults resultList = null;
    try
    {
        resultList = findService.FindNearby(findSpecification);
        if (resultList.Results != null)
        {
            DisplayResults(resultList.Results);
        }
    }
    catch(Exception exc)
    {
        System.Diagnostics.Debug.WriteLine(exc.ToString());
    }
}

//variable for holding our list of providers
ProviderExpiration[] _providerList;
 
public HubLocationProvider()
{
    //Add the providers to the provider list by order of priority
    _providerList = new ProviderExpiration[3] ;
 
    _providerList[0] = new ProviderExpiration();
    _providerList[0].ExpirationTime = new TimeSpan(0, 0, 30);
    _providerList[0].LocationProvider = _gpsProvider;
 
    _providerList[1] = new ProviderExpiration();
    _providerList[1].ExpirationTime = new TimeSpan(0, 1, 15);
    _providerList[1].LocationProvider = _wifiLocationProvider;
 
    _providerList[2] = new ProviderExpiration();
    _providerList[2].ExpirationTime = new TimeSpan(0, 2, 0);
    _providerList[2].LocationProvider = _cellProvider;
}
 
public Location LastLocation
{
    get 
    {
        // Go through all of the available location providers by order of
        //priority and return the highest priority non-expired value
        for (int i = 0; i < _providerList.Length; ++i)
        {
            if (!_providerList[i].IsExpired())
                return _providerList[i].LocationProvider.LastLocation;
        }
        return null;
    }
}

void EnsureMessageInterceptor()
{
    if (_messageInterceptor == null)
    {
        //If the application launcher is enable then 
        //the system already has our message interception
        //rules. We recreate the message interceptor using our Application ID string
        if (MessageInterceptor.IsApplicationLauncherEnabled(ApplicationLaunchID))
        {
            _messageInterceptor = new MessageInterceptor(ApplicationLaunchID, 
                                      _session.UserSettings.EnableAutostart);
        }
        else
        {
            //The application launcher isn't enabled, so we need
            //to create a new interceptor and give it rules. 
            _messageInterceptor = new MessageInterceptor();
            MessageCondition messageCondition = 
              new MessageCondition(
                  MessageProperty.Body,
                  MessagePropertyComparisonType.Contains,"findme://"

                  );
            _messageInterceptor.InterceptionAction = 
                                InterceptionAction.NotifyAndDelete;
            _messageInterceptor.MessageCondition = messageCondition;
            
            //Enable application launching if the user's settings allow for it.
            if(_session.UserSettings.EnableAutostart)
               _messageInterceptor.EnableApplicationLauncher(ApplicationLaunchID);
        }                
    }
}

static Regex LocationRegularExpression = 
  new  Regex(@"findme://(?<<atitude>(\-|\+)?\d+(\.\d*)?),"+
             "(?<longitude>(\-|\+)?\d+(\.\d*)?),(?<comment>.*)?", 
             RegexOptions.IgnoreCase|RegexOptions.Singleline);
static Regex LocationRequestRegularExpression = 
  new Regex(@"findme://whereareyou(\?format=(?<format>[a-z]*))?", 
            RegexOptions.IgnoreCase | RegexOptions.Singleline);

Match m = LocationRegularExpression.Match(smsMessage.Body);
if (m.Success)
{
    playAlert = true;
    double latitude = double.Parse(m.Groups["latitude"].Value);
    double longitude = double.Parse(m.Groups["longitude"].Value);
    string comment = m.Groups["Comment"].Value;
    
}

partial class ContactApproval: IContactApproval
{
 
    const string AllowLocationViewPropertyName = "Approved for Find Me";
    const string AllowLocationViewPropertyValue = "Yes";
 
    public void Allow(Contact c)
    {
        if (!c.Properties.Contains(AllowLocationViewPropertyName))
            c.Properties.Add(AllowLocationViewPropertyName);
        c.Properties[AllowLocationViewPropertyName] = 
            AllowLocationViewPropertyValue;
        c.Update();
    }
 
    public void Revoke(Contact c)
    {
        if (c.Properties.Contains(AllowLocationViewPropertyName))
            c.Properties[AllowLocationViewPropertyName] = null;
    }
 
    public bool IsAllowed(Contact c)
    {
        if ((c==null)||(c.ItemId.ToString().Equals("0")))
            return false;
        if (c.Properties.Contains(AllowLocationViewPropertyName))
        {
            object o = c.Properties[AllowLocationViewPropertyName];
            string allowSetting = o  as string;
            if (AllowLocationViewPropertyValue.Equals(allowSetting))
                return true;
        }
        return false;
    }
}

public static double CalcDistance(double lat1, double lng1, double lat2, double lng2, 
              double radius /*radius of earth in the unit of your choosing*/)
{
 
    return radius * 2 * Math.Asin(Math.Min(1, Math.Sqrt(
       (Math.Pow(Math.Sin((DiffRadian(lat1, lat2)) / 2.0), 2.0) + 
        Math.Cos(ToRadian(lat1)) * Math.Cos(ToRadian(lat2)) * 
        Math.Pow(Math.Sin((DiffRadian(lng1, lng2)) / 2.0), 2.0)))));
}