package android.support.graphics.drawable;

import aa;
import ac;
import android.animation.Animator;
import android.animation.AnimatorInflater;
import android.animation.AnimatorSet;
import android.animation.ArgbEvaluator;
import android.animation.ObjectAnimator;
import android.annotation.SuppressLint;
import android.content.Context;
import android.content.res.ColorStateList;
import android.content.res.Resources;
import android.content.res.Resources.Theme;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.ColorFilter;
import android.graphics.PorterDuff.Mode;
import android.graphics.Rect;
import android.graphics.drawable.Animatable;
import android.graphics.drawable.AnimatedVectorDrawable;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.Drawable.Callback;
import android.graphics.drawable.Drawable.ConstantState;
import android.os.Build.VERSION;
import android.support.annotation.DrawableRes;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.content.res.ResourcesCompat;
import android.support.v4.graphics.drawable.DrawableCompat;
import android.support.v4.util.ArrayMap;
import android.util.AttributeSet;
import android.util.Log;
import android.util.Xml;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;

@SuppressLint({"NewApi"})
public class AnimatedVectorDrawableCompat
  extends ac
  implements Animatable
{
  b a;
  final Drawable.Callback b = new Drawable.Callback()
  {
    public final void invalidateDrawable(Drawable paramAnonymousDrawable)
    {
      AnimatedVectorDrawableCompat.this.invalidateSelf();
    }
    
    public final void scheduleDrawable(Drawable paramAnonymousDrawable, Runnable paramAnonymousRunnable, long paramAnonymousLong)
    {
      AnimatedVectorDrawableCompat.this.scheduleSelf(paramAnonymousRunnable, paramAnonymousLong);
    }
    
    public final void unscheduleDrawable(Drawable paramAnonymousDrawable, Runnable paramAnonymousRunnable)
    {
      AnimatedVectorDrawableCompat.this.unscheduleSelf(paramAnonymousRunnable);
    }
  };
  private a d;
  private Context e;
  private ArgbEvaluator f = null;
  
  AnimatedVectorDrawableCompat()
  {
    this(null, (byte)0);
  }
  
  private AnimatedVectorDrawableCompat(@Nullable Context paramContext)
  {
    this(paramContext, (byte)0);
  }
  
  private AnimatedVectorDrawableCompat(@Nullable Context paramContext, byte paramByte)
  {
    this.e = paramContext;
    this.d = new a();
  }
  
  private void a(Animator paramAnimator)
  {
    Object localObject;
    if ((paramAnimator instanceof AnimatorSet))
    {
      localObject = ((AnimatorSet)paramAnimator).getChildAnimations();
      if (localObject != null)
      {
        int i = 0;
        while (i < ((List)localObject).size())
        {
          a((Animator)((List)localObject).get(i));
          i += 1;
        }
      }
    }
    if ((paramAnimator instanceof ObjectAnimator))
    {
      paramAnimator = (ObjectAnimator)paramAnimator;
      localObject = paramAnimator.getPropertyName();
      if (("fillColor".equals(localObject)) || ("strokeColor".equals(localObject)))
      {
        if (this.f == null) {
          this.f = new ArgbEvaluator();
        }
        paramAnimator.setEvaluator(this.f);
      }
    }
  }
  
  private boolean a()
  {
    ArrayList localArrayList = this.d.c;
    if (localArrayList == null) {
      return false;
    }
    int j = localArrayList.size();
    int i = 0;
    while (i < j)
    {
      if (((Animator)localArrayList.get(i)).isRunning()) {
        return true;
      }
      i += 1;
    }
    return false;
  }
  
  @Nullable
  public static AnimatedVectorDrawableCompat create(@NonNull Context paramContext, @DrawableRes int paramInt)
  {
    if (Build.VERSION.SDK_INT >= 24)
    {
      localObject = new AnimatedVectorDrawableCompat(paramContext);
      ((AnimatedVectorDrawableCompat)localObject).c = ResourcesCompat.getDrawable(paramContext.getResources(), paramInt, paramContext.getTheme());
      ((AnimatedVectorDrawableCompat)localObject).c.setCallback(((AnimatedVectorDrawableCompat)localObject).b);
      ((AnimatedVectorDrawableCompat)localObject).a = new b(((AnimatedVectorDrawableCompat)localObject).c.getConstantState());
      return (AnimatedVectorDrawableCompat)localObject;
    }
    Object localObject = paramContext.getResources();
    try
    {
      localObject = ((Resources)localObject).getXml(paramInt);
      localAttributeSet = Xml.asAttributeSet((XmlPullParser)localObject);
      do
      {
        paramInt = ((XmlPullParser)localObject).next();
      } while ((paramInt != 2) && (paramInt != 1));
      if (paramInt != 2) {
        throw new XmlPullParserException("No start tag found");
      }
    }
    catch (XmlPullParserException paramContext)
    {
      AttributeSet localAttributeSet;
      Log.e("AnimatedVDCompat", "parser error", paramContext);
      return null;
      paramContext = createFromXmlInner(paramContext, paramContext.getResources(), (XmlPullParser)localObject, localAttributeSet, paramContext.getTheme());
      return paramContext;
    }
    catch (IOException paramContext)
    {
      for (;;)
      {
        Log.e("AnimatedVDCompat", "parser error", paramContext);
      }
    }
  }
  
  public static AnimatedVectorDrawableCompat createFromXmlInner(Context paramContext, Resources paramResources, XmlPullParser paramXmlPullParser, AttributeSet paramAttributeSet, Resources.Theme paramTheme)
    throws XmlPullParserException, IOException
  {
    paramContext = new AnimatedVectorDrawableCompat(paramContext);
    paramContext.inflate(paramResources, paramXmlPullParser, paramAttributeSet, paramTheme);
    return paramContext;
  }
  
  public void applyTheme(Resources.Theme paramTheme)
  {
    if (this.c != null) {
      DrawableCompat.applyTheme(this.c, paramTheme);
    }
  }
  
  public boolean canApplyTheme()
  {
    if (this.c != null) {
      return DrawableCompat.canApplyTheme(this.c);
    }
    return false;
  }
  
  public void draw(Canvas paramCanvas)
  {
    if (this.c != null) {
      this.c.draw(paramCanvas);
    }
    do
    {
      return;
      this.d.b.draw(paramCanvas);
    } while (!a());
    invalidateSelf();
  }
  
  public int getAlpha()
  {
    if (this.c != null) {
      return DrawableCompat.getAlpha(this.c);
    }
    return this.d.b.getAlpha();
  }
  
  public int getChangingConfigurations()
  {
    if (this.c != null) {
      return this.c.getChangingConfigurations();
    }
    return super.getChangingConfigurations() | this.d.a;
  }
  
  public Drawable.ConstantState getConstantState()
  {
    if (this.c != null) {
      return new b(this.c.getConstantState());
    }
    return null;
  }
  
  public int getIntrinsicHeight()
  {
    if (this.c != null) {
      return this.c.getIntrinsicHeight();
    }
    return this.d.b.getIntrinsicHeight();
  }
  
  public int getIntrinsicWidth()
  {
    if (this.c != null) {
      return this.c.getIntrinsicWidth();
    }
    return this.d.b.getIntrinsicWidth();
  }
  
  public int getOpacity()
  {
    if (this.c != null) {
      return this.c.getOpacity();
    }
    return this.d.b.getOpacity();
  }
  
  public void inflate(Resources paramResources, XmlPullParser paramXmlPullParser, AttributeSet paramAttributeSet)
    throws XmlPullParserException, IOException
  {
    inflate(paramResources, paramXmlPullParser, paramAttributeSet, null);
  }
  
  public void inflate(Resources paramResources, XmlPullParser paramXmlPullParser, AttributeSet paramAttributeSet, Resources.Theme paramTheme)
    throws XmlPullParserException, IOException
  {
    if (this.c != null)
    {
      DrawableCompat.inflate(this.c, paramResources, paramXmlPullParser, paramAttributeSet, paramTheme);
      return;
    }
    int i = paramXmlPullParser.getEventType();
    int j = paramXmlPullParser.getDepth();
    label36:
    Object localObject1;
    Object localObject2;
    if ((i != 1) && ((paramXmlPullParser.getDepth() >= j + 1) || (i != 3))) {
      if (i == 2)
      {
        localObject1 = paramXmlPullParser.getName();
        if (!"animated-vector".equals(localObject1)) {
          break label183;
        }
        localObject1 = ac.obtainAttributes(paramResources, paramTheme, paramAttributeSet, aa.e);
        i = ((TypedArray)localObject1).getResourceId(0, 0);
        if (i != 0)
        {
          localObject2 = VectorDrawableCompat.create(paramResources, i, paramTheme);
          ((VectorDrawableCompat)localObject2).d = false;
          ((VectorDrawableCompat)localObject2).setCallback(this.b);
          if (this.d.b != null) {
            this.d.b.setCallback(null);
          }
          this.d.b = ((VectorDrawableCompat)localObject2);
        }
        ((TypedArray)localObject1).recycle();
      }
    }
    for (;;)
    {
      i = paramXmlPullParser.next();
      break label36;
      break;
      label183:
      if ("target".equals(localObject1))
      {
        localObject1 = paramResources.obtainAttributes(paramAttributeSet, aa.f);
        localObject2 = ((TypedArray)localObject1).getString(0);
        i = ((TypedArray)localObject1).getResourceId(1, 0);
        if (i != 0)
        {
          if (this.e == null) {
            break label358;
          }
          Animator localAnimator = AnimatorInflater.loadAnimator(this.e, i);
          localAnimator.setTarget(this.d.b.b.b.h.get(localObject2));
          if (Build.VERSION.SDK_INT < 21) {
            a(localAnimator);
          }
          if (this.d.c == null)
          {
            this.d.c = new ArrayList();
            this.d.d = new ArrayMap();
          }
          this.d.c.add(localAnimator);
          this.d.d.put(localAnimator, localObject2);
        }
        ((TypedArray)localObject1).recycle();
      }
    }
    label358:
    throw new IllegalStateException("Context can't be null when inflating animators");
  }
  
  public boolean isAutoMirrored()
  {
    if (this.c != null) {
      return DrawableCompat.isAutoMirrored(this.c);
    }
    return this.d.b.isAutoMirrored();
  }
  
  public boolean isRunning()
  {
    if (this.c != null) {
      return ((AnimatedVectorDrawable)this.c).isRunning();
    }
    ArrayList localArrayList = this.d.c;
    int j = localArrayList.size();
    int i = 0;
    while (i < j)
    {
      if (((Animator)localArrayList.get(i)).isRunning()) {
        return true;
      }
      i += 1;
    }
    return false;
  }
  
  public boolean isStateful()
  {
    if (this.c != null) {
      return this.c.isStateful();
    }
    return this.d.b.isStateful();
  }
  
  public Drawable mutate()
  {
    if (this.c != null) {
      this.c.mutate();
    }
    return this;
  }
  
  protected void onBoundsChange(Rect paramRect)
  {
    if (this.c != null)
    {
      this.c.setBounds(paramRect);
      return;
    }
    this.d.b.setBounds(paramRect);
  }
  
  protected boolean onLevelChange(int paramInt)
  {
    if (this.c != null) {
      return this.c.setLevel(paramInt);
    }
    return this.d.b.setLevel(paramInt);
  }
  
  protected boolean onStateChange(int[] paramArrayOfInt)
  {
    if (this.c != null) {
      return this.c.setState(paramArrayOfInt);
    }
    return this.d.b.setState(paramArrayOfInt);
  }
  
  public void setAlpha(int paramInt)
  {
    if (this.c != null)
    {
      this.c.setAlpha(paramInt);
      return;
    }
    this.d.b.setAlpha(paramInt);
  }
  
  public void setAutoMirrored(boolean paramBoolean)
  {
    if (this.c != null)
    {
      this.c.setAutoMirrored(paramBoolean);
      return;
    }
    this.d.b.setAutoMirrored(paramBoolean);
  }
  
  public void setColorFilter(ColorFilter paramColorFilter)
  {
    if (this.c != null)
    {
      this.c.setColorFilter(paramColorFilter);
      return;
    }
    this.d.b.setColorFilter(paramColorFilter);
  }
  
  public void setTint(int paramInt)
  {
    if (this.c != null)
    {
      DrawableCompat.setTint(this.c, paramInt);
      return;
    }
    this.d.b.setTint(paramInt);
  }
  
  public void setTintList(ColorStateList paramColorStateList)
  {
    if (this.c != null)
    {
      DrawableCompat.setTintList(this.c, paramColorStateList);
      return;
    }
    this.d.b.setTintList(paramColorStateList);
  }
  
  public void setTintMode(PorterDuff.Mode paramMode)
  {
    if (this.c != null)
    {
      DrawableCompat.setTintMode(this.c, paramMode);
      return;
    }
    this.d.b.setTintMode(paramMode);
  }
  
  public boolean setVisible(boolean paramBoolean1, boolean paramBoolean2)
  {
    if (this.c != null) {
      return this.c.setVisible(paramBoolean1, paramBoolean2);
    }
    this.d.b.setVisible(paramBoolean1, paramBoolean2);
    return super.setVisible(paramBoolean1, paramBoolean2);
  }
  
  public void start()
  {
    if (this.c != null) {
      ((AnimatedVectorDrawable)this.c).start();
    }
    while (a()) {
      return;
    }
    ArrayList localArrayList = this.d.c;
    int j = localArrayList.size();
    int i = 0;
    while (i < j)
    {
      ((Animator)localArrayList.get(i)).start();
      i += 1;
    }
    invalidateSelf();
  }
  
  public void stop()
  {
    if (this.c != null) {
      ((AnimatedVectorDrawable)this.c).stop();
    }
    for (;;)
    {
      return;
      ArrayList localArrayList = this.d.c;
      int j = localArrayList.size();
      int i = 0;
      while (i < j)
      {
        ((Animator)localArrayList.get(i)).end();
        i += 1;
      }
    }
  }
  
  static final class a
    extends Drawable.ConstantState
  {
    int a;
    VectorDrawableCompat b;
    ArrayList<Animator> c;
    ArrayMap<Animator, String> d;
    
    public final int getChangingConfigurations()
    {
      return this.a;
    }
    
    public final Drawable newDrawable()
    {
      throw new IllegalStateException("No constant state support for SDK < 24.");
    }
    
    public final Drawable newDrawable(Resources paramResources)
    {
      throw new IllegalStateException("No constant state support for SDK < 24.");
    }
  }
  
  static final class b
    extends Drawable.ConstantState
  {
    private final Drawable.ConstantState a;
    
    public b(Drawable.ConstantState paramConstantState)
    {
      this.a = paramConstantState;
    }
    
    public final boolean canApplyTheme()
    {
      return this.a.canApplyTheme();
    }
    
    public final int getChangingConfigurations()
    {
      return this.a.getChangingConfigurations();
    }
    
    public final Drawable newDrawable()
    {
      AnimatedVectorDrawableCompat localAnimatedVectorDrawableCompat = new AnimatedVectorDrawableCompat();
      localAnimatedVectorDrawableCompat.c = this.a.newDrawable();
      localAnimatedVectorDrawableCompat.c.setCallback(localAnimatedVectorDrawableCompat.b);
      return localAnimatedVectorDrawableCompat;
    }
    
    public final Drawable newDrawable(Resources paramResources)
    {
      AnimatedVectorDrawableCompat localAnimatedVectorDrawableCompat = new AnimatedVectorDrawableCompat();
      localAnimatedVectorDrawableCompat.c = this.a.newDrawable(paramResources);
      localAnimatedVectorDrawableCompat.c.setCallback(localAnimatedVectorDrawableCompat.b);
      return localAnimatedVectorDrawableCompat;
    }
    
    public final Drawable newDrawable(Resources paramResources, Resources.Theme paramTheme)
    {
      AnimatedVectorDrawableCompat localAnimatedVectorDrawableCompat = new AnimatedVectorDrawableCompat();
      localAnimatedVectorDrawableCompat.c = this.a.newDrawable(paramResources, paramTheme);
      localAnimatedVectorDrawableCompat.c.setCallback(localAnimatedVectorDrawableCompat.b);
      return localAnimatedVectorDrawableCompat;
    }
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/graphics/drawable/AnimatedVectorDrawableCompat.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */