src.android.location.SatellitePvt Maven / Gradle / Ivy
Show all versions of android-all Show documentation
/*
* Copyright (C) 2020 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.FloatRange;
import android.annotation.IntDef;
import android.annotation.IntRange;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.SystemApi;
import android.os.Parcel;
import android.os.Parcelable;
import com.android.internal.util.Preconditions;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
/**
* A class that contains GNSS satellite position, velocity and time information at the
* same signal transmission time {@link GnssMeasurement#getReceivedSvTimeNanos()}.
*
* The position and velocity must be in ECEF coordinates.
*
*
If {@link GnssMeasurement#getSatellitePvt()} is derived from Broadcast ephemeris, then the
* position is already w.r.t. the antenna phase center. However, if
* {@link GnssMeasurement#getSatellitePvt()} is derived from other modeled orbits, such as
* long-term orbits, or precise orbits, then the orbits may have been computed w.r.t.
* the satellite center of mass, and then GNSS vendors are expected to correct for the effect
* on different phase centers (can differ by meters) of different GNSS signals (e.g. L1, L5)
* on the reported satellite position. Accordingly, we might observe a different satellite
* position reported for L1 GnssMeasurement struct compared to L5 GnssMeasurement struct.
*
*
If {@link GnssMeasurement#getReceivedSvTimeNanos()} is not fully decoded,
* {@link GnssMeasurement#getSatellitePvt()} could still be reported and
* {@link GnssMeasurement#getReceivedSvTimeUncertaintyNanos()} would be used to provide confidence.
* @hide
*/
@SystemApi
public final class SatellitePvt implements Parcelable {
/**
* Bit mask for {@link #mFlags} indicating valid satellite position, velocity and clock info
* fields are stored in the SatellitePvt.
*/
private static final int HAS_POSITION_VELOCITY_CLOCK_INFO = 1 << 0;
/**
* Bit mask for {@link #mFlags} indicating a valid iono delay field is stored in the
* SatellitePvt.
*/
private static final int HAS_IONO = 1 << 1;
/**
* Bit mask for {@link #mFlags} indicating a valid tropo delay field is stored in the
* SatellitePvt.
*/
private static final int HAS_TROPO = 1 << 2;
/**
* Bit mask for {@link #mFlags} indicating a valid Issue of Data, Clock field is stored in the
* SatellitePvt.
*/
private static final int HAS_ISSUE_OF_DATA_CLOCK = 1 << 3;
/**
* Bit mask for {@link #mFlags} indicating a valid Issue of Data, Ephemeris field is stored in
* the SatellitePvt.
*/
private static final int HAS_ISSUE_OF_DATA_EPHEMERIS = 1 << 4;
/**
* Bit mask for {@link #mFlags} indicating a valid Time of Clock field is stored in the
* SatellitePvt.
*/
private static final int HAS_TIME_OF_CLOCK = 1 << 5;
/**
* Bit mask for {@link #mFlags} indicating a valid Time of Ephemeris field is stored in
* the SatellitePvt.
*/
private static final int HAS_TIME_OF_EPHEMERIS = 1 << 6;
/** Ephemeris demodulated from broadcast signals */
public static final int EPHEMERIS_SOURCE_DEMODULATED = 0;
/**
* Server provided Normal type ephemeris data, which is similar to broadcast ephemeris in
* longevity (e.g. SUPL) - lasting for few hours and providing satellite orbit and clock
* with accuracy of 1 - 2 meters.
*/
public static final int EPHEMERIS_SOURCE_SERVER_NORMAL = 1;
/**
* Server provided Long-Term type ephemeris data, which lasts for many hours to several days
* and often provides satellite orbit and clock accuracy of 2 - 20 meters.
*/
public static final int EPHEMERIS_SOURCE_SERVER_LONG_TERM = 2;
/** Other ephemeris source */
public static final int EPHEMERIS_SOURCE_OTHER = 3;
/**
* Satellite ephemeris source
* @hide
*/
@Retention(RetentionPolicy.SOURCE)
@IntDef({EPHEMERIS_SOURCE_DEMODULATED, EPHEMERIS_SOURCE_SERVER_NORMAL,
EPHEMERIS_SOURCE_SERVER_LONG_TERM, EPHEMERIS_SOURCE_OTHER})
public @interface EphemerisSource {
}
/**
* A bitfield of flags indicating the validity of the fields in this SatellitePvt.
* The bit masks are defined in the constants with prefix HAS_*
*
*
Fields for which there is no corresponding flag must be filled in with a valid value.
* For convenience, these are marked as mandatory.
*
*
Others fields may have invalid information in them, if not marked as valid by the
* corresponding bit in flags.
*/
private final int mFlags;
@Nullable
private final PositionEcef mPositionEcef;
@Nullable
private final VelocityEcef mVelocityEcef;
@Nullable
private final ClockInfo mClockInfo;
private final double mIonoDelayMeters;
private final double mTropoDelayMeters;
private final long mTimeOfClockSeconds;
private final long mTimeOfEphemerisSeconds;
private final int mIssueOfDataClock;
private final int mIssueOfDataEphemeris;
@EphemerisSource
private final int mEphemerisSource;
/**
* Class containing estimates of the satellite position fields in ECEF coordinate frame.
*
*
The satellite position must be defined at the time of transmission of the signal
* receivedSvTimeNs.
*/
public static final class PositionEcef implements Parcelable {
private final double mXMeters;
private final double mYMeters;
private final double mZMeters;
private final double mUreMeters;
public PositionEcef(
double xMeters,
double yMeters,
double zMeters,
double ureMeters) {
mXMeters = xMeters;
mYMeters = yMeters;
mZMeters = zMeters;
mUreMeters = ureMeters;
}
public static final @NonNull Creator CREATOR =
new Creator() {
@Override
public PositionEcef createFromParcel(Parcel in) {
return new PositionEcef(
in.readDouble(),
in.readDouble(),
in.readDouble(),
in.readDouble()
);
}
@Override
public PositionEcef[] newArray(int size) {
return new PositionEcef[size];
}
};
/**
* Returns the satellite position X in WGS84 ECEF (meters).
*/
@FloatRange()
public double getXMeters() {
return mXMeters;
}
/**
* Returns the satellite position Y in WGS84 ECEF (meters).
*/
@FloatRange()
public double getYMeters() {
return mYMeters;
}
/**
* Returns the satellite position Z in WGS84 ECEF (meters).
*/
@FloatRange()
public double getZMeters() {
return mZMeters;
}
/**
* Returns the signal in Space User Range Error (URE) (meters).
*/
@FloatRange(from = 0.0f, fromInclusive = false)
public double getUreMeters() {
return mUreMeters;
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(@NonNull Parcel dest, int flags) {
dest.writeDouble(mXMeters);
dest.writeDouble(mYMeters);
dest.writeDouble(mZMeters);
dest.writeDouble(mUreMeters);
}
@Override
public String toString() {
return "PositionEcef{"
+ "xMeters=" + mXMeters
+ ", yMeters=" + mYMeters
+ ", zMeters=" + mZMeters
+ ", ureMeters=" + mUreMeters
+ "}";
}
}
/**
* Class containing estimates of the satellite velocity fields in the ECEF coordinate frame.
*
* The satellite velocity must be defined at the time of transmission of the signal
* receivedSvTimeNs.
*/
public static final class VelocityEcef implements Parcelable {
private final double mXMetersPerSecond;
private final double mYMetersPerSecond;
private final double mZMetersPerSecond;
private final double mUreRateMetersPerSecond;
public VelocityEcef(
double xMetersPerSecond,
double yMetersPerSecond,
double zMetersPerSecond,
double ureRateMetersPerSecond) {
mXMetersPerSecond = xMetersPerSecond;
mYMetersPerSecond = yMetersPerSecond;
mZMetersPerSecond = zMetersPerSecond;
mUreRateMetersPerSecond = ureRateMetersPerSecond;
}
public static final @NonNull Creator CREATOR =
new Creator() {
@Override
public VelocityEcef createFromParcel(Parcel in) {
return new VelocityEcef(
in.readDouble(),
in.readDouble(),
in.readDouble(),
in.readDouble()
);
}
@Override
public VelocityEcef[] newArray(int size) {
return new VelocityEcef[size];
}
};
/**
* Returns the satellite velocity X in WGS84 ECEF (meters per second).
*/
@FloatRange()
public double getXMetersPerSecond() {
return mXMetersPerSecond;
}
/**
* Returns the satellite velocity Y in WGS84 ECEF (meters per second).
*/
@FloatRange()
public double getYMetersPerSecond() {
return mYMetersPerSecond;
}
/**
*Returns the satellite velocity Z in WGS84 ECEF (meters per second).
*/
@FloatRange()
public double getZMetersPerSecond() {
return mZMetersPerSecond;
}
/**
* Returns the signal in Space User Range Error Rate (URE Rate) (meters per second).
*
* It covers satellite velocity error and Satellite clock drift
* projected to the pseudorange rate measurements.
*/
@FloatRange(from = 0.0f, fromInclusive = false)
public double getUreRateMetersPerSecond() {
return mUreRateMetersPerSecond;
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(@NonNull Parcel dest, int flags) {
dest.writeDouble(mXMetersPerSecond);
dest.writeDouble(mYMetersPerSecond);
dest.writeDouble(mZMetersPerSecond);
dest.writeDouble(mUreRateMetersPerSecond);
}
@Override
public String toString() {
return "VelocityEcef{"
+ "xMetersPerSecond=" + mXMetersPerSecond
+ ", yMetersPerSecond=" + mYMetersPerSecond
+ ", zMetersPerSecond=" + mZMetersPerSecond
+ ", ureRateMetersPerSecond=" + mUreRateMetersPerSecond
+ "}";
}
}
/**
* Class containing estimates of the satellite clock info.
*/
public static final class ClockInfo implements Parcelable {
private final double mHardwareCodeBiasMeters;
private final double mTimeCorrectionMeters;
private final double mClockDriftMetersPerSecond;
public ClockInfo(
double hardwareCodeBiasMeters,
double timeCorrectionMeters,
double clockDriftMetersPerSecond) {
mHardwareCodeBiasMeters = hardwareCodeBiasMeters;
mTimeCorrectionMeters = timeCorrectionMeters;
mClockDriftMetersPerSecond = clockDriftMetersPerSecond;
}
public static final @NonNull Creator CREATOR =
new Creator() {
@Override
public ClockInfo createFromParcel(Parcel in) {
return new ClockInfo(
in.readDouble(),
in.readDouble(),
in.readDouble()
);
}
@Override
public ClockInfo[] newArray(int size) {
return new ClockInfo[size];
}
};
/**
* Returns the satellite hardware code bias of the reported code type w.r.t
* ionosphere-free measurement in meters.
*
* When broadcast ephemeris is used, this is the offset caused
* by the satellite hardware delays at different frequencies;
* e.g. in IS-GPS-705D, this term is described in Section
* 20.3.3.3.1.2.1.
*
*
For GPS this term is ~10ns, and affects the satellite position
* computation by less than a millimeter.
*/
@FloatRange()
public double getHardwareCodeBiasMeters() {
return mHardwareCodeBiasMeters;
}
/**
* Returns the satellite time correction for ionospheric-free signal measurement
* (meters). The satellite clock correction for the given signal type
* = satTimeCorrectionMeters - satHardwareCodeBiasMeters.
*
*
When broadcast ephemeris is used, this is the offset modeled in the
* clock terms broadcast over the air by the satellites;
* e.g. in IS-GPS-200H, Section 20.3.3.3.3.1, this term is
* ∆tsv = af0 + af1(t - toc) + af2(t - toc)^2 + ∆tr.
*
*
If another source of ephemeris is used for SatellitePvt, then the
* equivalent value of satTimeCorrection must be provided.
*
*
For GPS this term is ~1ms, and affects the satellite position
* computation by ~1m.
*/
@FloatRange()
public double getTimeCorrectionMeters() {
return mTimeCorrectionMeters;
}
/**
* Returns the satellite clock drift (meters per second).
*/
@FloatRange()
public double getClockDriftMetersPerSecond() {
return mClockDriftMetersPerSecond;
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(@NonNull Parcel dest, int flags) {
dest.writeDouble(mHardwareCodeBiasMeters);
dest.writeDouble(mTimeCorrectionMeters);
dest.writeDouble(mClockDriftMetersPerSecond);
}
@Override
public String toString() {
return "ClockInfo{"
+ "hardwareCodeBiasMeters=" + mHardwareCodeBiasMeters
+ ", timeCorrectionMeters=" + mTimeCorrectionMeters
+ ", clockDriftMetersPerSecond=" + mClockDriftMetersPerSecond
+ "}";
}
}
private SatellitePvt(
int flags,
@Nullable PositionEcef positionEcef,
@Nullable VelocityEcef velocityEcef,
@Nullable ClockInfo clockInfo,
double ionoDelayMeters,
double tropoDelayMeters,
long timeOfClockSeconds,
long timeOfEphemerisSeconds,
int issueOfDataClock,
int issueOfDataEphemeris,
@EphemerisSource int ephemerisSource) {
mFlags = flags;
mPositionEcef = positionEcef;
mVelocityEcef = velocityEcef;
mClockInfo = clockInfo;
mIonoDelayMeters = ionoDelayMeters;
mTropoDelayMeters = tropoDelayMeters;
mTimeOfClockSeconds = timeOfClockSeconds;
mTimeOfEphemerisSeconds = timeOfEphemerisSeconds;
mIssueOfDataClock = issueOfDataClock;
mIssueOfDataEphemeris = issueOfDataEphemeris;
mEphemerisSource = ephemerisSource;
}
/**
* Returns a {@link PositionEcef} object that contains estimates of the satellite
* position fields in ECEF coordinate frame.
*/
@Nullable
public PositionEcef getPositionEcef() {
return mPositionEcef;
}
/**
* Returns a {@link VelocityEcef} object that contains estimates of the satellite
* velocity fields in the ECEF coordinate frame.
*/
@Nullable
public VelocityEcef getVelocityEcef() {
return mVelocityEcef;
}
/**
* Returns a {@link ClockInfo} object that contains estimates of the satellite
* clock info.
*/
@Nullable
public ClockInfo getClockInfo() {
return mClockInfo;
}
/**
* Returns the ionospheric delay in meters.
*/
@FloatRange()
public double getIonoDelayMeters() {
return mIonoDelayMeters;
}
/**
* Returns the tropospheric delay in meters.
*/
@FloatRange()
public double getTropoDelayMeters() {
return mTropoDelayMeters;
}
/**
* Issue of Data, Clock.
*
*
This is defined in GPS ICD200 documentation (e.g.,
* ).
*
*
This field is valid if {@link #hasIssueOfDataClock()} is true.
*/
@IntRange(from = 0, to = 1023)
public int getIssueOfDataClock() {
return mIssueOfDataClock;
}
/**
* Issue of Data, Ephemeris.
*
*
This is defined in GPS ICD200 documentation (e.g.,
* ).
*
*
This field is valid if {@link #hasIssueOfDataEphemeris()} is true.
*/
@IntRange(from = 0, to = 1023)
public int getIssueOfDataEphemeris() {
return mIssueOfDataEphemeris;
}
/**
* Time of Clock in seconds.
*
*
The value is in seconds since GPS epoch, regardless of the constellation.
*
*
The value is not encoded as in GPS ICD200 documentation.
*
*
This field is valid if {@link #hasTimeOfClockSeconds()} is true.
*/
@IntRange(from = 0)
public long getTimeOfClockSeconds() {
return mTimeOfClockSeconds;
}
/**
* Time of ephemeris in seconds.
*
*
The value is in seconds since GPS epoch, regardless of the constellation.
*
*
The value is not encoded as in GPS ICD200 documentation.
*
*
This field is valid if {@link #hasTimeOfEphemerisSeconds()} is true.
*/
@IntRange(from = 0)
public long getTimeOfEphemerisSeconds() {
return mTimeOfEphemerisSeconds;
}
/**
* Satellite ephemeris source.
*/
@EphemerisSource
public int getEphemerisSource() {
return mEphemerisSource;
}
/** Returns {@code true} if {@link #getPositionEcef()}, {@link #getVelocityEcef()},
* and {@link #getClockInfo()} are valid.
*/
public boolean hasPositionVelocityClockInfo() {
return (mFlags & HAS_POSITION_VELOCITY_CLOCK_INFO) != 0;
}
/** Returns {@code true} if {@link #getIonoDelayMeters()} is valid. */
public boolean hasIono() {
return (mFlags & HAS_IONO) != 0;
}
/** Returns {@code true} if {@link #getTropoDelayMeters()} is valid. */
public boolean hasTropo() {
return (mFlags & HAS_TROPO) != 0;
}
/** Returns {@code true} if {@link #getIssueOfDataClock()} is valid. */
public boolean hasIssueOfDataClock() {
return (mFlags & HAS_ISSUE_OF_DATA_CLOCK) != 0;
}
/** Returns {@code true} if {@link #getIssueOfDataEphemeris()} is valid. */
public boolean hasIssueOfDataEphemeris() {
return (mFlags & HAS_ISSUE_OF_DATA_EPHEMERIS) != 0;
}
/** Returns {@code true} if {@link #getTimeOfClockSeconds()} ()} is valid. */
public boolean hasTimeOfClockSeconds() {
return (mFlags & HAS_TIME_OF_CLOCK) != 0;
}
/** Returns {@code true} if {@link #getTimeOfEphemerisSeconds()} is valid. */
public boolean hasTimeOfEphemerisSeconds() {
return (mFlags & HAS_TIME_OF_EPHEMERIS) != 0;
}
public static final @android.annotation.NonNull Creator CREATOR =
new Creator() {
@Override
@Nullable
public SatellitePvt createFromParcel(Parcel in) {
int flags = in.readInt();
ClassLoader classLoader = getClass().getClassLoader();
PositionEcef positionEcef = in.readParcelable(classLoader,
android.location.SatellitePvt.PositionEcef.class);
VelocityEcef velocityEcef = in.readParcelable(classLoader,
android.location.SatellitePvt.VelocityEcef.class);
ClockInfo clockInfo = in.readParcelable(classLoader,
android.location.SatellitePvt.ClockInfo.class);
double ionoDelayMeters = in.readDouble();
double tropoDelayMeters = in.readDouble();
long toc = in.readLong();
long toe = in.readLong();
int iodc = in.readInt();
int iode = in.readInt();
int ephemerisSource = in.readInt();
return new SatellitePvt(
flags,
positionEcef,
velocityEcef,
clockInfo,
ionoDelayMeters,
tropoDelayMeters,
toc,
toe,
iodc,
iode,
ephemerisSource);
}
@Override
public SatellitePvt[] newArray(int size) {
return new SatellitePvt[size];
}
};
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(@NonNull Parcel parcel, int flags) {
parcel.writeInt(mFlags);
parcel.writeParcelable(mPositionEcef, flags);
parcel.writeParcelable(mVelocityEcef, flags);
parcel.writeParcelable(mClockInfo, flags);
parcel.writeDouble(mIonoDelayMeters);
parcel.writeDouble(mTropoDelayMeters);
parcel.writeLong(mTimeOfClockSeconds);
parcel.writeLong(mTimeOfEphemerisSeconds);
parcel.writeInt(mIssueOfDataClock);
parcel.writeInt(mIssueOfDataEphemeris);
parcel.writeInt(mEphemerisSource);
}
@Override
public String toString() {
return "SatellitePvt["
+ "Flags=" + mFlags
+ ", PositionEcef=" + mPositionEcef
+ ", VelocityEcef=" + mVelocityEcef
+ ", ClockInfo=" + mClockInfo
+ ", IonoDelayMeters=" + mIonoDelayMeters
+ ", TropoDelayMeters=" + mTropoDelayMeters
+ ", TimeOfClockSeconds=" + mTimeOfClockSeconds
+ ", TimeOfEphemerisSeconds=" + mTimeOfEphemerisSeconds
+ ", IssueOfDataClock=" + mIssueOfDataClock
+ ", IssueOfDataEphemeris=" + mIssueOfDataEphemeris
+ ", EphemerisSource=" + mEphemerisSource
+ "]";
}
/**
* Builder class for SatellitePvt.
*/
public static final class Builder {
/**
* For documentation of below fields, see corresponding fields in {@link
* SatellitePvt}.
*/
private int mFlags;
@Nullable private PositionEcef mPositionEcef;
@Nullable private VelocityEcef mVelocityEcef;
@Nullable private ClockInfo mClockInfo;
private double mIonoDelayMeters;
private double mTropoDelayMeters;
private long mTimeOfClockSeconds;
private long mTimeOfEphemerisSeconds;
private int mIssueOfDataClock;
private int mIssueOfDataEphemeris;
@EphemerisSource
private int mEphemerisSource = EPHEMERIS_SOURCE_OTHER;
/**
* Set position ECEF.
*
* @param positionEcef position ECEF object
* @return builder object
*/
@NonNull
public Builder setPositionEcef(@NonNull PositionEcef positionEcef) {
mPositionEcef = positionEcef;
updateFlags();
return this;
}
/**
* Set velocity ECEF.
*
* @param velocityEcef velocity ECEF object
* @return builder object
*/
@NonNull
public Builder setVelocityEcef(@NonNull VelocityEcef velocityEcef) {
mVelocityEcef = velocityEcef;
updateFlags();
return this;
}
/**
* Set clock info.
*
* @param clockInfo clock info object
* @return builder object
*/
@NonNull
public Builder setClockInfo(@NonNull ClockInfo clockInfo) {
mClockInfo = clockInfo;
updateFlags();
return this;
}
private void updateFlags() {
if (mPositionEcef != null && mVelocityEcef != null && mClockInfo != null) {
mFlags = (byte) (mFlags | HAS_POSITION_VELOCITY_CLOCK_INFO);
}
}
/**
* Set ionospheric delay in meters.
*
* @param ionoDelayMeters ionospheric delay (meters)
* @return builder object
*/
@NonNull
public Builder setIonoDelayMeters(
@FloatRange(from = 0.0f, to = 100.0f) double ionoDelayMeters) {
mIonoDelayMeters = ionoDelayMeters;
mFlags = (byte) (mFlags | HAS_IONO);
return this;
}
/**
* Set tropospheric delay in meters.
*
* @param tropoDelayMeters tropospheric delay (meters)
* @return builder object
*/
@NonNull
public Builder setTropoDelayMeters(
@FloatRange(from = 0.0f, to = 100.0f) double tropoDelayMeters) {
mTropoDelayMeters = tropoDelayMeters;
mFlags = (byte) (mFlags | HAS_TROPO);
return this;
}
/**
* Set time of clock in seconds.
*
* The value is in seconds since GPS epoch, regardless of the constellation.
*
*
The value is not encoded as in GPS ICD200 documentation.
*
* @param timeOfClockSeconds time of clock (seconds)
* @return builder object
*/
@NonNull
public Builder setTimeOfClockSeconds(@IntRange(from = 0) long timeOfClockSeconds) {
Preconditions.checkArgumentNonnegative(timeOfClockSeconds);
mTimeOfClockSeconds = timeOfClockSeconds;
mFlags = (byte) (mFlags | HAS_TIME_OF_CLOCK);
return this;
}
/**
* Set time of ephemeris in seconds.
*
*
The value is in seconds since GPS epoch, regardless of the constellation.
*
*
The value is not encoded as in GPS ICD200 documentation.
*
* @param timeOfEphemerisSeconds time of ephemeris (seconds)
* @return builder object
*/
@NonNull
public Builder setTimeOfEphemerisSeconds(@IntRange(from = 0) long timeOfEphemerisSeconds) {
Preconditions.checkArgumentNonnegative(timeOfEphemerisSeconds);
mTimeOfEphemerisSeconds = timeOfEphemerisSeconds;
mFlags = (byte) (mFlags | HAS_TIME_OF_EPHEMERIS);
return this;
}
/**
* Set issue of data, clock.
*
* @param issueOfDataClock issue of data, clock.
* @return builder object
*/
@NonNull
public Builder setIssueOfDataClock(@IntRange(from = 0, to = 1023) int issueOfDataClock) {
Preconditions.checkArgumentInRange(issueOfDataClock, 0, 1023, "issueOfDataClock");
mIssueOfDataClock = issueOfDataClock;
mFlags = (byte) (mFlags | HAS_ISSUE_OF_DATA_CLOCK);
return this;
}
/**
* Set issue of data, ephemeris.
*
* @param issueOfDataEphemeris issue of data, ephemeris.
* @return builder object
*/
@NonNull
public Builder setIssueOfDataEphemeris(
@IntRange(from = 0, to = 1023) int issueOfDataEphemeris) {
Preconditions.checkArgumentInRange(issueOfDataEphemeris, 0, 1023,
"issueOfDataEphemeris");
mIssueOfDataEphemeris = issueOfDataEphemeris;
mFlags = (byte) (mFlags | HAS_ISSUE_OF_DATA_EPHEMERIS);
return this;
}
/**
* Set satellite ephemeris source.
*
* @param ephemerisSource satellite ephemeris source
* @return builder object
*/
@NonNull
public Builder setEphemerisSource(@EphemerisSource int ephemerisSource) {
Preconditions.checkArgument(ephemerisSource == EPHEMERIS_SOURCE_DEMODULATED
|| ephemerisSource == EPHEMERIS_SOURCE_SERVER_NORMAL
|| ephemerisSource == EPHEMERIS_SOURCE_SERVER_LONG_TERM
|| ephemerisSource == EPHEMERIS_SOURCE_OTHER);
mEphemerisSource = ephemerisSource;
return this;
}
/**
* Build SatellitePvt object.
*
* @return instance of SatellitePvt
*/
@NonNull
public SatellitePvt build() {
return new SatellitePvt(mFlags, mPositionEcef, mVelocityEcef, mClockInfo,
mIonoDelayMeters, mTropoDelayMeters, mTimeOfClockSeconds,
mTimeOfEphemerisSeconds,
mIssueOfDataClock, mIssueOfDataEphemeris,
mEphemerisSource);
}
}
}