/*
* 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.TestApi;
import android.annotation.IntDef;
import android.os.Parcel;
import android.os.Parcelable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
/**
* A class representing a GNSS satellite measurement, containing raw and computed information.
*/
public final class GnssMeasurement implements Parcelable {
private int mFlags;
private int mSvid;
private int mConstellationType;
private double mTimeOffsetNanos;
private int mState;
private long mReceivedSvTimeNanos;
private long mReceivedSvTimeUncertaintyNanos;
private double mCn0DbHz;
private double mPseudorangeRateMetersPerSecond;
private double mPseudorangeRateUncertaintyMetersPerSecond;
private int mAccumulatedDeltaRangeState;
private double mAccumulatedDeltaRangeMeters;
private double mAccumulatedDeltaRangeUncertaintyMeters;
private float mCarrierFrequencyHz;
private long mCarrierCycles;
private double mCarrierPhase;
private double mCarrierPhaseUncertainty;
private int mMultipathIndicator;
private double mSnrInDb;
// 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_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);
/**
* The status of the multipath indicator.
* @hide
*/
@Retention(RetentionPolicy.SOURCE)
@IntDef({MULTIPATH_INDICATOR_UNKNOWN, MULTIPATH_INDICATOR_DETECTED,
MULTIPATH_INDICATOR_NOT_USED})
public @interface MultipathIndicator {}
/**
* The indicator is not available or the presence or absence of multipath is unknown.
*/
public static final int MULTIPATH_INDICATOR_UNKNOWN = 0;
/**
* The measurement shows signs of multi-path.
*/
public static final int MULTIPATH_INDICATOR_DETECTED = 1;
/**
* The measurement shows no signs of multi-path.
*/
public static final int MULTIPATH_INDICATOR_NOT_DETECTED = 2;
/** @removed */
public static final int MULTIPATH_INDICATOR_NOT_USED = 2;
/** This GNSS measurement's tracking state is invalid or unknown. */
public static final int STATE_UNKNOWN = 0;
/** This GNSS measurement's tracking state has code lock. */
public static final int STATE_CODE_LOCK = (1<<0);
/** This GNSS measurement's tracking state has bit sync. */
public static final int STATE_BIT_SYNC = (1<<1);
/** This GNSS measurement's tracking state has sub-frame sync. */
public static final int STATE_SUBFRAME_SYNC = (1<<2);
/** This GNSS measurement's tracking state has time-of-week decoded. */
public static final int STATE_TOW_DECODED = (1<<3);
/** This GNSS measurement's tracking state contains millisecond ambiguity. */
public static final int STATE_MSEC_AMBIGUOUS = (1<<4);
/** This GNSS measurement's tracking state has symbol sync. */
public static final int STATE_SYMBOL_SYNC = (1<<5);
/** This Glonass measurement's tracking state has string sync. */
public static final int STATE_GLO_STRING_SYNC = (1<<6);
/** This Glonass measurement's tracking state has time-of-day decoded. */
public static final int STATE_GLO_TOD_DECODED = (1<<7);
/** This Beidou measurement's tracking state has D2 bit sync. */
public static final int STATE_BDS_D2_BIT_SYNC = (1<<8);
/** This Beidou measurement's tracking state has D2 sub-frame sync. */
public static final int STATE_BDS_D2_SUBFRAME_SYNC = (1<<9);
/** This Galileo measurement's tracking state has E1B/C code lock. */
public static final int STATE_GAL_E1BC_CODE_LOCK = (1<<10);
/** This Galileo measurement's tracking state has E1C secondary code lock. */
public static final int STATE_GAL_E1C_2ND_CODE_LOCK = (1<<11);
/** This Galileo measurement's tracking state has E1B page sync. */
public static final int STATE_GAL_E1B_PAGE_SYNC = (1<<12);
/** This SBAS measurement's tracking state has whole second level sync. */
public static final int STATE_SBAS_SYNC = (1<<13);
/**
* All the GNSS receiver state flags, for bit masking purposes (not a sensible state for any
* individual measurement.)
*/
private static final int STATE_ALL = 0x3fff; // 2 bits + 4 bits + 4 bits + 4 bits = 14 bits
/**
* The state of the 'Accumulated Delta Range' is invalid or unknown.
*/
public static final int ADR_STATE_UNKNOWN = 0;
/**
* The state of the 'Accumulated Delta Range' is valid.
*/
public static final int ADR_STATE_VALID = (1<<0);
/**
* The state of the 'Accumulated Delta Range' has detected a reset.
*/
public static final int ADR_STATE_RESET = (1<<1);
/**
* The state of the 'Accumulated Delta Range' has a cycle slip detected.
*/
public static final int ADR_STATE_CYCLE_SLIP = (1<<2);
/**
* All the 'Accumulated Delta Range' flags.
*/
private static final int ADR_ALL = ADR_STATE_VALID | ADR_STATE_RESET | ADR_STATE_CYCLE_SLIP;
// End enumerations in sync with gps.h
/**
* @hide
*/
@TestApi
public GnssMeasurement() {
initialize();
}
/**
* Sets all contents to the values stored in the provided object.
* @hide
*/
@TestApi
public void set(GnssMeasurement measurement) {
mFlags = measurement.mFlags;
mSvid = measurement.mSvid;
mConstellationType = measurement.mConstellationType;
mTimeOffsetNanos = measurement.mTimeOffsetNanos;
mState = measurement.mState;
mReceivedSvTimeNanos = measurement.mReceivedSvTimeNanos;
mReceivedSvTimeUncertaintyNanos = measurement.mReceivedSvTimeUncertaintyNanos;
mCn0DbHz = measurement.mCn0DbHz;
mPseudorangeRateMetersPerSecond = measurement.mPseudorangeRateMetersPerSecond;
mPseudorangeRateUncertaintyMetersPerSecond =
measurement.mPseudorangeRateUncertaintyMetersPerSecond;
mAccumulatedDeltaRangeState = measurement.mAccumulatedDeltaRangeState;
mAccumulatedDeltaRangeMeters = measurement.mAccumulatedDeltaRangeMeters;
mAccumulatedDeltaRangeUncertaintyMeters =
measurement.mAccumulatedDeltaRangeUncertaintyMeters;
mCarrierFrequencyHz = measurement.mCarrierFrequencyHz;
mCarrierCycles = measurement.mCarrierCycles;
mCarrierPhase = measurement.mCarrierPhase;
mCarrierPhaseUncertainty = measurement.mCarrierPhaseUncertainty;
mMultipathIndicator = measurement.mMultipathIndicator;
mSnrInDb = measurement.mSnrInDb;
}
/**
* Resets all the contents to its original state.
* @hide
*/
@TestApi
public void reset() {
initialize();
}
/**
* Gets the satellite ID.
*
* <p>Interpretation depends on {@link #getConstellationType()}.
* See {@link GnssStatus#getSvid(int)}.
*/
public int getSvid() {
return mSvid;
}
/**
* Sets the Satellite ID.
* @hide
*/
@TestApi
public void setSvid(int value) {
mSvid = value;
}
/**
* Gets the constellation type.
*
* <p>The return value is one of those constants with {@code CONSTELLATION_} prefix in
* {@link GnssStatus}.
*/
@GnssStatus.ConstellationType
public int getConstellationType() {
return mConstellationType;
}
/**
* Sets the constellation type.
* @hide
*/
@TestApi
public void setConstellationType(@GnssStatus.ConstellationType int value) {
mConstellationType = value;
}
/**
* Gets the time offset at which the measurement was taken in nanoseconds.
*
* <p>The reference receiver's time from which this is offset is specified by
* {@link GnssClock#getTimeNanos()}.
*
* <p>The sign of this value is given by the following equation:
* <pre>
* measurement time = TimeNanos + TimeOffsetNanos</pre>
*
* <p>The value provides an individual time-stamp for the measurement, and allows sub-nanosecond
* accuracy.
*/
public double getTimeOffsetNanos() {
return mTimeOffsetNanos;
}
/**
* Sets the time offset at which the measurement was taken in nanoseconds.
* @hide
*/
@TestApi
public void setTimeOffsetNanos(double value) {
mTimeOffsetNanos = value;
}
/**
* Gets per-satellite sync state.
*
* <p>It represents the current sync state for the associated satellite.
*
* <p>This value helps interpret {@link #getReceivedSvTimeNanos()}.
*/
public int getState() {
return mState;
}
/**
* Sets the sync state.
* @hide
*/
@TestApi
public void setState(int value) {
mState = value;
}
/**
* Gets a string representation of the 'sync state'.
*
* <p>For internal and logging use only.
*/
private String getStateString() {
if (mState == STATE_UNKNOWN) {
return "Unknown";
}
StringBuilder builder = new StringBuilder();
if ((mState & STATE_CODE_LOCK) != 0) {
builder.append("CodeLock|");
}
if ((mState & STATE_BIT_SYNC) != 0) {
builder.append("BitSync|");
}
if ((mState & STATE_SUBFRAME_SYNC) != 0) {
builder.append("SubframeSync|");
}
if ((mState & STATE_TOW_DECODED) != 0) {
builder.append("TowDecoded|");
}
if ((mState & STATE_MSEC_AMBIGUOUS) != 0) {
builder.append("MsecAmbiguous|");
}
if ((mState & STATE_SYMBOL_SYNC) != 0) {
builder.append("SymbolSync|");
}
if ((mState & STATE_GLO_STRING_SYNC) != 0) {
builder.append("GloStringSync|");
}
if ((mState & STATE_GLO_TOD_DECODED) != 0) {
builder.append("GloTodDecoded|");
}
if ((mState & STATE_BDS_D2_BIT_SYNC) != 0) {
builder.append("BdsD2BitSync|");
}
if ((mState & STATE_BDS_D2_SUBFRAME_SYNC) != 0) {
builder.append("BdsD2SubframeSync|");
}
if ((mState & STATE_GAL_E1BC_CODE_LOCK) != 0) {
builder.append("GalE1bcCodeLock|");
}
if ((mState & STATE_GAL_E1C_2ND_CODE_LOCK) != 0) {
builder.append("E1c2ndCodeLock|");
}
if ((mState & STATE_GAL_E1B_PAGE_SYNC) != 0) {
builder.append("GalE1bPageSync|");
}
if ((mState & STATE_SBAS_SYNC) != 0) {
builder.append("SbasSync|");
}
int remainingStates = mState & ~STATE_ALL;
if (remainingStates > 0) {
builder.append("Other(");
builder.append(Integer.toBinaryString(remainingStates));
builder.append(")|");
}
builder.setLength(builder.length() - 1);
return builder.toString();
}
/**
* Gets the received GNSS satellite time, at the measurement time, in nanoseconds.
*
* <p>For GPS & QZSS, this is:
* <ul>
* <li>Received GPS Time-of-Week at the measurement time, in nanoseconds.</li>
* <li>The value is relative to the beginning of the current GPS week.</li>
* </ul>
*
* <p>Given the highest sync state that can be achieved, per each satellite, valid range
* for this field can be:
* <pre>
* Searching : [ 0 ] : STATE_UNKNOWN
* C/A code lock : [ 0 1ms ] : STATE_CODE_LOCK is set
* Bit sync : [ 0 20ms ] : STATE_BIT_SYNC is set
* Subframe sync : [ 0 6s ] : STATE_SUBFRAME_SYNC is set
* TOW decoded : [ 0 1week ] : STATE_TOW_DECODED is set</pre>
*
* <p>Note well: if there is any ambiguity in integer millisecond, {@code STATE_MSEC_AMBIGUOUS}
* should be set accordingly, in the 'state' field.
*
* <p>This value must be populated if 'state' != {@code STATE_UNKNOWN}.
*
* <p>For Glonass, this is:
* <ul>
* <li>Received Glonass time of day, at the measurement time in nanoseconds.</li>
* </ul>
*
* <p>Given the highest sync state that can be achieved, per each satellite, valid range for
* this field can be:
* <pre>
* Searching : [ 0 ] : STATE_UNKNOWN
* C/A code lock : [ 0 1ms ] : STATE_CODE_LOCK is set
* Symbol sync : [ 0 10ms ] : STATE_SYMBOL_SYNC is set
* Bit sync : [ 0 20ms ] : STATE_BIT_SYNC is set
* String sync : [ 0 2s ] : STATE_GLO_STRING_SYNC is set
* Time of day : [ 0 1day ] : STATE_GLO_TOD_DECODED is set</pre>
*
* <p>For Beidou, this is:
* <ul>
* <li>Received Beidou time of week, at the measurement time in nanoseconds.</li>
* </ul>
*
* <p>Given the highest sync state that can be achieved, per each satellite, valid range for
* this field can be:
* <pre>
* Searching : [ 0 ] : STATE_UNKNOWN
* C/A code lock : [ 0 1ms ] : STATE_CODE_LOCK is set
* Bit sync (D2) : [ 0 2ms ] : STATE_BDS_D2_BIT_SYNC is set
* Bit sync (D1) : [ 0 20ms ] : STATE_BIT_SYNC is set
* Subframe (D2) : [ 0 0.6s ] : STATE_BDS_D2_SUBFRAME_SYNC is set
* Subframe (D1) : [ 0 6s ] : STATE_SUBFRAME_SYNC is set
* Time of week : [ 0 1week ] : STATE_TOW_DECODED is set</pre>
*
* <p>For Galileo, this is:
* <ul>
* <li>Received Galileo time of week, at the measurement time in nanoseconds.</li>
* </ul>
* <pre>
* E1BC code lock : [ 0 4ms ] : STATE_GAL_E1BC_CODE_LOCK is set
* E1C 2nd code lock: [ 0 100ms ] : STATE_GAL_E1C_2ND_CODE_LOCK is set
* E1B page : [ 0 2s ] : STATE_GAL_E1B_PAGE_SYNC is set
* Time of week : [ 0 1week ] : STATE_GAL_TOW_DECODED is set</pre>
*
* <p>For SBAS, this is:
* <ul>
* <li>Received SBAS time, at the measurement time in nanoseconds.</li>
* </ul>
*
* <p>Given the highest sync state that can be achieved, per each satellite, valid range for
* this field can be:
* <pre>
* Searching : [ 0 ] : STATE_UNKNOWN
* C/A code lock : [ 0 1ms ] : STATE_CODE_LOCK is set
* Symbol sync : [ 0 2ms ] : STATE_SYMBOL_SYNC is set
* Message : [ 0 1s ] : STATE_SBAS_SYNC is set</pre>
*/
public long getReceivedSvTimeNanos() {
return mReceivedSvTimeNanos;
}
/**
* Sets the received GNSS time in nanoseconds.
* @hide
*/
@TestApi
public void setReceivedSvTimeNanos(long value) {
mReceivedSvTimeNanos = value;
}
/**
* Gets the error estimate (1-sigma) for the received GNSS time, in nanoseconds.
*/
public long getReceivedSvTimeUncertaintyNanos() {
return mReceivedSvTimeUncertaintyNanos;
}
/**
* Sets the received GNSS time uncertainty (1-Sigma) in nanoseconds.
* @hide
*/
@TestApi
public void setReceivedSvTimeUncertaintyNanos(long value) {
mReceivedSvTimeUncertaintyNanos = value;
}
/**
* Gets the Carrier-to-noise density in dB-Hz.
*
* <p>Typical range: 10-50 db-Hz.
*
* <p>The value contains the measured C/N0 for the signal at the antenna input.
*/
public double getCn0DbHz() {
return mCn0DbHz;
}
/**
* Sets the carrier-to-noise density in dB-Hz.
* @hide
*/
@TestApi
public void setCn0DbHz(double value) {
mCn0DbHz = value;
}
/**
* Gets the Pseudorange rate at the timestamp in m/s.
*
* <p>The error estimate for this value is
* {@link #getPseudorangeRateUncertaintyMetersPerSecond()}.
*
* <p>The value is uncorrected, i.e. corrections for receiver and satellite clock frequency
* errors are not included.
*
* <p>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 'doppler shift'
* is given by the equation:
*
* <pre>
* pseudorange rate = -k * doppler shift (where k is a constant)</pre>
*/
public double getPseudorangeRateMetersPerSecond() {
return mPseudorangeRateMetersPerSecond;
}
/**
* Sets the pseudorange rate at the timestamp in m/s.
* @hide
*/
@TestApi
public void setPseudorangeRateMetersPerSecond(double value) {
mPseudorangeRateMetersPerSecond = value;
}
/**
* Gets the pseudorange's rate uncertainty (1-Sigma) in m/s.
*
* <p>The uncertainty is represented as an absolute (single sided) value.
*/
public double getPseudorangeRateUncertaintyMetersPerSecond() {
return mPseudorangeRateUncertaintyMetersPerSecond;
}
/**
* Sets the pseudorange's rate uncertainty (1-Sigma) in m/s.
* @hide
*/
@TestApi
public void setPseudorangeRateUncertaintyMetersPerSecond(double value) {
mPseudorangeRateUncertaintyMetersPerSecond = value;
}
/**
* Gets 'Accumulated Delta Range' state.
*
* <p>It indicates whether {@link #getAccumulatedDeltaRangeMeters()} is reset or there is a
* cycle slip (indicating 'loss of lock').
*/
public int getAccumulatedDeltaRangeState() {
return mAccumulatedDeltaRangeState;
}
/**
* Sets the 'Accumulated Delta Range' state.
* @hide
*/
@TestApi
public void setAccumulatedDeltaRangeState(int value) {
mAccumulatedDeltaRangeState = value;
}
/**
* Gets a string representation of the 'Accumulated Delta Range state'.
*
* <p>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.
*
* <p>The error estimate for this value is {@link #getAccumulatedDeltaRangeUncertaintyMeters()}.
*
* <p>The availability of the value is represented by {@link #getAccumulatedDeltaRangeState()}.
*
* <p>A positive value indicates that the SV is moving away from the receiver.
* The sign of {@link #getAccumulatedDeltaRangeMeters()} and its relation to the sign of
* {@link #getCarrierPhase()} is given by the equation:
*
* <pre>
* accumulated delta range = -k * carrier phase (where k is a constant)</pre>
*/
public double getAccumulatedDeltaRangeMeters() {
return mAccumulatedDeltaRangeMeters;
}
/**
* Sets the accumulated delta range in meters.
* @hide
*/
@TestApi
public void setAccumulatedDeltaRangeMeters(double value) {
mAccumulatedDeltaRangeMeters = value;
}
/**
* Gets the accumulated delta range's uncertainty (1-Sigma) in meters.
*
* <p>The uncertainty is represented as an absolute (single sided) value.
*
* <p>The status of the value is represented by {@link #getAccumulatedDeltaRangeState()}.
*/
public double getAccumulatedDeltaRangeUncertaintyMeters() {
return mAccumulatedDeltaRangeUncertaintyMeters;
}
/**
* Sets the accumulated delta range's uncertainty (1-sigma) in meters.
*
* <p>The status of the value is represented by {@link #getAccumulatedDeltaRangeState()}.
*
* @hide
*/
@TestApi
public void setAccumulatedDeltaRangeUncertaintyMeters(double value) {
mAccumulatedDeltaRangeUncertaintyMeters = value;
}
/**
* Returns {@code true} if {@link #getCarrierFrequencyHz()} is available, {@code false}
* otherwise.
*/
public boolean hasCarrierFrequencyHz() {
return isFlagSet(HAS_CARRIER_FREQUENCY);
}
/**
* Gets the carrier frequency at which codes and messages are modulated.
*
* <p>For GPS, e.g., it can be L1 or L2. If the field is not set, it is the primary common use
* frequency, e.g. L1 for GPS.
*
* <p>The value is only available if {@link #hasCarrierFrequencyHz()} is {@code true}.
*/
public float getCarrierFrequencyHz() {
return mCarrierFrequencyHz;
}
/**
* Sets the Carrier frequency (L1 or L2) in Hz.
* @hide
*/
@TestApi
public void setCarrierFrequencyHz(float carrierFrequencyHz) {
setFlag(HAS_CARRIER_FREQUENCY);
mCarrierFrequencyHz = carrierFrequencyHz;
}
/**
* Resets the Carrier frequency (L1 or L2) in Hz.
* @hide
*/
@TestApi
public void resetCarrierFrequencyHz() {
resetFlag(HAS_CARRIER_FREQUENCY);
mCarrierFrequencyHz = Float.NaN;
}
/**
* Returns {@code true} if {@link #getCarrierCycles()} is available, {@code false} otherwise.
*/
public boolean hasCarrierCycles() {
return isFlagSet(HAS_CARRIER_CYCLES);
}
/**
* The number of full carrier cycles between the satellite and the receiver.
*
* <p>The reference frequency is given by the value of {@link #getCarrierFrequencyHz()}.
*
* <p>The value is only available if {@link #hasCarrierCycles()} is {@code true}.
*/
public long getCarrierCycles() {
return mCarrierCycles;
}
/**
* Sets the number of full carrier cycles between the satellite and the receiver.
* @hide
*/
@TestApi
public void setCarrierCycles(long value) {
setFlag(HAS_CARRIER_CYCLES);
mCarrierCycles = value;
}
/**
* Resets the number of full carrier cycles between the satellite and the receiver.
* @hide
*/
@TestApi
public void resetCarrierCycles() {
resetFlag(HAS_CARRIER_CYCLES);
mCarrierCycles = Long.MIN_VALUE;
}
/**
* Returns {@code true} if {@link #getCarrierPhase()} is available, {@code false} otherwise.
*/
public boolean hasCarrierPhase() {
return isFlagSet(HAS_CARRIER_PHASE);
}
/**
* Gets the RF phase detected by the receiver.
*
* <p>Range: [0.0, 1.0].
*
* <p>This is the fractional part of the complete carrier phase measurement.
*
* <p>The reference frequency is given by the value of {@link #getCarrierFrequencyHz()}.
*
* <p>The error estimate for this value is {@link #getCarrierPhaseUncertainty()}.
*
* <p>The value is only available if {@link #hasCarrierPhase()} is {@code true}.
*/
public double getCarrierPhase() {
return mCarrierPhase;
}
/**
* Sets the RF phase detected by the receiver.
* @hide
*/
@TestApi
public void setCarrierPhase(double value) {
setFlag(HAS_CARRIER_PHASE);
mCarrierPhase = value;
}
/**
* Resets the RF phase detected by the receiver.
* @hide
*/
@TestApi
public void resetCarrierPhase() {
resetFlag(HAS_CARRIER_PHASE);
mCarrierPhase = Double.NaN;
}
/**
* Returns {@code true} if {@link #getCarrierPhaseUncertainty()} is available, {@code false}
* otherwise.
*/
public boolean hasCarrierPhaseUncertainty() {
return isFlagSet(HAS_CARRIER_PHASE_UNCERTAINTY);
}
/**
* Gets the carrier-phase's uncertainty (1-Sigma).
*
* <p>The uncertainty is represented as an absolute (single sided) value.
*
* <p>The value is only available if {@link #hasCarrierPhaseUncertainty()} is {@code true}.
*/
public double getCarrierPhaseUncertainty() {
return mCarrierPhaseUncertainty;
}
/**
* Sets the Carrier-phase's uncertainty (1-Sigma) in cycles.
* @hide
*/
@TestApi
public void setCarrierPhaseUncertainty(double value) {
setFlag(HAS_CARRIER_PHASE_UNCERTAINTY);
mCarrierPhaseUncertainty = value;
}
/**
* Resets the Carrier-phase's uncertainty (1-Sigma) in cycles.
* @hide
*/
@TestApi
public void resetCarrierPhaseUncertainty() {
resetFlag(HAS_CARRIER_PHASE_UNCERTAINTY);
mCarrierPhaseUncertainty = Double.NaN;
}
/**
* Gets a value indicating the 'multipath' state of the event.
*/
@MultipathIndicator
public int getMultipathIndicator() {
return mMultipathIndicator;
}
/**
* Sets the 'multi-path' indicator.
* @hide
*/
@TestApi
public void setMultipathIndicator(@MultipathIndicator int value) {
mMultipathIndicator = value;
}
/**
* Gets a string representation of the 'multi-path indicator'.
*
* <p>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 {@code true} if {@link #getSnrInDb()} is available, {@code false} otherwise.
*/
public boolean hasSnrInDb() {
return isFlagSet(HAS_SNR);
}
/**
* Gets the Signal-to-Noise ratio (SNR) in dB.
*
* <p>The value is only available if {@link #hasSnrInDb()} is {@code true}.
*/
public double getSnrInDb() {
return mSnrInDb;
}
/**
* Sets the Signal-to-noise ratio (SNR) in dB.
* @hide
*/
@TestApi
public void setSnrInDb(double snrInDb) {
setFlag(HAS_SNR);
mSnrInDb = snrInDb;
}
/**
* Resets the Signal-to-noise ratio (SNR) in dB.
* @hide
*/
@TestApi
public void resetSnrInDb() {
resetFlag(HAS_SNR);
mSnrInDb = Double.NaN;
}
public static final Creator<GnssMeasurement> CREATOR = new Creator<GnssMeasurement>() {
@Override
public GnssMeasurement createFromParcel(Parcel parcel) {
GnssMeasurement gnssMeasurement = new GnssMeasurement();
gnssMeasurement.mFlags = parcel.readInt();
gnssMeasurement.mSvid = parcel.readInt();
gnssMeasurement.mConstellationType = parcel.readInt();
gnssMeasurement.mTimeOffsetNanos = parcel.readDouble();
gnssMeasurement.mState = parcel.readInt();
gnssMeasurement.mReceivedSvTimeNanos = parcel.readLong();
gnssMeasurement.mReceivedSvTimeUncertaintyNanos = parcel.readLong();
gnssMeasurement.mCn0DbHz = parcel.readDouble();
gnssMeasurement.mPseudorangeRateMetersPerSecond = parcel.readDouble();
gnssMeasurement.mPseudorangeRateUncertaintyMetersPerSecond = parcel.readDouble();
gnssMeasurement.mAccumulatedDeltaRangeState = parcel.readInt();
gnssMeasurement.mAccumulatedDeltaRangeMeters = parcel.readDouble();
gnssMeasurement.mAccumulatedDeltaRangeUncertaintyMeters = parcel.readDouble();
gnssMeasurement.mCarrierFrequencyHz = parcel.readFloat();
gnssMeasurement.mCarrierCycles = parcel.readLong();
gnssMeasurement.mCarrierPhase = parcel.readDouble();
gnssMeasurement.mCarrierPhaseUncertainty = parcel.readDouble();
gnssMeasurement.mMultipathIndicator = parcel.readInt();
gnssMeasurement.mSnrInDb = parcel.readDouble();
return gnssMeasurement;
}
@Override
public GnssMeasurement[] newArray(int i) {
return new GnssMeasurement[i];
}
};
@Override
public void writeToParcel(Parcel parcel, int flags) {
parcel.writeInt(mFlags);
parcel.writeInt(mSvid);
parcel.writeInt(mConstellationType);
parcel.writeDouble(mTimeOffsetNanos);
parcel.writeInt(mState);
parcel.writeLong(mReceivedSvTimeNanos);
parcel.writeLong(mReceivedSvTimeUncertaintyNanos);
parcel.writeDouble(mCn0DbHz);
parcel.writeDouble(mPseudorangeRateMetersPerSecond);
parcel.writeDouble(mPseudorangeRateUncertaintyMetersPerSecond);
parcel.writeInt(mAccumulatedDeltaRangeState);
parcel.writeDouble(mAccumulatedDeltaRangeMeters);
parcel.writeDouble(mAccumulatedDeltaRangeUncertaintyMeters);
parcel.writeFloat(mCarrierFrequencyHz);
parcel.writeLong(mCarrierCycles);
parcel.writeDouble(mCarrierPhase);
parcel.writeDouble(mCarrierPhaseUncertainty);
parcel.writeInt(mMultipathIndicator);
parcel.writeDouble(mSnrInDb);
}
@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("GnssMeasurement:\n");
builder.append(String.format(format, "Svid", mSvid));
builder.append(String.format(format, "ConstellationType", mConstellationType));
builder.append(String.format(format, "TimeOffsetNanos", mTimeOffsetNanos));
builder.append(String.format(format, "State", getStateString()));
builder.append(String.format(
formatWithUncertainty,
"ReceivedSvTimeNanos",
mReceivedSvTimeNanos,
"ReceivedSvTimeUncertaintyNanos",
mReceivedSvTimeUncertaintyNanos));
builder.append(String.format(format, "Cn0DbHz", mCn0DbHz));
builder.append(String.format(
formatWithUncertainty,
"PseudorangeRateMetersPerSecond",
mPseudorangeRateMetersPerSecond,
"PseudorangeRateUncertaintyMetersPerSecond",
mPseudorangeRateUncertaintyMetersPerSecond));
builder.append(String.format(
format,
"AccumulatedDeltaRangeState",
getAccumulatedDeltaRangeStateString()));
builder.append(String.format(
formatWithUncertainty,
"AccumulatedDeltaRangeMeters",
mAccumulatedDeltaRangeMeters,
"AccumulatedDeltaRangeUncertaintyMeters",
mAccumulatedDeltaRangeUncertaintyMeters));
builder.append(String.format(
format,
"CarrierFrequencyHz",
hasCarrierFrequencyHz() ? mCarrierFrequencyHz : 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, "MultipathIndicator", getMultipathIndicatorString()));
builder.append(String.format(
format,
"SnrInDb",
hasSnrInDb() ? mSnrInDb : null));
return builder.toString();
}
private void initialize() {
mFlags = HAS_NO_FLAGS;
setSvid(0);
setTimeOffsetNanos(Long.MIN_VALUE);
setState(STATE_UNKNOWN);
setReceivedSvTimeNanos(Long.MIN_VALUE);
setReceivedSvTimeUncertaintyNanos(Long.MAX_VALUE);
setCn0DbHz(Double.MIN_VALUE);
setPseudorangeRateMetersPerSecond(Double.MIN_VALUE);
setPseudorangeRateUncertaintyMetersPerSecond(Double.MIN_VALUE);
setAccumulatedDeltaRangeState(ADR_STATE_UNKNOWN);
setAccumulatedDeltaRangeMeters(Double.MIN_VALUE);
setAccumulatedDeltaRangeUncertaintyMeters(Double.MIN_VALUE);
resetCarrierFrequencyHz();
resetCarrierCycles();
resetCarrierPhase();
resetCarrierPhaseUncertainty();
setMultipathIndicator(MULTIPATH_INDICATOR_UNKNOWN);
resetSnrInDb();
}
private void setFlag(int flag) {
mFlags |= flag;
}
private void resetFlag(int flag) {
mFlags &= ~flag;
}
private boolean isFlagSet(int flag) {
return (mFlags & flag) == flag;
}
}