[Windows Mobile Development and Hacking General] tiger.woods:
How much of the code are you interested in?

In case anyone is interested I was able to find an unwilling soul to convert the first signature.

Here is the signature in C#:

[DllImport("gpsapi.dll")]static extern IntPtr GPSOpenDevice( IntPtr hNewLocationData, IntPtr hDeviceStateChange, string szDeviceName, int dwFlags);In VB, it looks like this:

In VB:

<DllImport("gpsapi.dll")> _Function Shared GPSOpenDevice( _ ByVal hNewLocationData As IntPtr, _ ByVal hDeviceStateChange As IntPtr, _ ByVal szDeviceName As String, _ ByVal dwFlags As Integer) As IntPtrEnd Function

hopefully some others can help come up with some simple VB source for using the GPS device....

I believe this is from a class module:

//

// Copyright (c) Microsoft Corporation. All rights reserved.

//

//

// Use of this sample source code is subject to the terms of the Microsoft

// license agreement under which you licensed this sample source code. If

// you did not accept the terms of the license agreement, you are not

// authorized to use this sample source code. For the terms of the license,

// please see the license agreement between you and Microsoft or, if applicable,

// see the LICENSE.RTF on your install media or the root of your tools installation.

// THE SAMPLE SOURCE CODE IS PROVIDED "AS IS", WITH NO WARRANTIES OR INDEMNITIES.

//

using System;

using System.Runtime.InteropServices;

using System.Collections;

using System.Text;

namespace Microsoft.WindowsMobile.Samples.Location

{

public delegate void LocationChangedEventHandler(object sender, LocationChangedEventArgs args);

public delegate void DeviceStateChangedEventHandler(object sender, DeviceStateChangedEventArgs args);

/// <summary>

/// Summary description for GPS.

/// </summary>

public class Gps

{

// handle to the gps device

IntPtr gpsHandle = IntPtr.Zero;

// handle to the native event that is signalled when the GPS

// devices gets a new location

IntPtr newLocationHandle = IntPtr.Zero;

// handle to the native event that is signalled when the GPS

// device state changes

IntPtr deviceStateChangedHandle = IntPtr.Zero;

// handle to the native event that we use to stop our event

// thread

IntPtr stopHandle = IntPtr.Zero;

// holds our event thread instance

System.Threading.Thread gpsEventThread = null;

event LocationChangedEventHandler locationChanged;

/// <summary>

/// Event that is raised when the GPS locaction data changes

/// </summary>

public event LocationChangedEventHandler LocationChanged

{

add

{

locationChanged += value;

// create our event thread only if the user decides to listen

CreateGpsEventThread();

}

remove

{

locationChanged -= value;

}

}

event DeviceStateChangedEventHandler deviceStateChanged;

/// <summary>

/// Event that is raised when the GPS device state changes

/// </summary>

public event DeviceStateChangedEventHandler DeviceStateChanged

{

add

{

deviceStateChanged += value;

// create our event thread only if the user decides to listen

CreateGpsEventThread();

}

remove

{

deviceStateChanged -= value;

}

}

/// <summary>

/// True: The GPS device has been opened. False: It has not been opened

/// </summary>

public bool Opened

{

get { return gpsHandle != IntPtr.Zero; }

}

public Gps()

{

}

~Gps()

{

// make sure that the GPS was closed.

Close();

}

/// <summary>

/// Opens the GPS device and prepares to receive data from it.

/// </summary>

public void Open()

{

if (!Opened)

{

// create handles for GPS events

newLocationHandle = CreateEvent(IntPtr.Zero, 0, 0, null);

deviceStateChangedHandle = CreateEvent(IntPtr.Zero, 0, 0, null);

stopHandle = CreateEvent(IntPtr.Zero, 0, 0, null);

gpsHandle = GPSOpenDevice(newLocationHandle, deviceStateChangedHandle, null, 0);

// if events were hooked up before the device was opened, we'll need

// to create the gps event thread.

if (locationChanged != null || deviceStateChanged != null)

{

CreateGpsEventThread();

}

}

}

/// <summary>

/// Closes the gps device.

/// </summary>

public void Close()

{

if (gpsHandle != IntPtr.Zero)

{

GPSCloseDevice(gpsHandle);

gpsHandle = IntPtr.Zero;

}

// Set our native stop event so we can exit our event thread.

if (stopHandle != IntPtr.Zero)

{

EventModify(stopHandle, eventSet);

}

// block until our event thread is finished before

// we close our native event handles

lock (this)

{

if (newLocationHandle != IntPtr.Zero)

{

CloseHandle(newLocationHandle);

newLocationHandle = IntPtr.Zero;

}

if (deviceStateChangedHandle != IntPtr.Zero)

{

CloseHandle(deviceStateChangedHandle);

deviceStateChangedHandle = IntPtr.Zero;

}

if (stopHandle != IntPtr.Zero)

{

CloseHandle(stopHandle);

stopHandle = IntPtr.Zero;

}

}

}

/// <summary>

/// Get the position reported by the GPS receiver

/// </summary>

/// <returns>GpsPosition class with all the position details</returns>

public GpsPosition GetPosition()

{

return GetPosition(TimeSpan.Zero);

}

/// <summary>

/// Get the position reported by the GPS receiver that is no older than

/// the maxAge passed in

/// </summary>

/// <param name="maxAge">Max age of the gps position data that you want back.

/// If there is no data within the required age, null is returned.

/// if maxAge == TimeSpan.Zero, then the age of the data is ignored</param>

/// <returns>GpsPosition class with all the position details</returns>

public GpsPosition GetPosition(TimeSpan maxAge)

{

GpsPosition gpsPosition = null;

if (Opened)

{

// allocate the necessary memory on the native side. We have a class (GpsPosition) that

// has the same memory layout as its native counterpart

IntPtr ptr = Utils.LocalAlloc(Marshal.SizeOf(typeof(GpsPosition)));

// fill in the required fields

gpsPosition = new GpsPosition();

gpsPosition.dwVersion = 1;

gpsPosition.dwSize = Marshal.SizeOf(typeof(GpsPosition));

// Marshal our data to the native pointer we allocated.

Marshal.StructureToPtr(gpsPosition, ptr, false);

// call native method passing in our native buffer

int result = GPSGetPosition(gpsHandle, ptr, 500000, 0);

if (result == 0)

{

// native call succeeded, marshal native data to our managed data

gpsPosition = (GpsPosition)Marshal.PtrToStructure(ptr, typeof(GpsPosition));

if (maxAge != TimeSpan.Zero)

{

// check to see if the data is recent enough.

if (!gpsPosition.TimeValid || DateTime.Now - maxAge > gpsPosition.Time)

{

gpsPosition = null;

}

}

}

// free our native memory

Utils.LocalFree(ptr);

}

return gpsPosition;

}