package io.fabric.sdk.android;

import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import io.fabric.sdk.android.services.common.IdManager;
import io.fabric.sdk.android.services.concurrency.DependsOn;
import io.fabric.sdk.android.services.concurrency.PriorityThreadPoolExecutor;
import io.fabric.sdk.android.services.concurrency.UnmetDependencyException;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicBoolean;
import ta;
import tb;
import tc;

public class Fabric
{
  public static final String TAG = "Fabric";
  static volatile Fabric a;
  static final Logger b = new DefaultLogger();
  final Logger c;
  final boolean d;
  private final Context e;
  private final Map<Class<? extends Kit>, Kit> f;
  private final ExecutorService g;
  private final Handler h;
  private final InitializationCallback<Fabric> i;
  private final InitializationCallback<?> j;
  private final IdManager k;
  private ActivityLifecycleManager l;
  private WeakReference<Activity> m;
  private AtomicBoolean n;
  
  Fabric(Context paramContext, Map<Class<? extends Kit>, Kit> paramMap, PriorityThreadPoolExecutor paramPriorityThreadPoolExecutor, Handler paramHandler, Logger paramLogger, boolean paramBoolean, InitializationCallback paramInitializationCallback, IdManager paramIdManager)
  {
    this.e = paramContext.getApplicationContext();
    this.f = paramMap;
    this.g = paramPriorityThreadPoolExecutor;
    this.h = paramHandler;
    this.c = paramLogger;
    this.d = paramBoolean;
    this.i = paramInitializationCallback;
    this.n = new AtomicBoolean(false);
    this.j = new InitializationCallback()
    {
      final CountDownLatch a = new CountDownLatch(this.b);
      
      public final void failure(Exception paramAnonymousException)
      {
        Fabric.b(Fabric.this).failure(paramAnonymousException);
      }
      
      public final void success(Object paramAnonymousObject)
      {
        this.a.countDown();
        if (this.a.getCount() == 0L)
        {
          Fabric.a(Fabric.this).set(true);
          Fabric.b(Fabric.this).success(Fabric.this);
        }
      }
    };
    this.k = paramIdManager;
    if ((paramContext instanceof Activity)) {}
    for (paramContext = (Activity)paramContext;; paramContext = null)
    {
      setCurrentActivity(paramContext);
      return;
    }
  }
  
  private static void a(Map<Class<? extends Kit>, Kit> paramMap, Kit paramKit)
  {
    Object localObject1 = paramKit.dependsOnAnnotation;
    if (localObject1 != null)
    {
      localObject1 = ((DependsOn)localObject1).value();
      int i2 = localObject1.length;
      int i1 = 0;
      while (i1 < i2)
      {
        Object localObject2 = localObject1[i1];
        if (((Class)localObject2).isInterface())
        {
          Iterator localIterator = paramMap.values().iterator();
          while (localIterator.hasNext())
          {
            Kit localKit = (Kit)localIterator.next();
            if (((Class)localObject2).isAssignableFrom(localKit.getClass())) {
              paramKit.initializationTask.addDependency(localKit.initializationTask);
            }
          }
        }
        if ((Kit)paramMap.get(localObject2) == null) {
          throw new UnmetDependencyException("Referenced Kit was null, does the kit exist?");
        }
        paramKit.initializationTask.addDependency(((Kit)paramMap.get(localObject2)).initializationTask);
        i1 += 1;
      }
    }
  }
  
  private static void a(Map<Class<? extends Kit>, Kit> paramMap, Collection<? extends Kit> paramCollection)
  {
    paramCollection = paramCollection.iterator();
    while (paramCollection.hasNext())
    {
      Kit localKit = (Kit)paramCollection.next();
      paramMap.put(localKit.getClass(), localKit);
      if ((localKit instanceof KitGroup)) {
        a(paramMap, ((KitGroup)localKit).getKits());
      }
    }
  }
  
  private static void c(Fabric paramFabric)
  {
    a = paramFabric;
    paramFabric.l = new ActivityLifecycleManager(paramFabric.e);
    paramFabric.l.registerCallbacks(new ActivityLifecycleManager.Callbacks()
    {
      public final void onActivityCreated(Activity paramAnonymousActivity, Bundle paramAnonymousBundle)
      {
        Fabric.this.setCurrentActivity(paramAnonymousActivity);
      }
      
      public final void onActivityResumed(Activity paramAnonymousActivity)
      {
        Fabric.this.setCurrentActivity(paramAnonymousActivity);
      }
      
      public final void onActivityStarted(Activity paramAnonymousActivity)
      {
        Fabric.this.setCurrentActivity(paramAnonymousActivity);
      }
    });
    Object localObject1 = paramFabric.e;
    Object localObject2 = new ta(((Context)localObject1).getPackageCodePath());
    localObject2 = paramFabric.getExecutorService().submit((Callable)localObject2);
    Object localObject3 = paramFabric.getKits();
    localObject2 = new tc((Future)localObject2, (Collection)localObject3);
    localObject3 = new ArrayList((Collection)localObject3);
    Collections.sort((List)localObject3);
    ((tc)localObject2).injectParameters((Context)localObject1, paramFabric, InitializationCallback.EMPTY, paramFabric.k);
    Object localObject4 = ((List)localObject3).iterator();
    while (((Iterator)localObject4).hasNext()) {
      ((Kit)((Iterator)localObject4).next()).injectParameters((Context)localObject1, paramFabric, paramFabric.j, paramFabric.k);
    }
    ((tc)localObject2).initialize();
    if (getLogger().isLoggable("Fabric", 3)) {}
    for (localObject1 = new StringBuilder("Initializing ").append(paramFabric.getIdentifier()).append(" [Version: ").append(paramFabric.getVersion()).append("], with the following kits:\n");; localObject1 = null)
    {
      localObject3 = ((List)localObject3).iterator();
      while (((Iterator)localObject3).hasNext())
      {
        localObject4 = (Kit)((Iterator)localObject3).next();
        ((Kit)localObject4).initializationTask.addDependency(((tc)localObject2).initializationTask);
        a(paramFabric.f, (Kit)localObject4);
        ((Kit)localObject4).initialize();
        if (localObject1 != null) {
          ((StringBuilder)localObject1).append(((Kit)localObject4).getIdentifier()).append(" [Version: ").append(((Kit)localObject4).getVersion()).append("]\n");
        }
      }
    }
    if (localObject1 != null) {
      getLogger().d("Fabric", ((StringBuilder)localObject1).toString());
    }
  }
  
  public static <T extends Kit> T getKit(Class<T> paramClass)
  {
    if (a == null) {
      throw new IllegalStateException("Must Initialize Fabric before using singleton()");
    }
    return (Kit)a.f.get(paramClass);
  }
  
  public static Logger getLogger()
  {
    if (a == null) {
      return b;
    }
    return a.c;
  }
  
  public static boolean isDebuggable()
  {
    if (a == null) {
      return false;
    }
    return a.d;
  }
  
  public static boolean isInitialized()
  {
    return (a != null) && (a.n.get());
  }
  
  public static Fabric with(Context paramContext, Kit... paramVarArgs)
  {
    if (a == null) {}
    try
    {
      if (a == null) {
        c(new Builder(paramContext).kits(paramVarArgs).build());
      }
      return a;
    }
    finally {}
  }
  
  public static Fabric with(Fabric paramFabric)
  {
    if (a == null) {}
    try
    {
      if (a == null) {
        c(paramFabric);
      }
      return a;
    }
    finally {}
  }
  
  public ActivityLifecycleManager getActivityLifecycleManager()
  {
    return this.l;
  }
  
  public String getAppIdentifier()
  {
    return this.k.getAppIdentifier();
  }
  
  public String getAppInstallIdentifier()
  {
    return this.k.getAppInstallIdentifier();
  }
  
  public Activity getCurrentActivity()
  {
    if (this.m != null) {
      return (Activity)this.m.get();
    }
    return null;
  }
  
  public ExecutorService getExecutorService()
  {
    return this.g;
  }
  
  public String getIdentifier()
  {
    return "io.fabric.sdk.android:fabric";
  }
  
  public Collection<Kit> getKits()
  {
    return this.f.values();
  }
  
  public Handler getMainHandler()
  {
    return this.h;
  }
  
  public String getVersion()
  {
    return "1.3.15.167";
  }
  
  public Fabric setCurrentActivity(Activity paramActivity)
  {
    this.m = new WeakReference(paramActivity);
    return this;
  }
  
  public static class Builder
  {
    private final Context a;
    private Kit[] b;
    private PriorityThreadPoolExecutor c;
    private Handler d;
    private Logger e;
    private boolean f;
    private String g;
    private String h;
    private InitializationCallback<Fabric> i;
    
    public Builder(Context paramContext)
    {
      if (paramContext == null) {
        throw new IllegalArgumentException("Context must not be null.");
      }
      this.a = paramContext;
    }
    
    public Builder appIdentifier(String paramString)
    {
      if (paramString == null) {
        throw new IllegalArgumentException("appIdentifier must not be null.");
      }
      if (this.h != null) {
        throw new IllegalStateException("appIdentifier already set.");
      }
      this.h = paramString;
      return this;
    }
    
    public Builder appInstallIdentifier(String paramString)
    {
      if (paramString == null) {
        throw new IllegalArgumentException("appInstallIdentifier must not be null.");
      }
      if (this.g != null) {
        throw new IllegalStateException("appInstallIdentifier already set.");
      }
      this.g = paramString;
      return this;
    }
    
    public Fabric build()
    {
      if (this.c == null) {
        this.c = PriorityThreadPoolExecutor.create();
      }
      if (this.d == null) {
        this.d = new Handler(Looper.getMainLooper());
      }
      if (this.e == null)
      {
        if (this.f) {
          this.e = new DefaultLogger(3);
        }
      }
      else
      {
        if (this.h == null) {
          this.h = this.a.getPackageName();
        }
        if (this.i == null) {
          this.i = InitializationCallback.EMPTY;
        }
        if (this.b != null) {
          break label182;
        }
      }
      label182:
      for (Object localObject = new HashMap();; localObject = Fabric.a(Arrays.asList(this.b)))
      {
        IdManager localIdManager = new IdManager(this.a, this.h, this.g, ((Map)localObject).values());
        return new Fabric(this.a, (Map)localObject, this.c, this.d, this.e, this.f, this.i, localIdManager);
        this.e = new DefaultLogger();
        break;
      }
    }
    
    public Builder debuggable(boolean paramBoolean)
    {
      this.f = paramBoolean;
      return this;
    }
    
    @Deprecated
    public Builder executorService(ExecutorService paramExecutorService)
    {
      return this;
    }
    
    @Deprecated
    public Builder handler(Handler paramHandler)
    {
      return this;
    }
    
    public Builder initializationCallback(InitializationCallback<Fabric> paramInitializationCallback)
    {
      if (paramInitializationCallback == null) {
        throw new IllegalArgumentException("initializationCallback must not be null.");
      }
      if (this.i != null) {
        throw new IllegalStateException("initializationCallback already set.");
      }
      this.i = paramInitializationCallback;
      return this;
    }
    
    public Builder kits(Kit... paramVarArgs)
    {
      if (this.b != null) {
        throw new IllegalStateException("Kits already set.");
      }
      this.b = paramVarArgs;
      return this;
    }
    
    public Builder logger(Logger paramLogger)
    {
      if (paramLogger == null) {
        throw new IllegalArgumentException("Logger must not be null.");
      }
      if (this.e != null) {
        throw new IllegalStateException("Logger already set.");
      }
      this.e = paramLogger;
      return this;
    }
    
    public Builder threadPoolExecutor(PriorityThreadPoolExecutor paramPriorityThreadPoolExecutor)
    {
      if (paramPriorityThreadPoolExecutor == null) {
        throw new IllegalArgumentException("PriorityThreadPoolExecutor must not be null.");
      }
      if (this.c != null) {
        throw new IllegalStateException("PriorityThreadPoolExecutor already set.");
      }
      this.c = paramPriorityThreadPoolExecutor;
      return this;
    }
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/io/fabric/sdk/android/Fabric.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */