| /* | |
| * 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.NonNull; | |
| import android.annotation.SystemApi; | |
| import android.os.Parcel; | |
| import android.os.Parcelable; | |
| /** | |
| * A class representing a GPS satellite measurement, containing raw and computed information. | |
| * | |
| * @deprecated use {@link GnssMeasurement} instead. | |
| * | |
| * @hide | |
| */ | |
| @Deprecated | |
| @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. | |
| */ | |
| public static final byte LOSS_OF_LOCK_UNKNOWN = 0; | |
| /** | |
| * 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. | |
| */ | |
| public static final byte LOSS_OF_LOCK_CYCLE_SLIP = 2; | |
| /** | |
| * 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. | |
| */ | |
| public static final byte MULTIPATH_INDICATOR_DETECTED = 1; | |
| /** | |
| * 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. | |
| */ | |
| public static final short STATE_UNKNOWN = 0; | |
| /** | |
| * 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. | |
| */ | |
| public static final short STATE_BIT_SYNC = (1<<1); | |
| /** | |
| *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. | |
| */ | |
| public static final short STATE_TOW_DECODED = (1<<3); | |
| /** | |
| * The state of the GPS receiver contains millisecond ambiguity. | |
| */ | |
| public static final short STATE_MSEC_AMBIGUOUS = (1<<4); | |
| /** | |
| * 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. | |
| */ | |
| public static final short ADR_STATE_UNKNOWN = 0; | |
| /** | |
| * 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. | |
| */ | |
| public static final short ADR_STATE_RESET = (1<<1); | |
| /** | |
| * 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. | |
| */ | |
| 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. | |
| */ | |
| 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. | |
| */ | |
| public void reset() { | |
| initialize(); | |
| } | |
| /** | |
| * Gets the Pseudo-random number (PRN). | |
| * Range: [1, 32] | |
| */ | |
| public byte getPrn() { | |
| return mPrn; | |
| } | |
| /** | |
| * 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 {@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. | |
| */ | |
| 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 {@link #getReceivedGpsTowInNs()}. | |
| */ | |
| public short getState() { | |
| return mState; | |
| } | |
| /** | |
| * 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. | |
| */ | |
| 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 {@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. | |
| */ | |
| public void setReceivedGpsTowInNs(long value) { | |
| mReceivedGpsTowInNs = value; | |
| } | |
| /** | |
| * 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. | |
| */ | |
| 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. | |
| */ | |
| public double getCn0InDbHz() { | |
| return mCn0InDbHz; | |
| } | |
| /** | |
| * 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 {@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. | |
| */ | |
| public void setPseudorangeRateInMetersPerSec(double value) { | |
| mPseudorangeRateInMetersPerSec = 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. | |
| */ | |
| public double getPseudorangeRateUncertaintyInMetersPerSec() { | |
| return mPseudorangeRateUncertaintyInMetersPerSec; | |
| } | |
| /** | |
| * 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 {@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. | |
| */ | |
| public void setAccumulatedDeltaRangeState(short value) { | |
| mAccumulatedDeltaRangeState = value; | |
| } | |
| /** | |
| * 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 {@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. | |
| */ | |
| 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 {@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 {@link #getAccumulatedDeltaRangeState()}. | |
| */ | |
| public void setAccumulatedDeltaRangeUncertaintyInMeters(double value) { | |
| mAccumulatedDeltaRangeUncertaintyInMeters = value; | |
| } | |
| /** | |
| * 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 {@link #getPseudorangeUncertaintyInMeters()}. | |
| * | |
| * The value is only available if {@link #hasPseudorangeInMeters()} is true. | |
| */ | |
| public double getPseudorangeInMeters() { | |
| return mPseudorangeInMeters; | |
| } | |
| /** | |
| * Sets the Pseudo-range in meters. | |
| */ | |
| public void setPseudorangeInMeters(double value) { | |
| setFlag(HAS_PSEUDORANGE); | |
| mPseudorangeInMeters = value; | |
| } | |
| /** | |
| * Resets the Pseudo-range in meters. | |
| */ | |
| public void resetPseudorangeInMeters() { | |
| resetFlag(HAS_PSEUDORANGE); | |
| mPseudorangeInMeters = Double.NaN; | |
| } | |
| /** | |
| * 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 {@link #hasPseudorangeUncertaintyInMeters()} is true. | |
| */ | |
| public double getPseudorangeUncertaintyInMeters() { | |
| return mPseudorangeUncertaintyInMeters; | |
| } | |
| /** | |
| * 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. | |
| */ | |
| public void resetPseudorangeUncertaintyInMeters() { | |
| resetFlag(HAS_PSEUDORANGE_UNCERTAINTY); | |
| mPseudorangeUncertaintyInMeters = Double.NaN; | |
| } | |
| /** | |
| * 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 {@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. | |
| */ | |
| public void setCodePhaseInChips(double value) { | |
| setFlag(HAS_CODE_PHASE); | |
| mCodePhaseInChips = value; | |
| } | |
| /** | |
| * Resets the Code-phase in chips. | |
| */ | |
| public void resetCodePhaseInChips() { | |
| resetFlag(HAS_CODE_PHASE); | |
| mCodePhaseInChips = Double.NaN; | |
| } | |
| /** | |
| * 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 {@link #hasCodePhaseUncertaintyInChips()} is true. | |
| */ | |
| public double getCodePhaseUncertaintyInChips() { | |
| return mCodePhaseUncertaintyInChips; | |
| } | |
| /** | |
| * 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. | |
| */ | |
| public void resetCodePhaseUncertaintyInChips() { | |
| resetFlag(HAS_CODE_PHASE_UNCERTAINTY); | |
| mCodePhaseUncertaintyInChips = Double.NaN; | |
| } | |
| /** | |
| * 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 {@link #hasCarrierFrequencyInHz()} is true. | |
| */ | |
| public float getCarrierFrequencyInHz() { | |
| return mCarrierFrequencyInHz; | |
| } | |
| /** | |
| * 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. | |
| */ | |
| public void resetCarrierFrequencyInHz() { | |
| resetFlag(HAS_CARRIER_FREQUENCY); | |
| mCarrierFrequencyInHz = Float.NaN; | |
| } | |
| /** | |
| * 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 {@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. | |
| */ | |
| public void setCarrierCycles(long value) { | |
| setFlag(HAS_CARRIER_CYCLES); | |
| mCarrierCycles = value; | |
| } | |
| /** | |
| * 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 {@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 {@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. | |
| */ | |
| public void setCarrierPhase(double value) { | |
| setFlag(HAS_CARRIER_PHASE); | |
| mCarrierPhase = value; | |
| } | |
| /** | |
| * Resets the RF phase detected by the receiver. | |
| */ | |
| public void resetCarrierPhase() { | |
| resetFlag(HAS_CARRIER_PHASE); | |
| mCarrierPhase = Double.NaN; | |
| } | |
| /** | |
| * 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 {@link #hasCarrierPhaseUncertainty()} is true. | |
| */ | |
| public double getCarrierPhaseUncertainty() { | |
| return mCarrierPhaseUncertainty; | |
| } | |
| /** | |
| * 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. | |
| */ | |
| public void resetCarrierPhaseUncertainty() { | |
| resetFlag(HAS_CARRIER_PHASE_UNCERTAINTY); | |
| mCarrierPhaseUncertainty = Double.NaN; | |
| } | |
| /** | |
| * Gets a value indicating the 'loss of lock' state of the event. | |
| */ | |
| public byte getLossOfLock() { | |
| return mLossOfLock; | |
| } | |
| /** | |
| * 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. | |
| */ | |
| 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 {@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 {@link #hasBitNumber()} is true. | |
| */ | |
| public int getBitNumber() { | |
| return mBitNumber; | |
| } | |
| /** | |
| * 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. | |
| */ | |
| public void resetBitNumber() { | |
| resetFlag(HAS_BIT_NUMBER); | |
| mBitNumber = Integer.MIN_VALUE; | |
| } | |
| /** | |
| * 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 {@link #hasTimeFromLastBitInMs()} is true. | |
| */ | |
| public short getTimeFromLastBitInMs() { | |
| return mTimeFromLastBitInMs; | |
| } | |
| /** | |
| * 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. | |
| */ | |
| public void resetTimeFromLastBitInMs() { | |
| resetFlag(HAS_TIME_FROM_LAST_BIT); | |
| mTimeFromLastBitInMs = Short.MIN_VALUE; | |
| } | |
| /** | |
| * 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 {@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. | |
| */ | |
| public void setDopplerShiftInHz(double value) { | |
| setFlag(HAS_DOPPLER_SHIFT); | |
| mDopplerShiftInHz = value; | |
| } | |
| /** | |
| * Resets the Doppler shift in Hz. | |
| */ | |
| public void resetDopplerShiftInHz() { | |
| resetFlag(HAS_DOPPLER_SHIFT); | |
| mDopplerShiftInHz = Double.NaN; | |
| } | |
| /** | |
| * 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 {@link #hasDopplerShiftUncertaintyInHz()} is true. | |
| */ | |
| public double getDopplerShiftUncertaintyInHz() { | |
| return mDopplerShiftUncertaintyInHz; | |
| } | |
| /** | |
| * 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. | |
| */ | |
| public void resetDopplerShiftUncertaintyInHz() { | |
| resetFlag(HAS_DOPPLER_SHIFT_UNCERTAINTY); | |
| mDopplerShiftUncertaintyInHz = Double.NaN; | |
| } | |
| /** | |
| * Gets a value indicating the 'multipath' state of the event. | |
| */ | |
| public byte getMultipathIndicator() { | |
| return mMultipathIndicator; | |
| } | |
| /** | |
| * 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. | |
| */ | |
| 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 {@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 {@link #hasSnrInDb()} is true. | |
| */ | |
| public double getSnrInDb() { | |
| return mSnrInDb; | |
| } | |
| /** | |
| * 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. | |
| */ | |
| public void resetSnrInDb() { | |
| resetFlag(HAS_SNR); | |
| mSnrInDb = Double.NaN; | |
| } | |
| /** | |
| * 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 {@link #getElevationUncertaintyInDeg()}. | |
| * | |
| * The value is only available if {@link #hasElevationInDeg()} is true. | |
| */ | |
| public double getElevationInDeg() { | |
| return mElevationInDeg; | |
| } | |
| /** | |
| * Sets the Elevation in degrees. | |
| */ | |
| public void setElevationInDeg(double elevationInDeg) { | |
| setFlag(HAS_ELEVATION); | |
| mElevationInDeg = elevationInDeg; | |
| } | |
| /** | |
| * Resets the Elevation in degrees. | |
| */ | |
| public void resetElevationInDeg() { | |
| resetFlag(HAS_ELEVATION); | |
| mElevationInDeg = Double.NaN; | |
| } | |
| /** | |
| * 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 {@link #hasElevationUncertaintyInDeg()} is true. | |
| */ | |
| public double getElevationUncertaintyInDeg() { | |
| return mElevationUncertaintyInDeg; | |
| } | |
| /** | |
| * 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. | |
| */ | |
| public void resetElevationUncertaintyInDeg() { | |
| resetFlag(HAS_ELEVATION_UNCERTAINTY); | |
| mElevationUncertaintyInDeg = Double.NaN; | |
| } | |
| /** | |
| * 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 {@link #getAzimuthUncertaintyInDeg()}. | |
| * | |
| * The value is only available if {@link #hasAzimuthInDeg()} is true. | |
| */ | |
| public double getAzimuthInDeg() { | |
| return mAzimuthInDeg; | |
| } | |
| /** | |
| * Sets the Azimuth in degrees. | |
| */ | |
| public void setAzimuthInDeg(double value) { | |
| setFlag(HAS_AZIMUTH); | |
| mAzimuthInDeg = value; | |
| } | |
| /** | |
| * Resets the Azimuth in degrees. | |
| */ | |
| public void resetAzimuthInDeg() { | |
| resetFlag(HAS_AZIMUTH); | |
| mAzimuthInDeg = Double.NaN; | |
| } | |
| /** | |
| * 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 {@link #hasAzimuthUncertaintyInDeg()} is true. | |
| */ | |
| public double getAzimuthUncertaintyInDeg() { | |
| return mAzimuthUncertaintyInDeg; | |
| } | |
| /** | |
| * 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. | |
| */ | |
| 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. | |
| * | |
| * @return A non-null value if the data is available, null otherwise. | |
| */ | |
| public boolean isUsedInFix() { | |
| return mUsedInFix; | |
| } | |
| /** | |
| * Sets the Used-in-Fix flag. | |
| */ | |
| public void setUsedInFix(boolean value) { | |
| mUsedInFix = value; | |
| } | |
| public static final @android.annotation.NonNull 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; | |
| } | |
| @NonNull | |
| @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; | |
| } | |
| } |