/**@class android.location.GnssClock
 implements android.os.Parcelable

@extends java.lang.Object

 A class containing a GPS clock timestamp.

 <p>It represents a measurement of the GPS receiver's clock.
*/
var GnssClock = {

/***/
CREATOR : "null",
/**Sets all contents to the values stored in the provided object.
@hide 
*/
set : function(  ) {},

/**Resets all the contents to its original state.
@hide 
*/
reset : function(  ) {},

/**Returns {@code true} if {@link #getLeapSecond}() is available, {@code false} otherwise.
*/
hasLeapSecond : function(  ) {},

/**Gets the leap second associated with the clock's time.

 <p>The sign of the value is defined by the following equation:
 <pre>
     UtcTimeNanos = TimeNanos - (FullBiasNanos + BiasNanos) - LeapSecond * 1,000,000,000</pre>

 <p>The value is only available if {@link #hasLeapSecond}() is {@code true}.
*/
getLeapSecond : function(  ) {},

/**Sets the leap second associated with the clock's time.
@hide 
*/
setLeapSecond : function(  ) {},

/**Resets the leap second associated with the clock's time.
@hide 
*/
resetLeapSecond : function(  ) {},

/**Gets the GNSS receiver internal hardware clock value in nanoseconds.

 <p>This value is expected to be monotonically increasing while the hardware clock remains
 powered on. For the case of a hardware clock that is not continuously on, see the
 {@link #getHardwareClockDiscontinuityCount} field. The GPS time can be derived by subtracting
 the sum of {@link #getFullBiasNanos}() and {@link #getBiasNanos}() (when they are available)
 from this value. Sub-nanosecond accuracy can be provided by means of {@link #getBiasNanos}().

 <p>The error estimate for this value (if applicable) is {@link #getTimeUncertaintyNanos}().
*/
getTimeNanos : function(  ) {},

/**Sets the GNSS receiver internal clock in nanoseconds.
@hide 
*/
setTimeNanos : function(  ) {},

/**Returns {@code true} if {@link #getTimeUncertaintyNanos}() is available, {@code false}
 otherwise.
*/
hasTimeUncertaintyNanos : function(  ) {},

/**Gets the clock's time Uncertainty (1-Sigma) in nanoseconds.

 <p>The uncertainty is represented as an absolute (single sided) value.

 <p>The value is only available if {@link #hasTimeUncertaintyNanos}() is {@code true}.

 <p>This value is often effectively zero (it is the reference clock by which all other times
 and time uncertainties are measured), and thus this field may often be 0, or not provided.
*/
getTimeUncertaintyNanos : function(  ) {},

/**Sets the clock's Time Uncertainty (1-Sigma) in nanoseconds.
@hide 
*/
setTimeUncertaintyNanos : function(  ) {},

/**Resets the clock's Time Uncertainty (1-Sigma) in nanoseconds.
@hide 
*/
resetTimeUncertaintyNanos : function(  ) {},

/**Returns {@code true} if {@link #getFullBiasNanos}() is available, {@code false} otherwise.
*/
hasFullBiasNanos : function(  ) {},

/**Gets the difference between hardware clock ({@link #getTimeNanos}()) inside GPS receiver and
 the true GPS time since 0000Z, January 6, 1980, in nanoseconds.

 <p>This value is available if the receiver has estimated GPS time. If the computed time is
 for a non-GPS constellation, the time offset of that constellation to GPS has to be applied
 to fill this value. The value is only available if {@link #hasFullBiasNanos}() is
 {@code true}.

 <p>The error estimate for the sum of this field and {@link #getBiasNanos} is
 {@link #getBiasUncertaintyNanos}().

 <p>The sign of the value is defined by the following equation:

 <pre>
     local estimate of GPS time = TimeNanos - (FullBiasNanos + BiasNanos)</pre>
*/
getFullBiasNanos : function(  ) {},

/**Sets the full bias in nanoseconds.
@hide 
*/
setFullBiasNanos : function(  ) {},

/**Resets the full bias in nanoseconds.
@hide 
*/
resetFullBiasNanos : function(  ) {},

/**Returns {@code true} if {@link #getBiasNanos}() is available, {@code false} otherwise.
*/
hasBiasNanos : function(  ) {},

/**Gets the clock's sub-nanosecond bias.

 <p>See the description of how this field is part of converting from hardware clock time, to
 GPS time, in {@link #getFullBiasNanos}().

 <p>The error estimate for the sum of this field and {@link #getFullBiasNanos} is
 {@link #getBiasUncertaintyNanos}().

 <p>The value is only available if {@link #hasBiasNanos}() is {@code true}.
*/
getBiasNanos : function(  ) {},

/**Sets the sub-nanosecond bias.
@hide 
*/
setBiasNanos : function(  ) {},

/**Resets the clock's Bias in nanoseconds.
@hide 
*/
resetBiasNanos : function(  ) {},

/**Returns {@code true} if {@link #getBiasUncertaintyNanos}() is available, {@code false}
 otherwise.
*/
hasBiasUncertaintyNanos : function(  ) {},

/**Gets the clock's Bias Uncertainty (1-Sigma) in nanoseconds.

 <p>See the description of how this field provides the error estimate in the conversion from
 hardware clock time, to GPS time, in {@link #getFullBiasNanos}().

 <p>The value is only available if {@link #hasBiasUncertaintyNanos}() is {@code true}.
*/
getBiasUncertaintyNanos : function(  ) {},

/**Sets the clock's Bias Uncertainty (1-Sigma) in nanoseconds.
@hide 
*/
setBiasUncertaintyNanos : function(  ) {},

/**Resets the clock's Bias Uncertainty (1-Sigma) in nanoseconds.
@hide 
*/
resetBiasUncertaintyNanos : function(  ) {},

/**Returns {@code true} if {@link #getDriftNanosPerSecond}() is available, {@code false}
 otherwise.
*/
hasDriftNanosPerSecond : function(  ) {},

/**Gets the clock's Drift in nanoseconds per second.

 <p>This value is the instantaneous time-derivative of the value provided by
 {@link #getBiasNanos}().

 <p>A positive value indicates that the frequency is higher than the nominal (e.g. GPS master
 clock) frequency. The error estimate for this reported drift is
 {@link #getDriftUncertaintyNanosPerSecond}().

 <p>The value is only available if {@link #hasDriftNanosPerSecond}() is {@code true}.
*/
getDriftNanosPerSecond : function(  ) {},

/**Sets the clock's Drift in nanoseconds per second.
@hide 
*/
setDriftNanosPerSecond : function(  ) {},

/**Resets the clock's Drift in nanoseconds per second.
@hide 
*/
resetDriftNanosPerSecond : function(  ) {},

/**Returns {@code true} if {@link #getDriftUncertaintyNanosPerSecond}() is available,
 {@code false} otherwise.
*/
hasDriftUncertaintyNanosPerSecond : function(  ) {},

/**Gets the clock's Drift Uncertainty (1-Sigma) in nanoseconds per second.

 <p>The value is only available if {@link #hasDriftUncertaintyNanosPerSecond}() is
 {@code true}.
*/
getDriftUncertaintyNanosPerSecond : function(  ) {},

/**Sets the clock's Drift Uncertainty (1-Sigma) in nanoseconds per second.
@hide 
*/
setDriftUncertaintyNanosPerSecond : function(  ) {},

/**Resets the clock's Drift Uncertainty (1-Sigma) in nanoseconds per second.
@hide 
*/
resetDriftUncertaintyNanosPerSecond : function(  ) {},

/**Returns {@code true} if {@link #getElapsedRealtimeNanos}() is available, {@code false}
 otherwise.
*/
hasElapsedRealtimeNanos : function(  ) {},

/**Returns the elapsed real-time of this clock since system boot, in nanoseconds.

 <p>The value is only available if {@link #hasElapsedRealtimeNanos}() is
 {@code true}.
*/
getElapsedRealtimeNanos : function(  ) {},

/**Sets the elapsed real-time of this clock since system boot, in nanoseconds.
@hide 
*/
setElapsedRealtimeNanos : function(  ) {},

/**Resets the elapsed real-time of this clock since system boot, in nanoseconds.
@hide 
*/
resetElapsedRealtimeNanos : function(  ) {},

/**Returns {@code true} if {@link #getElapsedRealtimeUncertaintyNanos}() is available, {@code
 false} otherwise.
*/
hasElapsedRealtimeUncertaintyNanos : function(  ) {},

/**Gets the estimate of the relative precision of the alignment of the
 {@link #getElapsedRealtimeNanos}() timestamp, with the reported measurements in
 nanoseconds (68% confidence).

 <p>The value is only available if {@link #hasElapsedRealtimeUncertaintyNanos}() is
 {@code true}.
*/
getElapsedRealtimeUncertaintyNanos : function(  ) {},

/**Sets the estimate of the relative precision of the alignment of the
 {@link #getElapsedRealtimeNanos}() timestamp, with the reported measurements in
 nanoseconds (68% confidence).
@hide 
*/
setElapsedRealtimeUncertaintyNanos : function(  ) {},

/**Resets the estimate of the relative precision of the alignment of the
 {@link #getElapsedRealtimeNanos}() timestamp, with the reported measurements in
 nanoseconds (68% confidence).
@hide 
*/
resetElapsedRealtimeUncertaintyNanos : function(  ) {},

/**Gets count of hardware clock discontinuities.

 <p>When this value stays the same, vs. a value in a previously reported {@link android.location.GnssClock}, it
 can be safely assumed that the {@code TimeNanos} value has been derived from a clock that has
 been running continuously - e.g. a single continuously powered crystal oscillator, and thus
 the {@code (FullBiasNanos + BiasNanos)} offset can be modelled with traditional clock bias
 &amp; drift models.

 <p>Each time this value changes, vs. the value in a previously reported {@link android.location.GnssClock},
 that suggests the hardware clock may have experienced a discontinuity (e.g. a power cycle or
 other anomaly), so that any assumptions about modelling a smoothly changing
 {@code (FullBiasNanos + BiasNanos)} offset, and a smoothly growing {@code (TimeNanos)}
 between this and the previously reported {@code GnssClock}, should be reset.
*/
getHardwareClockDiscontinuityCount : function(  ) {},

/**Sets count of last hardware clock discontinuity.
@hide 
*/
setHardwareClockDiscontinuityCount : function(  ) {},

/**
*/
writeToParcel : function(  ) {},

/**
*/
describeContents : function(  ) {},

/**
*/
toString : function(  ) {},


};