/**@class android.widget.ProgressBar
@extends android.view.View

 <p>
 A user interface element that indicates the progress of an operation.
 Progress bar supports two modes to represent progress: determinate, and indeterminate. For
 a visual overview of the difference between determinate and indeterminate progress modes, see
 <a href="https://material.io/guidelines/components/progress-activity.html#progress-activity-types-of-indicators">
 Progress & activity</a>.
 Display progress bars to a user in a non-interruptive way.
 Show the progress bar in your app's user interface or in a notification
 instead of within a dialog.
 </p>
 <h3>Indeterminate Progress</h3>
 <p>
 Use indeterminate mode for the progress bar when you do not know how long an
 operation will take.
 Indeterminate mode is the default for progress bar and shows a cyclic animation without a
 specific amount of progress indicated.
 The following example shows an indeterminate progress bar:
 <pre>
 &lt;ProgressBar
      android:id="@+id/indeterminateBar"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      /&gt;
 </pre>
 </p>
 <h3>Determinate Progress</h3>
 <p>
 Use determinate mode for the progress bar when you want to show that a specific quantity of
 progress has occurred.
 For example, the percent remaining of a file being retrieved, the amount records in
 a batch written to database, or the percent remaining of an audio file that is playing.
 <p>
 <p>
 To indicate determinate progress, you set the style of the progress bar to
 {@link android.R.style#Widget_ProgressBar_Horizontal} and set the amount of progress.
 The following example shows a determinate progress bar that is 25% complete:
 <pre>
 &lt;ProgressBar
      android:id="@+id/determinateBar"
      style="@android:style/Widget.ProgressBar.Horizontal"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:progress="25"/&gt;
 </pre>
 You can update the percentage of progress displayed by using the
 {@link #setProgress}(int) method, or by calling
 {@link #incrementProgressBy}(int) to increase the current progress completed
 by a specified amount.
 By default, the progress bar is full when the progress value reaches 100.
 You can adjust this default by setting the
 {@link android.R.styleable#ProgressBar_max android:max} attribute.
 </p>
 <p>Other progress bar styles provided by the system include:</p>
 <ul>
 <li>{@link android.R.style#Widget_ProgressBar_Horizontal Widget.ProgressBar.Horizontal}</li>
 <li>{@link android.R.style#Widget_ProgressBar_Small Widget.ProgressBar.Small}</li>
 <li>{@link android.R.style#Widget_ProgressBar_Large Widget.ProgressBar.Large}</li>
 <li>{@link android.R.style#Widget_ProgressBar_Inverse Widget.ProgressBar.Inverse}</li>
 <li>{@link android.R.style#Widget_ProgressBar_Small_Inverse
 Widget.ProgressBar.Small.Inverse}</li>
 <li>{@link android.R.style#Widget_ProgressBar_Large_Inverse
 Widget.ProgressBar.Large.Inverse}</li>
 </ul>
 <p>The "inverse" styles provide an inverse color scheme for the spinner, which may be necessary
 if your application uses a light colored theme (a white background).</p>

 <p><strong>XML attributes</b></strong>
 <p>
 See {@link android.R.styleable#android.widget.ProgressBar android.widget.ProgressBar Attributes},
 {@link android.R.styleable#View View Attributes}
 </p>

 @attr ref android.R.styleable#ProgressBar_animationResolution
 @attr ref android.R.styleable#ProgressBar_indeterminate
 @attr ref android.R.styleable#ProgressBar_indeterminateBehavior
 @attr ref android.R.styleable#ProgressBar_indeterminateDrawable
 @attr ref android.R.styleable#ProgressBar_indeterminateDuration
 @attr ref android.R.styleable#ProgressBar_indeterminateOnly
 @attr ref android.R.styleable#ProgressBar_interpolator
 @attr ref android.R.styleable#ProgressBar_min
 @attr ref android.R.styleable#ProgressBar_max
 @attr ref android.R.styleable#ProgressBar_maxHeight
 @attr ref android.R.styleable#ProgressBar_maxWidth
 @attr ref android.R.styleable#ProgressBar_minHeight
 @attr ref android.R.styleable#ProgressBar_minWidth
 @attr ref android.R.styleable#ProgressBar_mirrorForRtl
 @attr ref android.R.styleable#ProgressBar_progress
 @attr ref android.R.styleable#ProgressBar_progressDrawable
 @attr ref android.R.styleable#ProgressBar_secondaryProgress
*/
var ProgressBar = {

/**Sets the minimum width the progress bar can have.
@param {Number} minWidth the minimum width to be set, in pixels
@attr ref android.R.styleable#ProgressBar_minWidth
*/
setMinWidth : function(  ) {},

/**
@return {Number} the minimum width the progress bar can have, in pixels
*/
getMinWidth : function(  ) {},

/**Sets the maximum width the progress bar can have.
@param {Number} maxWidth the maximum width to be set, in pixels
@attr ref android.R.styleable#ProgressBar_maxWidth
*/
setMaxWidth : function(  ) {},

/**
@return {Number} the maximum width the progress bar can have, in pixels
*/
getMaxWidth : function(  ) {},

/**Sets the minimum height the progress bar can have.
@param {Number} minHeight the minimum height to be set, in pixels
@attr ref android.R.styleable#ProgressBar_minHeight
*/
setMinHeight : function(  ) {},

/**
@return {Number} the minimum height the progress bar can have, in pixels
*/
getMinHeight : function(  ) {},

/**Sets the maximum height the progress bar can have.
@param {Number} maxHeight the maximum height to be set, in pixels
@attr ref android.R.styleable#ProgressBar_maxHeight
*/
setMaxHeight : function(  ) {},

/**
@return {Number} the maximum height the progress bar can have, in pixels
*/
getMaxHeight : function(  ) {},

/**<p>Indicate whether this progress bar is in indeterminate mode.</p>
@return {Boolean} true if the progress bar is in indeterminate mode
*/
isIndeterminate : function(  ) {},

/**<p>Change the indeterminate mode for this progress bar. In indeterminate
 mode, the progress is ignored and the progress bar shows an infinite
 animation instead.</p>

 If this progress bar's style only supports indeterminate mode (such as the circular
 progress bars), then this will be ignored.
@param {Boolean} indeterminate true to enable the indeterminate mode
*/
setIndeterminate : function(  ) {},

/**<p>Get the drawable used to draw the progress bar in
 indeterminate mode.</p>
@return {Object {android.graphics.drawable.Drawable}} a {@link android.graphics.drawable.Drawable} instance
@see #setIndeterminateDrawable(android.graphics.drawable.Drawable)
@see #setIndeterminate(boolean)
*/
getIndeterminateDrawable : function(  ) {},

/**Define the drawable used to draw the progress bar in indeterminate mode.

 <p>For the Drawable to animate, it must implement {@link Animatable}, or override
 {@link Drawable#onLevelChange(int)}.  A Drawable that implements Animatable will be animated
 via that interface and therefore provides the greatest amount of customization. A Drawable
 that only overrides onLevelChange(int) is animated directly by ProgressBar and only the
 animation {@link android.R.styleable#ProgressBar_indeterminateDuration duration},
 {@link android.R.styleable#ProgressBar_indeterminateBehavior repeating behavior}, and
 {@link #setInterpolator(Interpolator) interpolator} can be modified, and only before the
 indeterminate animation begins.
@param {Object {Drawable}} d the new drawable
@attr ref android.R.styleable#ProgressBar_indeterminateDrawable
@see #getIndeterminateDrawable()
@see #setIndeterminate(boolean)
*/
setIndeterminateDrawable : function(  ) {},

/**Applies a tint to the indeterminate drawable. Does not modify the
 current tint mode, which is {@link PorterDuff.Mode#SRC_IN} by default.
 <p>
 Subsequent calls to {@link #setIndeterminateDrawable}(Drawable) will
 automatically mutate the drawable and apply the specified tint and
 tint mode using
 {@link Drawable#setTintList(ColorStateList)}.
@param {Object {ColorStateList}} tint the tint to apply, may be {@code null} to clear tint
@attr ref android.R.styleable#ProgressBar_indeterminateTint
@see #getIndeterminateTintList()
@see Drawable#setTintList(ColorStateList)
*/
setIndeterminateTintList : function(  ) {},

/**
@return {Object {android.content.res.ColorStateList}} the tint applied to the indeterminate drawable
@attr ref android.R.styleable#ProgressBar_indeterminateTint
@see #setIndeterminateTintList(ColorStateList)
*/
getIndeterminateTintList : function(  ) {},

/**Specifies the blending mode used to apply the tint specified by
 {@link #setIndeterminateTintList}(ColorStateList) to the indeterminate
 drawable. The default mode is {@link PorterDuff.Mode#SRC_IN}.
@param {Object {PorterDuff.Mode}} tintMode the blending mode used to apply the tint, may be
                 {@code null} to clear tint
@attr ref android.R.styleable#ProgressBar_indeterminateTintMode
@see #setIndeterminateTintList(ColorStateList)
@see Drawable#setTintMode(PorterDuff.Mode)
*/
setIndeterminateTintMode : function(  ) {},

/**Specifies the blending mode used to apply the tint specified by
 {@link #setIndeterminateTintList}(ColorStateList) to the indeterminate
 drawable. The default mode is {@link PorterDuff.Mode#SRC_IN}.
@param {Object {BlendMode}} blendMode the blending mode used to apply the tint, may be
                 {@code null} to clear tint
@attr ref android.R.styleable#ProgressBar_indeterminateTintMode
@see #setIndeterminateTintList(ColorStateList)
@see Drawable#setTintBlendMode(BlendMode)
*/
setIndeterminateTintBlendMode : function(  ) {},

/**Returns the blending mode used to apply the tint to the indeterminate
 drawable, if specified.
@return {Object {android.graphics.PorterDuff.Mode}} the blending mode used to apply the tint to the indeterminate
         drawable
@attr ref android.R.styleable#ProgressBar_indeterminateTintMode
@see #setIndeterminateTintMode(PorterDuff.Mode)
*/
getIndeterminateTintMode : function(  ) {},

/**Returns the blending mode used to apply the tint to the indeterminate
 drawable, if specified.
@return {Object {android.graphics.BlendMode}} the blending mode used to apply the tint to the indeterminate
         drawable
@attr ref android.R.styleable#ProgressBar_indeterminateTintMode
@see #setIndeterminateTintBlendMode(BlendMode)
*/
getIndeterminateTintBlendMode : function(  ) {},

/**Define the tileable drawable used to draw the progress bar in
 indeterminate mode.
 <p>
 If the drawable is a BitmapDrawable or contains BitmapDrawables, a
 tiled copy will be generated for display as a progress bar.
@param {Object {Drawable}} d the new drawable
@see #getIndeterminateDrawable()
@see #setIndeterminate(boolean)
*/
setIndeterminateDrawableTiled : function(  ) {},

/**<p>Get the drawable used to draw the progress bar in
 progress mode.</p>
@return {Object {android.graphics.drawable.Drawable}} a {@link android.graphics.drawable.Drawable} instance
@see #setProgressDrawable(android.graphics.drawable.Drawable)
@see #setIndeterminate(boolean)
*/
getProgressDrawable : function(  ) {},

/**Define the drawable used to draw the progress bar in progress mode.
@param {Object {Drawable}} d the new drawable
@see #getProgressDrawable()
@see #setIndeterminate(boolean)
*/
setProgressDrawable : function(  ) {},

/**
@hide 
*/
getMirrorForRtl : function(  ) {},

/**Applies a tint to the progress indicator, if one exists, or to the
 entire progress drawable otherwise. Does not modify the current tint
 mode, which is {@link PorterDuff.Mode#SRC_IN} by default.
 <p>
 The progress indicator should be specified as a layer with
 id {@link android.R.id#progress} in a {@link LayerDrawable}
 used as the progress drawable.
 <p>
 Subsequent calls to {@link #setProgressDrawable}(Drawable) will
 automatically mutate the drawable and apply the specified tint and
 tint mode using
 {@link Drawable#setTintList(ColorStateList)}.
@param {Object {ColorStateList}} tint the tint to apply, may be {@code null} to clear tint
@attr ref android.R.styleable#ProgressBar_progressTint
@see #getProgressTintList()
@see Drawable#setTintList(ColorStateList)
*/
setProgressTintList : function(  ) {},

/**Returns the tint applied to the progress drawable, if specified.
@return {Object {android.content.res.ColorStateList}} the tint applied to the progress drawable
@attr ref android.R.styleable#ProgressBar_progressTint
@see #setProgressTintList(ColorStateList)
*/
getProgressTintList : function(  ) {},

/**Specifies the blending mode used to apply the tint specified by
 {@link #setProgressTintList}(ColorStateList)} to the progress
 indicator. The default mode is {@link PorterDuff.Mode#SRC_IN}.
@param {Object {PorterDuff.Mode}} tintMode the blending mode used to apply the tint, may be
                 {@code null} to clear tint
@attr ref android.R.styleable#ProgressBar_progressTintMode
@see #getProgressTintMode()
@see Drawable#setTintMode(PorterDuff.Mode)
*/
setProgressTintMode : function(  ) {},

/**Specifies the blending mode used to apply the tint specified by
 {@link #setProgressTintList}(ColorStateList)} to the progress
 indicator. The default mode is {@link PorterDuff.Mode#SRC_IN}.
@param {Object {BlendMode}} blendMode the blending mode used to apply the tint, may be
                 {@code null} to clear tint
@attr ref android.R.styleable#ProgressBar_progressTintMode
@see #getProgressTintMode()
@see Drawable#setTintBlendMode(BlendMode)
*/
setProgressTintBlendMode : function(  ) {},

/**Returns the blending mode used to apply the tint to the progress
 drawable, if specified.
@return {Object {android.graphics.PorterDuff.Mode}} the blending mode used to apply the tint to the progress
         drawable
@attr ref android.R.styleable#ProgressBar_progressTintMode
@see #setProgressTintMode(PorterDuff.Mode)
*/
getProgressTintMode : function(  ) {},

/**Returns the blending mode used to apply the tint to the progress
 drawable, if specified.
@return {Object {android.graphics.BlendMode}} the blending mode used to apply the tint to the progress
         drawable
@attr ref android.R.styleable#ProgressBar_progressTintMode
@see #setProgressTintBlendMode(BlendMode)
*/
getProgressTintBlendMode : function(  ) {},

/**Applies a tint to the progress background, if one exists. Does not
 modify the current tint mode, which is
 {@link PorterDuff.Mode#SRC_ATOP} by default.
 <p>
 The progress background must be specified as a layer with
 id {@link android.R.id#background} in a {@link LayerDrawable}
 used as the progress drawable.
 <p>
 Subsequent calls to {@link #setProgressDrawable}(Drawable) where the
 drawable contains a progress background will automatically mutate the
 drawable and apply the specified tint and tint mode using
 {@link Drawable#setTintList(ColorStateList)}.
@param {Object {ColorStateList}} tint the tint to apply, may be {@code null} to clear tint
@attr ref android.R.styleable#ProgressBar_progressBackgroundTint
@see #getProgressBackgroundTintList()
@see Drawable#setTintList(ColorStateList)
*/
setProgressBackgroundTintList : function(  ) {},

/**Returns the tint applied to the progress background, if specified.
@return {Object {android.content.res.ColorStateList}} the tint applied to the progress background
@attr ref android.R.styleable#ProgressBar_progressBackgroundTint
@see #setProgressBackgroundTintList(ColorStateList)
*/
getProgressBackgroundTintList : function(  ) {},

/**Specifies the blending mode used to apply the tint specified by
 {@link #setProgressBackgroundTintList}(ColorStateList)} to the progress
 background. The default mode is {@link PorterDuff.Mode#SRC_IN}.
@param {Object {PorterDuff.Mode}} tintMode the blending mode used to apply the tint, may be
                 {@code null} to clear tint
@attr ref android.R.styleable#ProgressBar_progressBackgroundTintMode
@see #setProgressBackgroundTintList(ColorStateList)
@see Drawable#setTintMode(PorterDuff.Mode)
*/
setProgressBackgroundTintMode : function(  ) {},

/**Specifies the blending mode used to apply the tint specified by
 {@link #setProgressBackgroundTintList}(ColorStateList)} to the progress
 background. The default mode is {@link BlendMode#SRC_IN}.
@param {Object {BlendMode}} blendMode the blending mode used to apply the tint, may be
                 {@code null} to clear tint
@attr ref android.R.styleable#ProgressBar_progressBackgroundTintMode
@see #setProgressBackgroundTintList(ColorStateList)
@see Drawable#setTintBlendMode(BlendMode)
*/
setProgressBackgroundTintBlendMode : function(  ) {},

/**
@return {Object {android.graphics.PorterDuff.Mode}} the blending mode used to apply the tint to the progress
         background
@attr ref android.R.styleable#ProgressBar_progressBackgroundTintMode
@see #setProgressBackgroundTintMode(PorterDuff.Mode)
*/
getProgressBackgroundTintMode : function(  ) {},

/**
@return {Object {android.graphics.BlendMode}} the blending mode used to apply the tint to the progress
         background
@attr ref android.R.styleable#ProgressBar_progressBackgroundTintMode
@see #setProgressBackgroundTintBlendMode(BlendMode)
*/
getProgressBackgroundTintBlendMode : function(  ) {},

/**Applies a tint to the secondary progress indicator, if one exists.
 Does not modify the current tint mode, which is
 {@link PorterDuff.Mode#SRC_ATOP} by default.
 <p>
 The secondary progress indicator must be specified as a layer with
 id {@link android.R.id#secondaryProgress} in a {@link LayerDrawable}
 used as the progress drawable.
 <p>
 Subsequent calls to {@link #setProgressDrawable}(Drawable) where the
 drawable contains a secondary progress indicator will automatically
 mutate the drawable and apply the specified tint and tint mode using
 {@link Drawable#setTintList(ColorStateList)}.
@param {Object {ColorStateList}} tint the tint to apply, may be {@code null} to clear tint
@attr ref android.R.styleable#ProgressBar_secondaryProgressTint
@see #getSecondaryProgressTintList()
@see Drawable#setTintList(ColorStateList)
*/
setSecondaryProgressTintList : function(  ) {},

/**Returns the tint applied to the secondary progress drawable, if
 specified.
@return {Object {android.content.res.ColorStateList}} the tint applied to the secondary progress drawable
@attr ref android.R.styleable#ProgressBar_secondaryProgressTint
@see #setSecondaryProgressTintList(ColorStateList)
*/
getSecondaryProgressTintList : function(  ) {},

/**Specifies the blending mode used to apply the tint specified by
 {@link #setSecondaryProgressTintList}(ColorStateList)} to the secondary
 progress indicator. The default mode is
 {@link PorterDuff.Mode#SRC_ATOP}.
@param {Object {PorterDuff.Mode}} tintMode the blending mode used to apply the tint, may be
                 {@code null} to clear tint
@attr ref android.R.styleable#ProgressBar_secondaryProgressTintMode
@see #setSecondaryProgressTintList(ColorStateList)
@see Drawable#setTintMode(PorterDuff.Mode)
*/
setSecondaryProgressTintMode : function(  ) {},

/**Specifies the blending mode used to apply the tint specified by
 {@link #setSecondaryProgressTintList}(ColorStateList)} to the secondary
 progress indicator. The default mode is
 {@link PorterDuff.Mode#SRC_ATOP}.
@param {Object {BlendMode}} blendMode the blending mode used to apply the tint, may be
                 {@code null} to clear tint
@attr ref android.R.styleable#ProgressBar_secondaryProgressTintMode
@see #setSecondaryProgressTintList(ColorStateList)
@see Drawable#setTintBlendMode(BlendMode)
*/
setSecondaryProgressTintBlendMode : function(  ) {},

/**Returns the blending mode used to apply the tint to the secondary
 progress drawable, if specified.
@return {Object {android.graphics.PorterDuff.Mode}} the blending mode used to apply the tint to the secondary
         progress drawable
@attr ref android.R.styleable#ProgressBar_secondaryProgressTintMode
@see #setSecondaryProgressTintMode(PorterDuff.Mode)
*/
getSecondaryProgressTintMode : function(  ) {},

/**Returns the blending mode used to apply the tint to the secondary
 progress drawable, if specified.
@return {Object {android.graphics.BlendMode}} the blending mode used to apply the tint to the secondary
         progress drawable
@attr ref android.R.styleable#ProgressBar_secondaryProgressTintMode
@see #setSecondaryProgressTintBlendMode(BlendMode)
*/
getSecondaryProgressTintBlendMode : function(  ) {},

/**Define the tileable drawable used to draw the progress bar in
 progress mode.
 <p>
 If the drawable is a BitmapDrawable or contains BitmapDrawables, a
 tiled copy will be generated for display as a progress bar.
@param {Object {Drawable}} d the new drawable
@see #getProgressDrawable()
@see #setIndeterminate(boolean)
*/
setProgressDrawableTiled : function(  ) {},

/**Returns the drawable currently used to draw the progress bar. This will be
 either {@link #getProgressDrawable}() or {@link #getIndeterminateDrawable}()
 depending on whether the progress bar is in determinate or indeterminate mode.
@return {Object {android.graphics.drawable.Drawable}} the drawable currently used to draw the progress bar
*/
getCurrentDrawable : function(  ) {},

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

/**
@hide 
*/
onResolveDrawables : function(  ) {},

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

/**Sets the current progress to the specified value. Does not do anything
 if the progress bar is in indeterminate mode.
 <p>
 This method will immediately update the visual position of the progress
 indicator. To animate the visual position to the target value, use
 {@link #setProgress(int, boolean)}}.
@param {Number} progress the new progress, between {@link #getMin()} and {@link #getMax()}
@see #setIndeterminate(boolean)
@see #isIndeterminate()
@see #getProgress()
@see #incrementProgressBy(int)
*/
setProgress : function(  ) {},

/**Sets the current progress to the specified value, optionally animating
 the visual position between the current and target values.
 <p>
 Animation does not affect the result of {@link #getProgress}(), which
 will return the target value immediately after this method is called.
@param {Number} progress the new progress value, between {@link #getMin()} and {@link #getMax()}
@param {Boolean} animate {@code true} to animate between the current and target
                values or {@code false} to not animate
*/
setProgress : function(  ) {},

/**<p>
 Set the current secondary progress to the specified value. Does not do
 anything if the progress bar is in indeterminate mode.
 </p>
@param {Number} secondaryProgress the new secondary progress, between {@link #getMin()} and
 {@link #getMax()}
@see #setIndeterminate(boolean)
@see #isIndeterminate()
@see #getSecondaryProgress()
@see #incrementSecondaryProgressBy(int)
*/
setSecondaryProgress : function(  ) {},

/**<p>Get the progress bar's current level of progress. Return 0 when the
 progress bar is in indeterminate mode.</p>
@return {Number} the current progress, between {@link #getMin()} and {@link #getMax()}
@see #setIndeterminate(boolean)
@see #isIndeterminate()
@see #setProgress(int)
@see #setMax(int)
@see #getMax()
*/
getProgress : function(  ) {},

/**<p>Get the progress bar's current level of secondary progress. Return 0 when the
 progress bar is in indeterminate mode.</p>
@return {Number} the current secondary progress, between {@link #getMin()} and {@link #getMax()}
@see #setIndeterminate(boolean)
@see #isIndeterminate()
@see #setSecondaryProgress(int)
@see #setMax(int)
@see #getMax()
*/
getSecondaryProgress : function(  ) {},

/**<p>Return the lower limit of this progress bar's range.</p>
@return {Number} a positive integer
@see #setMin(int)
@see #getProgress()
@see #getSecondaryProgress()
*/
getMin : function(  ) {},

/**<p>Return the upper limit of this progress bar's range.</p>
@return {Number} a positive integer
@see #setMax(int)
@see #getProgress()
@see #getSecondaryProgress()
*/
getMax : function(  ) {},

/**<p>Set the lower range of the progress bar to <tt>min</tt>.</p>
@param {Number} min the lower range of this progress bar
@see #getMin()
@see #setProgress(int)
@see #setSecondaryProgress(int)
*/
setMin : function(  ) {},

/**<p>Set the upper range of the progress bar <tt>max</tt>.</p>
@param {Number} max the upper range of this progress bar
@see #getMax()
@see #setProgress(int)
@see #setSecondaryProgress(int)
*/
setMax : function(  ) {},

/**<p>Increase the progress bar's progress by the specified amount.</p>
@param {Number} diff the amount by which the progress must be increased
@see #setProgress(int)
*/
incrementProgressBy : function(  ) {},

/**<p>Increase the progress bar's secondary progress by the specified amount.</p>
@param {Number} diff the amount by which the secondary progress must be increased
@see #setSecondaryProgress(int)
*/
incrementSecondaryProgressBy : function(  ) {},

/**Sets the acceleration curve for the indeterminate animation.

 <p>The interpolator is loaded as a resource from the specified context. Defaults to a linear
 interpolation.

 <p>The interpolator only affects the indeterminate animation if the
 {@link #setIndeterminateDrawable(Drawable) supplied indeterminate drawable} does not
 implement {@link Animatable}.

 <p>This call must be made before the indeterminate animation starts for it to have an affect.
@param {Object {Context}} context The application environment
@param {Number} resID The resource identifier of the interpolator to load
@attr ref android.R.styleable#ProgressBar_interpolator
@see #setInterpolator(Interpolator)
@see #getInterpolator()
*/
setInterpolator : function(  ) {},

/**Sets the acceleration curve for the indeterminate animation.
 Defaults to a linear interpolation.

 <p>The interpolator only affects the indeterminate animation if the
 {@link #setIndeterminateDrawable(Drawable) supplied indeterminate drawable} does not
 implement {@link Animatable}.

 <p>This call must be made before the indeterminate animation starts for it to have
 an affect.
@param {Object {Interpolator}} interpolator The interpolator which defines the acceleration curve
@attr ref android.R.styleable#ProgressBar_interpolator
@see #setInterpolator(Context, int)
@see #getInterpolator()
*/
setInterpolator : function(  ) {},

/**Gets the acceleration curve type for the indeterminate animation.
@return {Object {android.view.animation.Interpolator}} the {@link Interpolator} associated to this animation
@attr ref android.R.styleable#ProgressBar_interpolator
@see #setInterpolator(Context, int)
@see #setInterpolator(Interpolator)
*/
getInterpolator : function(  ) {},

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

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

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

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

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

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

/**
@hide 
*/
onInitializeAccessibilityEventInternal : function(  ) {},

/**
@hide 
*/
onInitializeAccessibilityNodeInfoInternal : function(  ) {},

/**Returns whether the ProgressBar is animating or not. This is essentially the same
 as whether the ProgressBar is {@link #isIndeterminate() indeterminate} and visible,
 as indeterminate ProgressBars are always animating, and non-indeterminate
 ProgressBars are not animating.
@return {Boolean} true if the ProgressBar is animating, false otherwise.
*/
isAnimating : function(  ) {},


};