path: root/location/java/android/location/SatellitePvt.java

/*
 * 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()}.
 *
 * <p>The position and velocity must be in ECEF coordinates.
 *
 * <p>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.
 *
 * <p>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_*
     *
     * <p>Fields for which there is no corresponding flag must be filled in with a valid value.
     * For convenience, these are marked as mandatory.
     *
     * <p>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.
     *
     * <p>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<PositionEcef> CREATOR =
                new Creator<PositionEcef>() {
                    @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.
     *
     * <p>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<VelocityEcef> CREATOR =
                new Creator<VelocityEcef>() {
                    @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).
         *
         * <p>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<ClockInfo> CREATOR =
                new Creator<ClockInfo>() {
                    @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.
         *
         * <p>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.
         *
         * <p>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.
         *
         * <p>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.
         *
         * <p>If another source of ephemeris is used for SatellitePvt, then the
         * equivalent value of satTimeCorrection must be provided.
         *
         * <p>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.
     *
     * <p>This is defined in GPS ICD200 documentation (e.g.,
     * <a href="https://www.gps.gov/technical/icwg/IS-GPS-200H.pdf"></a>).
     *
     * <p>This field is valid if {@link #hasIssueOfDataClock()} is true.
     */
    @IntRange(from = 0, to = 1023)
    public int getIssueOfDataClock() {
        return mIssueOfDataClock;
    }

    /**
     * Issue of Data, Ephemeris.
     *
     * <p>This is defined in GPS ICD200 documentation (e.g.,
     * <a href="https://www.gps.gov/technical/icwg/IS-GPS-200H.pdf"></a>).
     *
     * <p>This field is valid if {@link #hasIssueOfDataEphemeris()} is true.
     */
    @IntRange(from = 0, to = 1023)
    public int getIssueOfDataEphemeris() {
        return mIssueOfDataEphemeris;
    }

    /**
     * Time of Clock in seconds.
     *
     * <p>The value is in seconds since GPS epoch, regardless of the constellation.
     *
     * <p>The value is not encoded as in GPS ICD200 documentation.
     *
     * <p>This field is valid if {@link #hasTimeOfClockSeconds()} is true.
     */
    @IntRange(from = 0)
    public long getTimeOfClockSeconds() {
        return mTimeOfClockSeconds;
    }

    /**
     * Time of ephemeris in seconds.
     *
     * <p>The value is in seconds since GPS epoch, regardless of the constellation.
     *
     * <p>The value is not encoded as in GPS ICD200 documentation.
     *
     * <p>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<SatellitePvt> CREATOR =
            new Creator<SatellitePvt>() {
                @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.
         *
         * <p>The value is in seconds since GPS epoch, regardless of the constellation.
         *
         * <p>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.
         *
         * <p>The value is in seconds since GPS epoch, regardless of the constellation.
         *
         * <p>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);
        }
    }
}