/*
 * Copyright (C) 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License
 */

package android.location;

import android.annotation.SystemApi;
import android.os.Parcel;
import android.os.Parcelable;

A class representing a GPS satellite measurement, containing raw and computed information.
@hide
/**
 * A class representing a GPS satellite measurement, containing raw and computed information.
 *
 * @hide
 */
@SystemApi
public class GpsMeasurement implements Parcelable {
    private int mFlags;
    private byte mPrn;
    private double mTimeOffsetInNs;
    private short mState;
    private long mReceivedGpsTowInNs;
    private long mReceivedGpsTowUncertaintyInNs;
    private double mCn0InDbHz;
    private double mPseudorangeRateInMetersPerSec;
    private double mPseudorangeRateUncertaintyInMetersPerSec;
    private short mAccumulatedDeltaRangeState;
    private double mAccumulatedDeltaRangeInMeters;
    private double mAccumulatedDeltaRangeUncertaintyInMeters;
    private double mPseudorangeInMeters;
    private double mPseudorangeUncertaintyInMeters;
    private double mCodePhaseInChips;
    private double mCodePhaseUncertaintyInChips;
    private float mCarrierFrequencyInHz;
    private long mCarrierCycles;
    private double mCarrierPhase;
    private double mCarrierPhaseUncertainty;
    private byte mLossOfLock;
    private int mBitNumber;
    private short mTimeFromLastBitInMs;
    private double mDopplerShiftInHz;
    private double mDopplerShiftUncertaintyInHz;
    private byte mMultipathIndicator;
    private double mSnrInDb;
    private double mElevationInDeg;
    private double mElevationUncertaintyInDeg;
    private double mAzimuthInDeg;
    private double mAzimuthUncertaintyInDeg;
    private boolean mUsedInFix;

    // The following enumerations must be in sync with the values declared in gps.h

    private static final int HAS_NO_FLAGS = 0;
    private static final int HAS_SNR = (1<<0);
    private static final int HAS_ELEVATION = (1<<1);
    private static final int HAS_ELEVATION_UNCERTAINTY = (1<<2);
    private static final int HAS_AZIMUTH = (1<<3);
    private static final int HAS_AZIMUTH_UNCERTAINTY = (1<<4);
    private static final int HAS_PSEUDORANGE = (1<<5);
    private static final int HAS_PSEUDORANGE_UNCERTAINTY = (1<<6);
    private static final int HAS_CODE_PHASE = (1<<7);
    private static final int HAS_CODE_PHASE_UNCERTAINTY = (1<<8);
    private static final int HAS_CARRIER_FREQUENCY = (1<<9);
    private static final int HAS_CARRIER_CYCLES = (1<<10);
    private static final int HAS_CARRIER_PHASE = (1<<11);
    private static final int HAS_CARRIER_PHASE_UNCERTAINTY = (1<<12);
    private static final int HAS_BIT_NUMBER = (1<<13);
    private static final int HAS_TIME_FROM_LAST_BIT = (1<<14);
    private static final int HAS_DOPPLER_SHIFT = (1<<15);
    private static final int HAS_DOPPLER_SHIFT_UNCERTAINTY = (1<<16);
    private static final int HAS_USED_IN_FIX = (1<<17);
    private static final int GPS_MEASUREMENT_HAS_UNCORRECTED_PSEUDORANGE_RATE = (1<<18);

    
The indicator is not available or it is unknown.
/**
     * The indicator is not available or it is unknown.
     */
    public static final byte LOSS_OF_LOCK_UNKNOWN = 0;

    
The measurement does not present any indication of 'loss of lock'.
/**
     * The measurement does not present any indication of 'loss of lock'.
     */
    public static final byte LOSS_OF_LOCK_OK = 1;

    
'Loss of lock' detected between the previous and current observation: cycle slip possible.
/**
     * 'Loss of lock' detected between the previous and current observation: cycle slip possible.
     */
    public static final byte LOSS_OF_LOCK_CYCLE_SLIP = 2;

    
The indicator is not available or it is unknown.
/**
     * The indicator is not available or it is unknown.
     */
    public static final byte MULTIPATH_INDICATOR_UNKNOWN = 0;

    
The measurement has been indicated to use multi-path.
/**
     * The measurement has been indicated to use multi-path.
     */
    public static final byte MULTIPATH_INDICATOR_DETECTED = 1;

    
The measurement has been indicated not tu use multi-path.
/**
     * The measurement has been indicated not tu use multi-path.
     */
    public static final byte MULTIPATH_INDICATOR_NOT_USED = 2;

    
The state of GPS receiver the measurement is invalid or unknown.
/**
     * The state of GPS receiver the measurement is invalid or unknown.
     */
    public static final short STATE_UNKNOWN = 0;

    
The state of the GPS receiver is ranging code lock.
/**
     * The state of the GPS receiver is ranging code lock.
     */
    public static final short STATE_CODE_LOCK = (1<<0);

    
The state of the GPS receiver is in bit sync.
/**
     * The state of the GPS receiver is in bit sync.
     */
    public static final short STATE_BIT_SYNC = (1<<1);

    
The state of the GPS receiver is in sub-frame sync.
/**
     *The state of the GPS receiver is in sub-frame sync.
     */
    public static final short STATE_SUBFRAME_SYNC = (1<<2);

    
The state of the GPS receiver has TOW decoded.
/**
     * The state of the GPS receiver has TOW decoded.
     */
    public static final short STATE_TOW_DECODED = (1<<3);

    
The state of the GPS receiver contains millisecond ambiguity.
/**
     * The state of the GPS receiver contains millisecond ambiguity.
     */
    public static final short STATE_MSEC_AMBIGUOUS = (1<<4);

    
All the GPS receiver state flags.
/**
     * All the GPS receiver state flags.
     */
    private static final short STATE_ALL = STATE_CODE_LOCK | STATE_BIT_SYNC | STATE_SUBFRAME_SYNC
            | STATE_TOW_DECODED | STATE_MSEC_AMBIGUOUS;

    
The state of the 'Accumulated Delta Range' is invalid or unknown.
/**
     * The state of the 'Accumulated Delta Range' is invalid or unknown.
     */
    public static final short ADR_STATE_UNKNOWN = 0;

    
The state of the 'Accumulated Delta Range' is valid.
/**
     * The state of the 'Accumulated Delta Range' is valid.
     */
    public static final short ADR_STATE_VALID = (1<<0);

    
The state of the 'Accumulated Delta Range' has detected a reset.
/**
     * The state of the 'Accumulated Delta Range' has detected a reset.
     */
    public static final short ADR_STATE_RESET = (1<<1);

    
The state of the 'Accumulated Delta Range' has a cycle slip detected.
/**
     * The state of the 'Accumulated Delta Range' has a cycle slip detected.
     */
    public static final short ADR_STATE_CYCLE_SLIP = (1<<2);

    
All the 'Accumulated Delta Range' flags.
/**
     * All the 'Accumulated Delta Range' flags.
     */
    private static final short ADR_ALL = ADR_STATE_VALID | ADR_STATE_RESET | ADR_STATE_CYCLE_SLIP;

    // End enumerations in sync with gps.h

    GpsMeasurement() {
        initialize();
    }

    
Sets all contents to the values stored in the provided object.
/**
     * Sets all contents to the values stored in the provided object.
     */
    public void set(GpsMeasurement measurement) {
        mFlags = measurement.mFlags;
        mPrn = measurement.mPrn;
        mTimeOffsetInNs = measurement.mTimeOffsetInNs;
        mState = measurement.mState;
        mReceivedGpsTowInNs = measurement.mReceivedGpsTowInNs;
        mReceivedGpsTowUncertaintyInNs = measurement.mReceivedGpsTowUncertaintyInNs;
        mCn0InDbHz = measurement.mCn0InDbHz;
        mPseudorangeRateInMetersPerSec = measurement.mPseudorangeRateInMetersPerSec;
        mPseudorangeRateUncertaintyInMetersPerSec =
                measurement.mPseudorangeRateUncertaintyInMetersPerSec;
        mAccumulatedDeltaRangeState = measurement.mAccumulatedDeltaRangeState;
        mAccumulatedDeltaRangeInMeters = measurement.mAccumulatedDeltaRangeInMeters;
        mAccumulatedDeltaRangeUncertaintyInMeters =
                measurement.mAccumulatedDeltaRangeUncertaintyInMeters;
        mPseudorangeInMeters = measurement.mPseudorangeInMeters;
        mPseudorangeUncertaintyInMeters = measurement.mPseudorangeUncertaintyInMeters;
        mCodePhaseInChips = measurement.mCodePhaseInChips;
        mCodePhaseUncertaintyInChips = measurement.mCodePhaseUncertaintyInChips;
        mCarrierFrequencyInHz = measurement.mCarrierFrequencyInHz;
        mCarrierCycles = measurement.mCarrierCycles;
        mCarrierPhase = measurement.mCarrierPhase;
        mCarrierPhaseUncertainty = measurement.mCarrierPhaseUncertainty;
        mLossOfLock = measurement.mLossOfLock;
        mBitNumber = measurement.mBitNumber;
        mTimeFromLastBitInMs = measurement.mTimeFromLastBitInMs;
        mDopplerShiftInHz = measurement.mDopplerShiftInHz;
        mDopplerShiftUncertaintyInHz = measurement.mDopplerShiftUncertaintyInHz;
        mMultipathIndicator = measurement.mMultipathIndicator;
        mSnrInDb = measurement.mSnrInDb;
        mElevationInDeg = measurement.mElevationInDeg;
        mElevationUncertaintyInDeg = measurement.mElevationUncertaintyInDeg;
        mAzimuthInDeg = measurement.mAzimuthInDeg;
        mAzimuthUncertaintyInDeg = measurement.mAzimuthUncertaintyInDeg;
        mUsedInFix = measurement.mUsedInFix;
    }

    
Resets all the contents to its original state.
/**
     * Resets all the contents to its original state.
     */
    public void reset() {
        initialize();
    }

    
Gets the Pseudo-random number (PRN).
Range: [1, 32]
/**
     * Gets the Pseudo-random number (PRN).
     * Range: [1, 32]
     */
    public byte getPrn() {
        return mPrn;
    }

    
Sets the Pseud-random number (PRN).
/**
     * Sets the Pseud-random number (PRN).
     */
    public void setPrn(byte value) {
        mPrn = value;
    }

    
Gets the time offset at which the measurement was taken in nanoseconds. The reference receiver's time is specified by GpsClock.getTimeInNs() and should be interpreted in the same way as indicated by GpsClock.getType(). The sign of this value is given by the following equation: measurement time = time_ns + time_offset_ns The value provides an individual time-stamp for the measurement, and allows sub-nanosecond accuracy. /**
     * Gets the time offset at which the measurement was taken in nanoseconds.
     * The reference receiver's time is specified by {@link GpsClock#getTimeInNs()} and should be
     * interpreted in the same way as indicated by {@link GpsClock#getType()}.
     *
     * The sign of this value is given by the following equation:
     *      measurement time = time_ns + time_offset_ns
     *
     * The value provides an individual time-stamp for the measurement, and allows sub-nanosecond
     * accuracy.
     */
    public double getTimeOffsetInNs() {
        return mTimeOffsetInNs;
    }

    
Sets the time offset at which the measurement was taken in nanoseconds.
/**
     * Sets the time offset at which the measurement was taken in nanoseconds.
     */
    public void setTimeOffsetInNs(double value) {
        mTimeOffsetInNs = value;
    }

    
Gets per-satellite sync state. It represents the current sync state for the associated satellite. This value helps interpret getReceivedGpsTowInNs(). /**
     * Gets per-satellite sync state.
     * It represents the current sync state for the associated satellite.
     *
     * This value helps interpret {@link #getReceivedGpsTowInNs()}.
     */
    public short getState() {
        return mState;
    }

    
Sets the sync state.
/**
     * Sets the sync state.
     */
    public void setState(short value) {
        mState = value;
    }

    
Gets a string representation of the 'sync state'.
For internal and logging use only.
/**
     * Gets a string representation of the 'sync state'.
     * For internal and logging use only.
     */
    private String getStateString() {
        if (mState == STATE_UNKNOWN) {
            return "Unknown";
        }
        StringBuilder builder = new StringBuilder();
        if ((mState & STATE_CODE_LOCK) == STATE_CODE_LOCK) {
            builder.append("CodeLock|");
        }
        if ((mState & STATE_BIT_SYNC) == STATE_BIT_SYNC) {
            builder.append("BitSync|");
        }
        if ((mState & STATE_SUBFRAME_SYNC) == STATE_SUBFRAME_SYNC) {
            builder.append("SubframeSync|");
        }
        if ((mState & STATE_TOW_DECODED) == STATE_TOW_DECODED) {
            builder.append("TowDecoded|");
        }
        if ((mState & STATE_MSEC_AMBIGUOUS) == STATE_MSEC_AMBIGUOUS) {
            builder.append("MsecAmbiguous");
        }
        int remainingStates = mState & ~STATE_ALL;
        if (remainingStates > 0) {
            builder.append("Other(");
            builder.append(Integer.toBinaryString(remainingStates));
            builder.append(")|");
        }
        builder.deleteCharAt(builder.length() - 1);
        return builder.toString();
    }

    
Gets the received GPS Time-of-Week at the measurement time, in nanoseconds. The value is relative to the beginning of the current GPS week. Given getState() of the GPS receiver, the range of this field can be: Searching : [ 0 ] : STATE_UNKNOWN is set Ranging code lock : [ 0 1 ms ] : STATE_CODE_LOCK is set Bit sync : [ 0 20 ms ] : STATE_BIT_SYNC is set Subframe sync : [ 0 6 ms ] : STATE_SUBFRAME_SYNC is set TOW decoded : [ 0 1 week ] : STATE_TOW_DECODED is set /**
     * Gets the received GPS Time-of-Week at the measurement time, in nanoseconds.
     * The value is relative to the beginning of the current GPS week.
     *
     * Given {@link #getState()} of the GPS receiver, the range of this field can be:
     *      Searching           : [ 0           ]   : {@link #STATE_UNKNOWN} is set
     *      Ranging code lock   : [ 0    1 ms   ]   : {@link #STATE_CODE_LOCK} is set
     *      Bit sync            : [ 0   20 ms   ]   : {@link #STATE_BIT_SYNC} is set
     *      Subframe sync       : [ 0    6 ms   ]   : {@link #STATE_SUBFRAME_SYNC} is set
     *      TOW decoded         : [ 0    1 week ]   : {@link #STATE_TOW_DECODED} is set
     */
    public long getReceivedGpsTowInNs() {
        return mReceivedGpsTowInNs;
    }

    
Sets the received GPS time-of-week in nanoseconds.
/**
     * Sets the received GPS time-of-week in nanoseconds.
     */
    public void setReceivedGpsTowInNs(long value) {
        mReceivedGpsTowInNs = value;
    }

    
Gets the received GPS time-of-week's uncertainty (1-Sigma) in nanoseconds.
/**
     * Gets the received GPS time-of-week's uncertainty (1-Sigma) in nanoseconds.
     */
    public long getReceivedGpsTowUncertaintyInNs() {
        return mReceivedGpsTowUncertaintyInNs;
    }

    
Sets the received GPS time-of-week's uncertainty (1-Sigma) in nanoseconds.
/**
     * Sets the received GPS time-of-week's uncertainty (1-Sigma) in nanoseconds.
     */
    public void setReceivedGpsTowUncertaintyInNs(long value) {
        mReceivedGpsTowUncertaintyInNs = value;
    }

    
Gets the Carrier-to-noise density in dB-Hz.
Range: [0, 63].
The value contains the measured C/N0 for the signal at the antenna input.
/**
     * Gets the Carrier-to-noise density in dB-Hz.
     * Range: [0, 63].
     *
     * The value contains the measured C/N0 for the signal at the antenna input.
     */
    public double getCn0InDbHz() {
        return mCn0InDbHz;
    }

    
Sets the carrier-to-noise density in dB-Hz.
/**
     * Sets the carrier-to-noise density in dB-Hz.
     */
    public void setCn0InDbHz(double value) {
        mCn0InDbHz = value;
    }

    
Gets the Pseudorange rate at the timestamp in m/s. The reported value includes getPseudorangeRateUncertaintyInMetersPerSec(). The correction of a given Pseudorange Rate value includes corrections from receiver and satellite clock frequency errors. isPseudorangeRateCorrected() identifies the type of value reported. A positive 'uncorrected' value indicates that the SV is moving away from the receiver. The sign of the 'uncorrected' Pseudorange Rate and its relation to the sign of getDopplerShiftInHz() is given by the equation: pseudorange rate = -k * doppler shift (where k is a constant) /**
     * Gets the Pseudorange rate at the timestamp in m/s.
     * The reported value includes {@link #getPseudorangeRateUncertaintyInMetersPerSec()}.
     *
     * The correction of a given Pseudorange Rate value includes corrections from receiver and
     * satellite clock frequency errors.
     * {@link #isPseudorangeRateCorrected()} identifies the type of value reported.
     *
     * A positive 'uncorrected' value indicates that the SV is moving away from the receiver.
     * The sign of the 'uncorrected' Pseudorange Rate and its relation to the sign of
     * {@link #getDopplerShiftInHz()} is given by the equation:
     *      pseudorange rate = -k * doppler shift   (where k is a constant)
     */
    public double getPseudorangeRateInMetersPerSec() {
        return mPseudorangeRateInMetersPerSec;
    }

    
Sets the pseudorange rate at the timestamp in m/s.
/**
     * Sets the pseudorange rate at the timestamp in m/s.
     */
    public void setPseudorangeRateInMetersPerSec(double value) {
        mPseudorangeRateInMetersPerSec = value;
    }

    
See getPseudorangeRateInMetersPerSec() for more details. 
Returns:
true if getPseudorangeRateInMetersPerSec() contains a corrected value, false if it contains an uncorrected value./**
     * See {@link #getPseudorangeRateInMetersPerSec()} for more details.
     *
     * @return {@code true} if {@link #getPseudorangeRateInMetersPerSec()} contains a corrected
     *         value, {@code false} if it contains an uncorrected value.
     */
    public boolean isPseudorangeRateCorrected() {
        return !isFlagSet(GPS_MEASUREMENT_HAS_UNCORRECTED_PSEUDORANGE_RATE);
    }

    
Gets the pseudorange's rate uncertainty (1-Sigma) in m/s.
The uncertainty is represented as an absolute (single sided) value.
/**
     * Gets the pseudorange's rate uncertainty (1-Sigma) in m/s.
     * The uncertainty is represented as an absolute (single sided) value.
     */
    public double getPseudorangeRateUncertaintyInMetersPerSec() {
        return mPseudorangeRateUncertaintyInMetersPerSec;
    }

    
Sets the pseudorange's rate uncertainty (1-Sigma) in m/s.
/**
     * Sets the pseudorange's rate uncertainty (1-Sigma) in m/s.
     */
    public void setPseudorangeRateUncertaintyInMetersPerSec(double value) {
        mPseudorangeRateUncertaintyInMetersPerSec = value;
    }

    
Gets 'Accumulated Delta Range' state. It indicates whether getAccumulatedDeltaRangeInMeters() is reset or there is a cycle slip (indicating 'loss of lock'). /**
     * Gets 'Accumulated Delta Range' state.
     * It indicates whether {@link #getAccumulatedDeltaRangeInMeters()} is reset or there is a
     * cycle slip (indicating 'loss of lock').
     */
    public short getAccumulatedDeltaRangeState() {
        return mAccumulatedDeltaRangeState;
    }

    
Sets the 'Accumulated Delta Range' state.
/**
     * Sets the 'Accumulated Delta Range' state.
     */
    public void setAccumulatedDeltaRangeState(short value) {
        mAccumulatedDeltaRangeState = value;
    }

    
Gets a string representation of the 'Accumulated Delta Range state'.
For internal and logging use only.
/**
     * Gets a string representation of the 'Accumulated Delta Range state'.
     * For internal and logging use only.
     */
    private String getAccumulatedDeltaRangeStateString() {
        if (mAccumulatedDeltaRangeState == ADR_STATE_UNKNOWN) {
            return "Unknown";
        }
        StringBuilder builder = new StringBuilder();
        if ((mAccumulatedDeltaRangeState & ADR_STATE_VALID) == ADR_STATE_VALID) {
            builder.append("Valid|");
        }
        if ((mAccumulatedDeltaRangeState & ADR_STATE_RESET) == ADR_STATE_RESET) {
            builder.append("Reset|");
        }
        if ((mAccumulatedDeltaRangeState & ADR_STATE_CYCLE_SLIP) == ADR_STATE_CYCLE_SLIP) {
            builder.append("CycleSlip|");
        }
        int remainingStates = mAccumulatedDeltaRangeState & ~ADR_ALL;
        if (remainingStates > 0) {
            builder.append("Other(");
            builder.append(Integer.toBinaryString(remainingStates));
            builder.append(")|");
        }
        builder.deleteCharAt(builder.length() - 1);
        return builder.toString();
    }

    
Gets the accumulated delta range since the last channel reset, in meters. The reported value includes getAccumulatedDeltaRangeUncertaintyInMeters(). The availability of the value is represented by getAccumulatedDeltaRangeState(). A positive value indicates that the SV is moving away from the receiver. The sign of getAccumulatedDeltaRangeInMeters() and its relation to the sign of getCarrierPhase() is given by the equation: accumulated delta range = -k * carrier phase (where k is a constant) /**
     * Gets the accumulated delta range since the last channel reset, in meters.
     * The reported value includes {@link #getAccumulatedDeltaRangeUncertaintyInMeters()}.
     *
     * The availability of the value is represented by {@link #getAccumulatedDeltaRangeState()}.
     *
     * A positive value indicates that the SV is moving away from the receiver.
     * The sign of {@link #getAccumulatedDeltaRangeInMeters()} and its relation to the sign of
     * {@link #getCarrierPhase()} is given by the equation:
     *          accumulated delta range = -k * carrier phase    (where k is a constant)
     */
    public double getAccumulatedDeltaRangeInMeters() {
        return mAccumulatedDeltaRangeInMeters;
    }

    
Sets the accumulated delta range in meters.
/**
     * Sets the accumulated delta range in meters.
     */
    public void setAccumulatedDeltaRangeInMeters(double value) {
        mAccumulatedDeltaRangeInMeters = value;
    }

    
Gets the accumulated delta range's uncertainty (1-Sigma) in meters. The uncertainty is represented as an absolute (single sided) value. The status of the value is represented by getAccumulatedDeltaRangeState(). /**
     * Gets the accumulated delta range's uncertainty (1-Sigma) in meters.
     * The uncertainty is represented as an absolute (single sided) value.
     *
     * The status of the value is represented by {@link #getAccumulatedDeltaRangeState()}.
     */
    public double getAccumulatedDeltaRangeUncertaintyInMeters() {
        return mAccumulatedDeltaRangeUncertaintyInMeters;
    }

    
Sets the accumulated delta range's uncertainty (1-sigma) in meters. The status of the value is represented by getAccumulatedDeltaRangeState(). /**
     * Sets the accumulated delta range's uncertainty (1-sigma) in meters.
     *
     * The status of the value is represented by {@link #getAccumulatedDeltaRangeState()}.
     */
    public void setAccumulatedDeltaRangeUncertaintyInMeters(double value) {
        mAccumulatedDeltaRangeUncertaintyInMeters = value;
    }

    
Returns true if getPseudorangeInMeters() is available, false otherwise. /**
     * Returns true if {@link #getPseudorangeInMeters()} is available, false otherwise.
     */
    public boolean hasPseudorangeInMeters() {
        return isFlagSet(HAS_PSEUDORANGE);
    }

    
Gets the best derived pseudorange by the chipset, in meters. The reported pseudorange includes getPseudorangeUncertaintyInMeters(). The value is only available if hasPseudorangeInMeters() is true. /**
     * Gets the best derived pseudorange by the chipset, in meters.
     * The reported pseudorange includes {@link #getPseudorangeUncertaintyInMeters()}.
     *
     * The value is only available if {@link #hasPseudorangeInMeters()} is true.
     */
    public double getPseudorangeInMeters() {
        return mPseudorangeInMeters;
    }

    
Sets the Pseudo-range in meters.
/**
     * Sets the Pseudo-range in meters.
     */
    public void setPseudorangeInMeters(double value) {
        setFlag(HAS_PSEUDORANGE);
        mPseudorangeInMeters = value;
    }

    
Resets the Pseudo-range in meters.
/**
     * Resets the Pseudo-range in meters.
     */
    public void resetPseudorangeInMeters() {
        resetFlag(HAS_PSEUDORANGE);
        mPseudorangeInMeters = Double.NaN;
    }

    
Returns true if getPseudorangeUncertaintyInMeters() is available, false otherwise. /**
     * Returns true if {@link #getPseudorangeUncertaintyInMeters()} is available, false otherwise.
     */
    public boolean hasPseudorangeUncertaintyInMeters() {
        return isFlagSet(HAS_PSEUDORANGE_UNCERTAINTY);
    }

    
Gets the pseudorange's uncertainty (1-Sigma) in meters. The value contains the 'pseudorange' and 'clock' uncertainty in it. The uncertainty is represented as an absolute (single sided) value. The value is only available if hasPseudorangeUncertaintyInMeters() is true. /**
     * Gets the pseudorange's uncertainty (1-Sigma) in meters.
     * The value contains the 'pseudorange' and 'clock' uncertainty in it.
     * The uncertainty is represented as an absolute (single sided) value.
     *
     * The value is only available if {@link #hasPseudorangeUncertaintyInMeters()} is true.
     */
    public double getPseudorangeUncertaintyInMeters() {
        return mPseudorangeUncertaintyInMeters;
    }

    
Sets the pseudo-range's uncertainty (1-Sigma) in meters.
/**
     * Sets the pseudo-range's uncertainty (1-Sigma) in meters.
     */
    public void setPseudorangeUncertaintyInMeters(double value) {
        setFlag(HAS_PSEUDORANGE_UNCERTAINTY);
        mPseudorangeUncertaintyInMeters = value;
    }

    
Resets the pseudo-range's uncertainty (1-Sigma) in meters.
/**
     * Resets the pseudo-range's uncertainty (1-Sigma) in meters.
     */
    public void resetPseudorangeUncertaintyInMeters() {
        resetFlag(HAS_PSEUDORANGE_UNCERTAINTY);
        mPseudorangeUncertaintyInMeters = Double.NaN;
    }

    
Returns true if getCodePhaseInChips() is available, false otherwise. /**
     * Returns true if {@link #getCodePhaseInChips()} is available, false otherwise.
     */
    public boolean hasCodePhaseInChips() {
        return isFlagSet(HAS_CODE_PHASE);
    }

    
Gets the fraction of the current C/A code cycle. Range: [0, 1023] The reference frequency is given by the value of getCarrierFrequencyInHz(). The reported code-phase includes getCodePhaseUncertaintyInChips(). The value is only available if hasCodePhaseInChips() is true. /**
     * Gets the fraction of the current C/A code cycle.
     * Range: [0, 1023]
     * The reference frequency is given by the value of {@link #getCarrierFrequencyInHz()}.
     * The reported code-phase includes {@link #getCodePhaseUncertaintyInChips()}.
     *
     * The value is only available if {@link #hasCodePhaseInChips()} is true.
     */
    public double getCodePhaseInChips() {
        return mCodePhaseInChips;
    }

    
Sets the Code-phase in chips.
/**
     * Sets the Code-phase in chips.
     */
    public void setCodePhaseInChips(double value) {
        setFlag(HAS_CODE_PHASE);
        mCodePhaseInChips = value;
    }

    
Resets the Code-phase in chips.
/**
     * Resets the Code-phase in chips.
     */
    public void resetCodePhaseInChips() {
        resetFlag(HAS_CODE_PHASE);
        mCodePhaseInChips = Double.NaN;
    }

    
Returns true if getCodePhaseUncertaintyInChips() is available, false otherwise. /**
     * Returns true if {@link #getCodePhaseUncertaintyInChips()} is available, false otherwise.
     */
    public boolean hasCodePhaseUncertaintyInChips() {
        return isFlagSet(HAS_CODE_PHASE_UNCERTAINTY);
    }

    
Gets the code-phase's uncertainty (1-Sigma) as a fraction of chips. The uncertainty is represented as an absolute (single sided) value. The value is only available if hasCodePhaseUncertaintyInChips() is true. /**
     * Gets the code-phase's uncertainty (1-Sigma) as a fraction of chips.
     * The uncertainty is represented as an absolute (single sided) value.
     *
     * The value is only available if {@link #hasCodePhaseUncertaintyInChips()} is true.
     */
    public double getCodePhaseUncertaintyInChips() {
        return mCodePhaseUncertaintyInChips;
    }

    
Sets the Code-phase's uncertainty (1-Sigma) in fractions of chips.
/**
     * Sets the Code-phase's uncertainty (1-Sigma) in fractions of chips.
     */
    public void setCodePhaseUncertaintyInChips(double value) {
        setFlag(HAS_CODE_PHASE_UNCERTAINTY);
        mCodePhaseUncertaintyInChips = value;
    }

    
Resets the Code-phase's uncertainty (1-Sigma) in fractions of chips.
/**
     * Resets the Code-phase's uncertainty (1-Sigma) in fractions of chips.
     */
    public void resetCodePhaseUncertaintyInChips() {
        resetFlag(HAS_CODE_PHASE_UNCERTAINTY);
        mCodePhaseUncertaintyInChips = Double.NaN;
    }

    
Returns true if getCarrierFrequencyInHz() is available, false otherwise. /**
     * Returns true if {@link #getCarrierFrequencyInHz()} is available, false otherwise.
     */
    public boolean hasCarrierFrequencyInHz() {
        return isFlagSet(HAS_CARRIER_FREQUENCY);
    }

    
Gets the carrier frequency at which codes and messages are modulated, it can be L1 or L2. If the field is not set, the carrier frequency corresponds to L1. The value is only available if hasCarrierFrequencyInHz() is true. /**
     * Gets the carrier frequency at which codes and messages are modulated, it can be L1 or L2.
     * If the field is not set, the carrier frequency corresponds to L1.
     *
     * The value is only available if {@link #hasCarrierFrequencyInHz()} is true.
     */
    public float getCarrierFrequencyInHz() {
        return mCarrierFrequencyInHz;
    }

    
Sets the Carrier frequency (L1 or L2) in Hz.
/**
     * Sets the Carrier frequency (L1 or L2) in Hz.
     */
    public void setCarrierFrequencyInHz(float carrierFrequencyInHz) {
        setFlag(HAS_CARRIER_FREQUENCY);
        mCarrierFrequencyInHz = carrierFrequencyInHz;
    }

    
Resets the Carrier frequency (L1 or L2) in Hz.
/**
     * Resets the Carrier frequency (L1 or L2) in Hz.
     */
    public void resetCarrierFrequencyInHz() {
        resetFlag(HAS_CARRIER_FREQUENCY);
        mCarrierFrequencyInHz = Float.NaN;
    }

    
Returns true if getCarrierCycles() is available, false otherwise. /**
     * Returns true if {@link #getCarrierCycles()} is available, false otherwise.
     */
    public boolean hasCarrierCycles() {
        return isFlagSet(HAS_CARRIER_CYCLES);
    }

    
The number of full carrier cycles between the satellite and the receiver. The reference frequency is given by the value of getCarrierFrequencyInHz(). The value is only available if hasCarrierCycles() is true. /**
     * The number of full carrier cycles between the satellite and the receiver.
     * The reference frequency is given by the value of {@link #getCarrierFrequencyInHz()}.
     *
     * The value is only available if {@link #hasCarrierCycles()} is true.
     */
    public long getCarrierCycles() {
        return mCarrierCycles;
    }

    
Sets the number of full carrier cycles between the satellite and the receiver.
/**
     * Sets the number of full carrier cycles between the satellite and the receiver.
     */
    public void setCarrierCycles(long value) {
        setFlag(HAS_CARRIER_CYCLES);
        mCarrierCycles = value;
    }

    
Resets the number of full carrier cycles between the satellite and the receiver.
/**
     * Resets the number of full carrier cycles between the satellite and the receiver.
     */
    public void resetCarrierCycles() {
        resetFlag(HAS_CARRIER_CYCLES);
        mCarrierCycles = Long.MIN_VALUE;
    }

    
Returns true if getCarrierPhase() is available, false otherwise. /**
     * Returns true if {@link #getCarrierPhase()} is available, false otherwise.
     */
    public boolean hasCarrierPhase() {
        return isFlagSet(HAS_CARRIER_PHASE);
    }

    
Gets the RF phase detected by the receiver. Range: [0.0, 1.0]. This is usually the fractional part of the complete carrier phase measurement. The reference frequency is given by the value of getCarrierFrequencyInHz(). The reported carrier-phase includes getCarrierPhaseUncertainty(). The value is only available if hasCarrierPhase() is true. /**
     * Gets the RF phase detected by the receiver.
     * Range: [0.0, 1.0].
     * This is usually the fractional part of the complete carrier phase measurement.
     *
     * The reference frequency is given by the value of {@link #getCarrierFrequencyInHz()}.
     * The reported carrier-phase includes {@link #getCarrierPhaseUncertainty()}.
     *
     * The value is only available if {@link #hasCarrierPhase()} is true.
     */
    public double getCarrierPhase() {
        return mCarrierPhase;
    }

    
Sets the RF phase detected by the receiver.
/**
     * Sets the RF phase detected by the receiver.
     */
    public void setCarrierPhase(double value) {
        setFlag(HAS_CARRIER_PHASE);
        mCarrierPhase = value;
    }

    
Resets the RF phase detected by the receiver.
/**
     * Resets the RF phase detected by the receiver.
     */
    public void resetCarrierPhase() {
        resetFlag(HAS_CARRIER_PHASE);
        mCarrierPhase = Double.NaN;
    }

    
Returns true if getCarrierPhaseUncertainty() is available, false otherwise. /**
     * Returns true if {@link #getCarrierPhaseUncertainty()} is available, false otherwise.
     */
    public boolean hasCarrierPhaseUncertainty() {
        return isFlagSet(HAS_CARRIER_PHASE_UNCERTAINTY);
    }

    
Gets the carrier-phase's uncertainty (1-Sigma). The uncertainty is represented as an absolute (single sided) value. The value is only available if hasCarrierPhaseUncertainty() is true. /**
     * Gets the carrier-phase's uncertainty (1-Sigma).
     * The uncertainty is represented as an absolute (single sided) value.
     *
     * The value is only available if {@link #hasCarrierPhaseUncertainty()} is true.
     */
    public double getCarrierPhaseUncertainty() {
        return mCarrierPhaseUncertainty;
    }

    
Sets the Carrier-phase's uncertainty (1-Sigma) in cycles.
/**
     * Sets the Carrier-phase's uncertainty (1-Sigma) in cycles.
     */
    public void setCarrierPhaseUncertainty(double value) {
        setFlag(HAS_CARRIER_PHASE_UNCERTAINTY);
        mCarrierPhaseUncertainty = value;
    }

    
Resets the Carrier-phase's uncertainty (1-Sigma) in cycles.
/**
     * Resets the Carrier-phase's uncertainty (1-Sigma) in cycles.
     */
    public void resetCarrierPhaseUncertainty() {
        resetFlag(HAS_CARRIER_PHASE_UNCERTAINTY);
        mCarrierPhaseUncertainty = Double.NaN;
    }

    
Gets a value indicating the 'loss of lock' state of the event.
/**
     * Gets a value indicating the 'loss of lock' state of the event.
     */
    public byte getLossOfLock() {
        return mLossOfLock;
    }

    
Sets the 'loss of lock' status.
/**
     * Sets the 'loss of lock' status.
     */
    public void setLossOfLock(byte value) {
        mLossOfLock = value;
    }

    
Gets a string representation of the 'loss of lock'.
For internal and logging use only.
/**
     * Gets a string representation of the 'loss of lock'.
     * For internal and logging use only.
     */
    private String getLossOfLockString() {
        switch (mLossOfLock) {
            case LOSS_OF_LOCK_UNKNOWN:
                return "Unknown";
            case LOSS_OF_LOCK_OK:
                return "Ok";
            case LOSS_OF_LOCK_CYCLE_SLIP:
                return "CycleSlip";
            default:
                return "<Invalid:" + mLossOfLock + ">";
        }
    }

    
Returns true if getBitNumber() is available, false otherwise. /**
     * Returns true if {@link #getBitNumber()} is available, false otherwise.
     */
    public boolean hasBitNumber() {
        return isFlagSet(HAS_BIT_NUMBER);
    }

    
Gets the number of GPS bits transmitted since Sat-Sun midnight (GPS week). The value is only available if hasBitNumber() is true. /**
     * Gets the number of GPS bits transmitted since Sat-Sun midnight (GPS week).
     *
     * The value is only available if {@link #hasBitNumber()} is true.
     */
    public int getBitNumber() {
        return mBitNumber;
    }

    
Sets the bit number within the broadcast frame.
/**
     * Sets the bit number within the broadcast frame.
     */
    public void setBitNumber(int bitNumber) {
        setFlag(HAS_BIT_NUMBER);
        mBitNumber = bitNumber;
    }

    
Resets the bit number within the broadcast frame.
/**
     * Resets the bit number within the broadcast frame.
     */
    public void resetBitNumber() {
        resetFlag(HAS_BIT_NUMBER);
        mBitNumber = Integer.MIN_VALUE;
    }

    
Returns true if getTimeFromLastBitInMs() is available, false otherwise. /**
     * Returns true if {@link #getTimeFromLastBitInMs()} is available, false otherwise.
     */
    public boolean hasTimeFromLastBitInMs() {
        return isFlagSet(HAS_TIME_FROM_LAST_BIT);
    }

    
Gets the elapsed time since the last received bit in milliseconds. Range: [0, 20]. The value is only available if hasTimeFromLastBitInMs() is true. /**
     * Gets the elapsed time since the last received bit in milliseconds.
     * Range: [0, 20].
     *
     * The value is only available if {@link #hasTimeFromLastBitInMs()} is true.
     */
    public short getTimeFromLastBitInMs() {
        return mTimeFromLastBitInMs;
    }

    
Sets the elapsed time since the last received bit in milliseconds.
/**
     * Sets the elapsed time since the last received bit in milliseconds.
     */
    public void setTimeFromLastBitInMs(short value) {
        setFlag(HAS_TIME_FROM_LAST_BIT);
        mTimeFromLastBitInMs = value;
    }

    
Resets the elapsed time since the last received bit in milliseconds.
/**
     * Resets the elapsed time since the last received bit in milliseconds.
     */
    public void resetTimeFromLastBitInMs() {
        resetFlag(HAS_TIME_FROM_LAST_BIT);
        mTimeFromLastBitInMs = Short.MIN_VALUE;
    }

    
Returns true if getDopplerShiftInHz() is available, false otherwise. /**
     * Returns true if {@link #getDopplerShiftInHz()} is available, false otherwise.
     */
    public boolean hasDopplerShiftInHz() {
        return isFlagSet(HAS_DOPPLER_SHIFT);
    }

    
Gets the Doppler Shift in Hz. A positive value indicates that the SV is moving toward the receiver. The reference frequency is given by the value of getCarrierFrequencyInHz(). The reported doppler shift includes getDopplerShiftUncertaintyInHz(). The value is only available if hasDopplerShiftInHz() is true. /**
     * Gets the Doppler Shift in Hz.
     * A positive value indicates that the SV is moving toward the receiver.
     *
     * The reference frequency is given by the value of {@link #getCarrierFrequencyInHz()}.
     * The reported doppler shift includes {@link #getDopplerShiftUncertaintyInHz()}.
     *
     * The value is only available if {@link #hasDopplerShiftInHz()} is true.
     */
    public double getDopplerShiftInHz() {
        return mDopplerShiftInHz;
    }

    
Sets the Doppler shift in Hz.
/**
     * Sets the Doppler shift in Hz.
     */
    public void setDopplerShiftInHz(double value) {
        setFlag(HAS_DOPPLER_SHIFT);
        mDopplerShiftInHz = value;
    }

    
Resets the Doppler shift in Hz.
/**
     * Resets the Doppler shift in Hz.
     */
    public void resetDopplerShiftInHz() {
        resetFlag(HAS_DOPPLER_SHIFT);
        mDopplerShiftInHz = Double.NaN;
    }

    
Returns true if getDopplerShiftUncertaintyInHz() is available, false otherwise. /**
     * Returns true if {@link #getDopplerShiftUncertaintyInHz()} is available, false otherwise.
     */
    public boolean hasDopplerShiftUncertaintyInHz() {
        return isFlagSet(HAS_DOPPLER_SHIFT_UNCERTAINTY);
    }

    
Gets the Doppler's Shift uncertainty (1-Sigma) in Hz. The uncertainty is represented as an absolute (single sided) value. The value is only available if hasDopplerShiftUncertaintyInHz() is true. /**
     * Gets the Doppler's Shift uncertainty (1-Sigma) in Hz.
     * The uncertainty is represented as an absolute (single sided) value.
     *
     * The value is only available if {@link #hasDopplerShiftUncertaintyInHz()} is true.
     */
    public double getDopplerShiftUncertaintyInHz() {
        return mDopplerShiftUncertaintyInHz;
    }

    
Sets the Doppler's shift uncertainty (1-Sigma) in Hz.
/**
     * Sets the Doppler's shift uncertainty (1-Sigma) in Hz.
     */
    public void setDopplerShiftUncertaintyInHz(double value) {
        setFlag(HAS_DOPPLER_SHIFT_UNCERTAINTY);
        mDopplerShiftUncertaintyInHz = value;
    }

    
Resets the Doppler's shift uncertainty (1-Sigma) in Hz.
/**
     * Resets the Doppler's shift uncertainty (1-Sigma) in Hz.
     */
    public void resetDopplerShiftUncertaintyInHz() {
        resetFlag(HAS_DOPPLER_SHIFT_UNCERTAINTY);
        mDopplerShiftUncertaintyInHz = Double.NaN;
    }

    
Gets a value indicating the 'multipath' state of the event.
/**
     * Gets a value indicating the 'multipath' state of the event.
     */
    public byte getMultipathIndicator() {
        return mMultipathIndicator;
    }

    
Sets the 'multi-path' indicator.
/**
     * Sets the 'multi-path' indicator.
     */
    public void setMultipathIndicator(byte value) {
        mMultipathIndicator = value;
    }

    
Gets a string representation of the 'multi-path indicator'.
For internal and logging use only.
/**
     * Gets a string representation of the 'multi-path indicator'.
     * For internal and logging use only.
     */
    private String getMultipathIndicatorString() {
        switch(mMultipathIndicator) {
            case MULTIPATH_INDICATOR_UNKNOWN:
                return "Unknown";
            case MULTIPATH_INDICATOR_DETECTED:
                return "Detected";
            case MULTIPATH_INDICATOR_NOT_USED:
                return "NotUsed";
            default:
                return "<Invalid:" + mMultipathIndicator + ">";
        }
    }

    
Returns true if getSnrInDb() is available, false otherwise. /**
     * Returns true if {@link #getSnrInDb()} is available, false otherwise.
     */
    public boolean hasSnrInDb() {
        return isFlagSet(HAS_SNR);
    }

    
Gets the Signal-to-Noise ratio (SNR) in dB. The value is only available if hasSnrInDb() is true. /**
     * Gets the Signal-to-Noise ratio (SNR) in dB.
     *
     * The value is only available if {@link #hasSnrInDb()} is true.
     */
    public double getSnrInDb() {
        return mSnrInDb;
    }

    
Sets the Signal-to-noise ratio (SNR) in dB.
/**
     * Sets the Signal-to-noise ratio (SNR) in dB.
     */
    public void setSnrInDb(double snrInDb) {
        setFlag(HAS_SNR);
        mSnrInDb = snrInDb;
    }

    
Resets the Signal-to-noise ratio (SNR) in dB.
/**
     * Resets the Signal-to-noise ratio (SNR) in dB.
     */
    public void resetSnrInDb() {
        resetFlag(HAS_SNR);
        mSnrInDb = Double.NaN;
    }

    
Returns true if getElevationInDeg() is available, false otherwise. /**
     * Returns true if {@link #getElevationInDeg()} is available, false otherwise.
     */
    public boolean hasElevationInDeg() {
        return isFlagSet(HAS_ELEVATION);
    }

    
Gets the Elevation in degrees. Range: [-90, 90] The reported elevation includes getElevationUncertaintyInDeg(). The value is only available if hasElevationInDeg() is true. /**
     * Gets the Elevation in degrees.
     * Range: [-90, 90]
     * The reported elevation includes {@link #getElevationUncertaintyInDeg()}.
     *
     * The value is only available if {@link #hasElevationInDeg()} is true.
     */
    public double getElevationInDeg() {
        return mElevationInDeg;
    }

    
Sets the Elevation in degrees.
/**
     * Sets the Elevation in degrees.
     */
    public void setElevationInDeg(double elevationInDeg) {
        setFlag(HAS_ELEVATION);
        mElevationInDeg = elevationInDeg;
    }

    
Resets the Elevation in degrees.
/**
     * Resets the Elevation in degrees.
     */
    public void resetElevationInDeg() {
        resetFlag(HAS_ELEVATION);
        mElevationInDeg = Double.NaN;
    }

    
Returns true if getElevationUncertaintyInDeg() is available, false otherwise. /**
     * Returns true if {@link #getElevationUncertaintyInDeg()} is available, false otherwise.
     */
    public boolean hasElevationUncertaintyInDeg() {
        return isFlagSet(HAS_ELEVATION_UNCERTAINTY);
    }

    
Gets the elevation's uncertainty (1-Sigma) in degrees. Range: [0, 90] The uncertainty is represented as an absolute (single sided) value. The value is only available if hasElevationUncertaintyInDeg() is true. /**
     * Gets the elevation's uncertainty (1-Sigma) in degrees.
     * Range: [0, 90]
     *
     * The uncertainty is represented as an absolute (single sided) value.
     *
     * The value is only available if {@link #hasElevationUncertaintyInDeg()} is true.
     */
    public double getElevationUncertaintyInDeg() {
        return mElevationUncertaintyInDeg;
    }

    
Sets the elevation's uncertainty (1-Sigma) in degrees.
/**
     * Sets the elevation's uncertainty (1-Sigma) in degrees.
     */
    public void setElevationUncertaintyInDeg(double value) {
        setFlag(HAS_ELEVATION_UNCERTAINTY);
        mElevationUncertaintyInDeg = value;
    }

    
Resets the elevation's uncertainty (1-Sigma) in degrees.
/**
     * Resets the elevation's uncertainty (1-Sigma) in degrees.
     */
    public void resetElevationUncertaintyInDeg() {
        resetFlag(HAS_ELEVATION_UNCERTAINTY);
        mElevationUncertaintyInDeg = Double.NaN;
    }

    
Returns true if getAzimuthInDeg() is available, false otherwise. /**
     * Returns true if {@link #getAzimuthInDeg()} is available, false otherwise.
     */
    public boolean hasAzimuthInDeg() {
        return isFlagSet(HAS_AZIMUTH);
    }

    
Gets the azimuth in degrees. Range: [0, 360). The reported azimuth includes getAzimuthUncertaintyInDeg(). The value is only available if hasAzimuthInDeg() is true. /**
     * Gets the azimuth in degrees.
     * Range: [0, 360).
     *
     * The reported azimuth includes {@link #getAzimuthUncertaintyInDeg()}.
     *
     * The value is only available if {@link #hasAzimuthInDeg()} is true.
     */
    public double getAzimuthInDeg() {
        return mAzimuthInDeg;
    }

    
Sets the Azimuth in degrees.
/**
     * Sets the Azimuth in degrees.
     */
    public void setAzimuthInDeg(double value) {
        setFlag(HAS_AZIMUTH);
        mAzimuthInDeg = value;
    }

    
Resets the Azimuth in degrees.
/**
     * Resets the Azimuth in degrees.
     */
    public void resetAzimuthInDeg() {
        resetFlag(HAS_AZIMUTH);
        mAzimuthInDeg = Double.NaN;
    }

    
Returns true if getAzimuthUncertaintyInDeg() is available, false otherwise. /**
     * Returns true if {@link #getAzimuthUncertaintyInDeg()} is available, false otherwise.
     */
    public boolean hasAzimuthUncertaintyInDeg() {
        return isFlagSet(HAS_AZIMUTH_UNCERTAINTY);
    }

    
Gets the azimuth's uncertainty (1-Sigma) in degrees. Range: [0, 180]. The uncertainty is represented as an absolute (single sided) value. The value is only available if hasAzimuthUncertaintyInDeg() is true. /**
     * Gets the azimuth's uncertainty (1-Sigma) in degrees.
     * Range: [0, 180].
     *
     * The uncertainty is represented as an absolute (single sided) value.
     *
     * The value is only available if {@link #hasAzimuthUncertaintyInDeg()} is true.
     */
    public double getAzimuthUncertaintyInDeg() {
        return mAzimuthUncertaintyInDeg;
    }

    
Sets the Azimuth's uncertainty (1-Sigma) in degrees.
/**
     * Sets the Azimuth's uncertainty (1-Sigma) in degrees.
     */
    public void setAzimuthUncertaintyInDeg(double value) {
        setFlag(HAS_AZIMUTH_UNCERTAINTY);
        mAzimuthUncertaintyInDeg = value;
    }

    
Resets the Azimuth's uncertainty (1-Sigma) in degrees.
/**
     * Resets the Azimuth's uncertainty (1-Sigma) in degrees.
     */
    public void resetAzimuthUncertaintyInDeg() {
        resetFlag(HAS_AZIMUTH_UNCERTAINTY);
        mAzimuthUncertaintyInDeg = Double.NaN;
    }

    
Gets a flag indicating whether the GPS represented by the measurement was used for computing
the most recent fix.
Returns:
A non-null value if the data is available, null otherwise./**
     * Gets a flag indicating whether the GPS represented by the measurement was used for computing
     * the most recent fix.
     *
     * @return A non-null value if the data is available, null otherwise.
     */
    public boolean isUsedInFix() {
        return mUsedInFix;
    }

    
Sets the Used-in-Fix flag.
/**
     * Sets the Used-in-Fix flag.
     */
    public void setUsedInFix(boolean value) {
        mUsedInFix = value;
    }

    public static final Creator<GpsMeasurement> CREATOR = new Creator<GpsMeasurement>() {
        @Override
        public GpsMeasurement createFromParcel(Parcel parcel) {
            GpsMeasurement gpsMeasurement = new GpsMeasurement();

            gpsMeasurement.mFlags = parcel.readInt();
            gpsMeasurement.mPrn = parcel.readByte();
            gpsMeasurement.mTimeOffsetInNs = parcel.readDouble();
            gpsMeasurement.mState = (short) parcel.readInt();
            gpsMeasurement.mReceivedGpsTowInNs = parcel.readLong();
            gpsMeasurement.mReceivedGpsTowUncertaintyInNs = parcel.readLong();
            gpsMeasurement.mCn0InDbHz = parcel.readDouble();
            gpsMeasurement.mPseudorangeRateInMetersPerSec = parcel.readDouble();
            gpsMeasurement.mPseudorangeRateUncertaintyInMetersPerSec = parcel.readDouble();
            gpsMeasurement.mAccumulatedDeltaRangeState = (short) parcel.readInt();
            gpsMeasurement.mAccumulatedDeltaRangeInMeters = parcel.readDouble();
            gpsMeasurement.mAccumulatedDeltaRangeUncertaintyInMeters = parcel.readDouble();
            gpsMeasurement.mPseudorangeInMeters = parcel.readDouble();
            gpsMeasurement.mPseudorangeUncertaintyInMeters = parcel.readDouble();
            gpsMeasurement.mCodePhaseInChips = parcel.readDouble();
            gpsMeasurement.mCodePhaseUncertaintyInChips = parcel.readDouble();
            gpsMeasurement.mCarrierFrequencyInHz = parcel.readFloat();
            gpsMeasurement.mCarrierCycles = parcel.readLong();
            gpsMeasurement.mCarrierPhase = parcel.readDouble();
            gpsMeasurement.mCarrierPhaseUncertainty = parcel.readDouble();
            gpsMeasurement.mLossOfLock = parcel.readByte();
            gpsMeasurement.mBitNumber = parcel.readInt();
            gpsMeasurement.mTimeFromLastBitInMs = (short) parcel.readInt();
            gpsMeasurement.mDopplerShiftInHz = parcel.readDouble();
            gpsMeasurement.mDopplerShiftUncertaintyInHz = parcel.readDouble();
            gpsMeasurement.mMultipathIndicator = parcel.readByte();
            gpsMeasurement.mSnrInDb = parcel.readDouble();
            gpsMeasurement.mElevationInDeg = parcel.readDouble();
            gpsMeasurement.mElevationUncertaintyInDeg = parcel.readDouble();
            gpsMeasurement.mAzimuthInDeg = parcel.readDouble();
            gpsMeasurement.mAzimuthUncertaintyInDeg = parcel.readDouble();
            gpsMeasurement.mUsedInFix = parcel.readInt() != 0;

            return gpsMeasurement;
        }

        @Override
        public GpsMeasurement[] newArray(int i) {
            return new GpsMeasurement[i];
        }
    };

    public void writeToParcel(Parcel parcel, int flags) {
        parcel.writeInt(mFlags);
        parcel.writeByte(mPrn);
        parcel.writeDouble(mTimeOffsetInNs);
        parcel.writeInt(mState);
        parcel.writeLong(mReceivedGpsTowInNs);
        parcel.writeLong(mReceivedGpsTowUncertaintyInNs);
        parcel.writeDouble(mCn0InDbHz);
        parcel.writeDouble(mPseudorangeRateInMetersPerSec);
        parcel.writeDouble(mPseudorangeRateUncertaintyInMetersPerSec);
        parcel.writeInt(mAccumulatedDeltaRangeState);
        parcel.writeDouble(mAccumulatedDeltaRangeInMeters);
        parcel.writeDouble(mAccumulatedDeltaRangeUncertaintyInMeters);
        parcel.writeDouble(mPseudorangeInMeters);
        parcel.writeDouble(mPseudorangeUncertaintyInMeters);
        parcel.writeDouble(mCodePhaseInChips);
        parcel.writeDouble(mCodePhaseUncertaintyInChips);
        parcel.writeFloat(mCarrierFrequencyInHz);
        parcel.writeLong(mCarrierCycles);
        parcel.writeDouble(mCarrierPhase);
        parcel.writeDouble(mCarrierPhaseUncertainty);
        parcel.writeByte(mLossOfLock);
        parcel.writeInt(mBitNumber);
        parcel.writeInt(mTimeFromLastBitInMs);
        parcel.writeDouble(mDopplerShiftInHz);
        parcel.writeDouble(mDopplerShiftUncertaintyInHz);
        parcel.writeByte(mMultipathIndicator);
        parcel.writeDouble(mSnrInDb);
        parcel.writeDouble(mElevationInDeg);
        parcel.writeDouble(mElevationUncertaintyInDeg);
        parcel.writeDouble(mAzimuthInDeg);
        parcel.writeDouble(mAzimuthUncertaintyInDeg);
        parcel.writeInt(mUsedInFix ? 1 : 0);
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public String toString() {
        final String format = "   %-29s = %s\n";
        final String formatWithUncertainty = "   %-29s = %-25s   %-40s = %s\n";
        StringBuilder builder = new StringBuilder("GpsMeasurement:\n");

        builder.append(String.format(format, "Prn", mPrn));

        builder.append(String.format(format, "TimeOffsetInNs", mTimeOffsetInNs));

        builder.append(String.format(format, "State", getStateString()));

        builder.append(String.format(
                formatWithUncertainty,
                "ReceivedGpsTowInNs",
                mReceivedGpsTowInNs,
                "ReceivedGpsTowUncertaintyInNs",
                mReceivedGpsTowUncertaintyInNs));

        builder.append(String.format(format, "Cn0InDbHz", mCn0InDbHz));

        builder.append(String.format(
                formatWithUncertainty,
                "PseudorangeRateInMetersPerSec",
                mPseudorangeRateInMetersPerSec,
                "PseudorangeRateUncertaintyInMetersPerSec",
                mPseudorangeRateUncertaintyInMetersPerSec));
        builder.append(String.format(
                format,
                "PseudorangeRateIsCorrected",
                isPseudorangeRateCorrected()));

        builder.append(String.format(
                format,
                "AccumulatedDeltaRangeState",
                getAccumulatedDeltaRangeStateString()));

        builder.append(String.format(
                formatWithUncertainty,
                "AccumulatedDeltaRangeInMeters",
                mAccumulatedDeltaRangeInMeters,
                "AccumulatedDeltaRangeUncertaintyInMeters",
                mAccumulatedDeltaRangeUncertaintyInMeters));

        builder.append(String.format(
                formatWithUncertainty,
                "PseudorangeInMeters",
                hasPseudorangeInMeters() ? mPseudorangeInMeters : null,
                "PseudorangeUncertaintyInMeters",
                hasPseudorangeUncertaintyInMeters() ? mPseudorangeUncertaintyInMeters : null));

        builder.append(String.format(
                formatWithUncertainty,
                "CodePhaseInChips",
                hasCodePhaseInChips() ? mCodePhaseInChips : null,
                "CodePhaseUncertaintyInChips",
                hasCodePhaseUncertaintyInChips() ? mCodePhaseUncertaintyInChips : null));

        builder.append(String.format(
                format,
                "CarrierFrequencyInHz",
                hasCarrierFrequencyInHz() ? mCarrierFrequencyInHz : null));

        builder.append(String.format(
                format,
                "CarrierCycles",
                hasCarrierCycles() ? mCarrierCycles : null));

        builder.append(String.format(
                formatWithUncertainty,
                "CarrierPhase",
                hasCarrierPhase() ? mCarrierPhase : null,
                "CarrierPhaseUncertainty",
                hasCarrierPhaseUncertainty() ? mCarrierPhaseUncertainty : null));

        builder.append(String.format(format, "LossOfLock", getLossOfLockString()));

        builder.append(String.format(
                format,
                "BitNumber",
                hasBitNumber() ? mBitNumber : null));

        builder.append(String.format(
                format,
                "TimeFromLastBitInMs",
                hasTimeFromLastBitInMs() ? mTimeFromLastBitInMs : null));

        builder.append(String.format(
                formatWithUncertainty,
                "DopplerShiftInHz",
                hasDopplerShiftInHz() ? mDopplerShiftInHz : null,
                "DopplerShiftUncertaintyInHz",
                hasDopplerShiftUncertaintyInHz() ? mDopplerShiftUncertaintyInHz : null));

        builder.append(String.format(format, "MultipathIndicator", getMultipathIndicatorString()));

        builder.append(String.format(
                format,
                "SnrInDb",
                hasSnrInDb() ? mSnrInDb : null));

        builder.append(String.format(
                formatWithUncertainty,
                "ElevationInDeg",
                hasElevationInDeg() ? mElevationInDeg : null,
                "ElevationUncertaintyInDeg",
                hasElevationUncertaintyInDeg() ? mElevationUncertaintyInDeg : null));

        builder.append(String.format(
                formatWithUncertainty,
                "AzimuthInDeg",
                hasAzimuthInDeg() ? mAzimuthInDeg : null,
                "AzimuthUncertaintyInDeg",
                hasAzimuthUncertaintyInDeg() ? mAzimuthUncertaintyInDeg : null));

        builder.append(String.format(format, "UsedInFix", mUsedInFix));

        return builder.toString();
    }

    private void initialize() {
        mFlags = HAS_NO_FLAGS;
        setPrn(Byte.MIN_VALUE);
        setTimeOffsetInNs(Long.MIN_VALUE);
        setState(STATE_UNKNOWN);
        setReceivedGpsTowInNs(Long.MIN_VALUE);
        setReceivedGpsTowUncertaintyInNs(Long.MAX_VALUE);
        setCn0InDbHz(Double.MIN_VALUE);
        setPseudorangeRateInMetersPerSec(Double.MIN_VALUE);
        setPseudorangeRateUncertaintyInMetersPerSec(Double.MIN_VALUE);
        setAccumulatedDeltaRangeState(ADR_STATE_UNKNOWN);
        setAccumulatedDeltaRangeInMeters(Double.MIN_VALUE);
        setAccumulatedDeltaRangeUncertaintyInMeters(Double.MIN_VALUE);
        resetPseudorangeInMeters();
        resetPseudorangeUncertaintyInMeters();
        resetCodePhaseInChips();
        resetCodePhaseUncertaintyInChips();
        resetCarrierFrequencyInHz();
        resetCarrierCycles();
        resetCarrierPhase();
        resetCarrierPhaseUncertainty();
        setLossOfLock(LOSS_OF_LOCK_UNKNOWN);
        resetBitNumber();
        resetTimeFromLastBitInMs();
        resetDopplerShiftInHz();
        resetDopplerShiftUncertaintyInHz();
        setMultipathIndicator(MULTIPATH_INDICATOR_UNKNOWN);
        resetSnrInDb();
        resetElevationInDeg();
        resetElevationUncertaintyInDeg();
        resetAzimuthInDeg();
        resetAzimuthUncertaintyInDeg();
        setUsedInFix(false);
    }

    private void setFlag(int flag) {
        mFlags |= flag;
    }

    private void resetFlag(int flag) {
        mFlags &= ~flag;
    }

    private boolean isFlagSet(int flag) {
        return (mFlags & flag) == flag;
    }
}