public static LocalAlloc ( int byteCount ) : |
||
byteCount | int | |
리턴 |
/// <summary> /// Queries the device state. /// </summary> /// <returns>Device state information</returns> public GpsDeviceState GetDeviceState() { GpsDeviceState device = null; // allocate a buffer on the native side. Since the IntPtr pGpsDevice = Utils.LocalAlloc(GpsDeviceState.GpsDeviceStructureSize); // GPS_DEVICE structure has arrays of characters, it's easier to just // write directly into memory rather than create a managed structure with // the same layout. Marshal.WriteInt32(pGpsDevice, 1); // write out GPS version of 1 Marshal.WriteInt32(pGpsDevice, 4, GpsDeviceState.GpsDeviceStructureSize); // write out dwSize of structure int result = GPSGetDeviceState(pGpsDevice); if (result == 0) { // instantiate the GpsDeviceState class passing in the native pointer device = new GpsDeviceState(pGpsDevice); } // free our native memory Utils.LocalFree(pGpsDevice); return(device); }
/// <summary> /// Method used to listen for native events from the GPS. /// </summary> private void WaitForGpsEvents() { lock (this) { bool listening = true; // allocate 3 handles worth of memory to pass to WaitForMultipleObjects IntPtr handles = Utils.LocalAlloc(12); // write the three handles we are listening for. Marshal.WriteInt32(handles, 0, stopHandle.ToInt32()); Marshal.WriteInt32(handles, 4, deviceStateChangedHandle.ToInt32()); Marshal.WriteInt32(handles, 8, newLocationHandle.ToInt32()); while (listening) { int obj = WaitForMultipleObjects(3, handles, 0, -1); if (obj != waitFailed) { switch (obj) { case 0: // we've been signalled to stop listening = false; break; case 1: // device state has changed if (deviceStateChanged != null) { deviceStateChanged(this, new DeviceStateChangedEventArgs(GetDeviceState())); } break; case 2: // location has changed if (locationChanged != null) { locationChanged(this, new LocationChangedEventArgs(GetPosition())); } break; } } else { System.Diagnostics.Debug.WriteLine("wait failed"); } } // free the memory we allocated for the native handles Utils.LocalFree(handles); // clear our gpsEventThread so that we can recreate this thread again // if the events are hooked up again. gpsEventThread = null; } }
/// <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); }