gpsposition.cs

来自「清华大学出版社出版的 移动应用开发宝典 张大威（2008）的附书源代码」· CS 代码 · 共 488 行 · 第 1/2 页

        /// <summary>
        /// Speed in knots
        /// </summary>
        public float Speed
        {
            get { return position.flSpeed; }
        }
        /// <summary>
        /// True if the Speed property is valid, false if invalid
        /// </summary>
        public bool SpeedValid
        {
            get { return (position.dwValidFields & GPS_VALID.SPEED) != 0; }
        }

        /// <summary>
        /// Altitude with regards to ellipsoid, in meters
        /// </summary>
        public float EllipsoidAltitude
        {
            get { return position.flAltitudeWRTEllipsoid; }
        }
        /// <summary>
        /// True if the EllipsoidAltitude property is valid, false if invalid
        /// </summary>
        public bool EllipsoidAltitudeValid
        {
            get { return (position.dwValidFields & GPS_VALID.ALTITUDE_WRT_ELLIPSOID) != 0; }
        }

        /// <summary>
        /// Altitute with regards to sea level, in meters
        /// </summary>
        public float SeaLevelAltitude
        {
            get { return position.flAltitudeWRTSeaLevel; }
        }
        /// <summary>
        /// True if the SeaLevelAltitude property is valid, false if invalid
        /// </summary>
        public bool SeaLevelAltitudeValid
        {
            get { return (position.dwValidFields & GPS_VALID.ALTITUDE_WRT_SEA_LEVEL) != 0; }
        }

        /// <summary>
        /// Latitude in decimal degrees.  North is positive
        /// </summary>
        public double Latitude
        {
            get { return position.dblLatitude; }
        }
        /// <summary>
        /// Latitude in degrees, minutes, seconds.  North is positive
        /// </summary>
        public DegreesMinutesSeconds LatitudeInDegreesMinutesSeconds
        {
            get { return new DegreesMinutesSeconds(position.dblLatitude); }
        }

        /// <summary>
        /// True if the Latitude property is valid, false if invalid
        /// </summary>
        public bool LatitudeValid
        {
            get { return (position.dwValidFields & GPS_VALID.LATITUDE) != 0; }
        }

        /// <summary>
        /// Longitude in decimal degrees.  East is positive
        /// </summary>
        public double Longitude
        {
            get { return position.dblLongitude; }
        }

        /// <summary>
        /// Longitude in degrees, minutes, seconds.  East is positive
        /// </summary>
        public DegreesMinutesSeconds LongitudeInDegreesMinutesSeconds
        {
            get { return new DegreesMinutesSeconds(position.dblLongitude); }
        }
        /// <summary>
        /// True if the Longitude property is valid, false if invalid
        /// </summary>
        public bool LongitudeValid
        {
            get { return (position.dwValidFields & GPS_VALID.LONGITUDE) != 0; }
        }

        /// <summary>
        /// Degrees heading (course made good).  True North=0
        /// </summary>
        public float Heading
        {
            get { return position.flHeading; }
        }
        /// <summary>
        /// True if the Heading property is valid, false if invalid
        /// </summary>
        public bool HeadingValid
        {
            get { return (position.dwValidFields & GPS_VALID.HEADING) != 0; }
        }

        /// <summary>
        /// Position Dilution Of Precision
        /// </summary>
        public float PositionDilutionOfPrecision
        {
            get { return position.flPositionDilutionOfPrecision; }
        }
        /// <summary>
        /// True if the PositionDilutionOfPrecision property is valid, false if invalid
        /// </summary>
        public bool PositionDilutionOfPrecisionValid
        {
            get { return (position.dwValidFields & GPS_VALID.POSITION_DILUTION_OF_PRECISION) != 0; }
        }

        /// <summary>
        /// Horizontal Dilution Of Precision
        /// </summary>
        public float HorizontalDilutionOfPrecision
        {
            get { return position.flHorizontalDilutionOfPrecision; }
        }
        /// <summary>
        /// True if the HorizontalDilutionOfPrecision property is valid, false if invalid
        /// </summary>
        public bool HorizontalDilutionOfPrecisionValid
        {
            get { return (position.dwValidFields & GPS_VALID.HORIZONTAL_DILUTION_OF_PRECISION) != 0; }
        }

        /// <summary>
        /// Vertical Dilution Of Precision
        /// </summary>
        public float VerticalDilutionOfPrecision
        {
            get { return position.flVerticalDilutionOfPrecision; }
        }
        /// <summary>
        /// True if the VerticalDilutionOfPrecision property is valid, false if invalid
        /// </summary>
        public bool VerticalDilutionOfPrecisionValid
        {
            get { return (position.dwValidFields & GPS_VALID.VERTICAL_DILUTION_OF_PRECISION) != 0; }
        }

        
    }

    [StructLayout(LayoutKind.Sequential)]
    internal struct GPS_POSITION
    {
        private const int GPS_MAX_SATELLITES = 12;

        public int dwVersion;
        public int dwSize;

        public GPS_VALID dwValidFields;

        public GPS_DATA_FLAGS dwFlags;

        public SYSTEMTIME stUTCTime;

        public double dblLatitude;
        public double dblLongitude;
        public float flSpeed;
        public float flHeading;
        public double dblMagneticVariation;
        public float flAltitudeWRTSeaLevel;
        public float flAltitudeWRTEllipsoid;

        public FixQuality FixQuality;
        public FixType FixType;
        public FixSelection SelectionType;
        public float flPositionDilutionOfPrecision;
        public float flHorizontalDilutionOfPrecision;
        public float flVerticalDilutionOfPrecision;

        public int dwSatelliteCount;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = GPS_MAX_SATELLITES)]
        public int[] rgdwSatellitesUsedPRNs;

        public int dwSatellitesInView;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = GPS_MAX_SATELLITES)]
        public int[] rgdwSatellitesInViewPRNs;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = GPS_MAX_SATELLITES)]
        public int[] rgdwSatellitesInViewElevation;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = GPS_MAX_SATELLITES)]
        public int[] rgdwSatellitesInViewAzimuth;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = GPS_MAX_SATELLITES)]
        public int[] rgdwSatellitesInViewSignalToNoiseRatio;
    }

    [Flags()]
    internal enum GPS_VALID : int
    {
        UTC_TIME                                = 0x00000001,
        LATITUDE                                = 0x00000002,
        LONGITUDE                               = 0x00000004,
        SPEED                                   = 0x00000008,
        HEADING                                 = 0x00000010,
        MAGNETIC_VARIATION                      = 0x00000020,
        ALTITUDE_WRT_SEA_LEVEL                  = 0x00000040,
        ALTITUDE_WRT_ELLIPSOID                  = 0x00000080,
        POSITION_DILUTION_OF_PRECISION          = 0x00000100,
        HORIZONTAL_DILUTION_OF_PRECISION        = 0x00000200,
        VERTICAL_DILUTION_OF_PRECISION          = 0x00000400,
        SATELLITE_COUNT                         = 0x00000800,
        SATELLITES_USED_PRNS                    = 0x00001000,
        SATELLITES_IN_VIEW                      = 0x00002000,
        SATELLITES_IN_VIEW_PRNS                 = 0x00004000,
        SATELLITES_IN_VIEW_ELEVATION            = 0x00008000,
        SATELLITES_IN_VIEW_AZIMUTH              = 0x00010000,
        SATELLITES_IN_VIEW_SIGNAL_TO_NOISE_RATIO = 0x00020000,
    }


    [Flags()]
    internal enum GPS_DATA_FLAGS : int
    {
        NONE = 0,
        HARDWARE_OFF = 0x00000001,
    }

    [StructLayout(LayoutKind.Sequential)]
    internal struct SYSTEMTIME
    {
        internal short year;
        internal short month;
        internal short dayOfWeek;
        internal short day;
        internal short hour;
        internal short minute;
        internal short second;
        internal short millisecond;
    }

}