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.ActivityLifecycleManager;
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.Map;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicBoolean;

/* loaded from: classes2.dex */
public class Fabric {
    static volatile Fabric l;
    static final Logger m = new DefaultLogger();
    private final Context a;
    private final Map<Class<? extends Kit>, Kit> b;
    private final ExecutorService c;
    private final Handler d;
    private final InitializationCallback<Fabric> e;
    private final InitializationCallback<?> f;
    private final IdManager g;
    private ActivityLifecycleManager h;
    private AtomicBoolean i = new AtomicBoolean(false);
    final Logger j;
    final boolean k;

    Fabric(Context context, Map<Class<? extends Kit>, Kit> map, PriorityThreadPoolExecutor priorityThreadPoolExecutor, Handler handler, Logger logger, boolean z, InitializationCallback initializationCallback, IdManager idManager, Activity activity) {
        this.a = context;
        this.b = map;
        this.c = priorityThreadPoolExecutor;
        this.d = handler;
        this.j = logger;
        this.k = z;
        this.e = initializationCallback;
        this.f = a(map.size());
        this.g = idManager;
        a(activity);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static Activity d(Context context) {
        if (context instanceof Activity) {
            return (Activity) context;
        }
        return null;
    }

    public static Logger g() {
        return l == null ? m : l.j;
    }

    private void h() {
        this.h = new ActivityLifecycleManager(this.a);
        this.h.a(new ActivityLifecycleManager.Callbacks() { // from class: io.fabric.sdk.android.Fabric.1
            @Override // io.fabric.sdk.android.ActivityLifecycleManager.Callbacks
            public void a(Activity activity, Bundle bundle) {
                Fabric.this.a(activity);
            }

            @Override // io.fabric.sdk.android.ActivityLifecycleManager.Callbacks
            public void c(Activity activity) {
                Fabric.this.a(activity);
            }

            @Override // io.fabric.sdk.android.ActivityLifecycleManager.Callbacks
            public void d(Activity activity) {
                Fabric.this.a(activity);
            }
        });
        b(this.a);
    }

    public static boolean i() {
        if (l == null) {
            return false;
        }
        return l.k;
    }

    static Fabric j() {
        if (l != null) {
            return l;
        }
        throw new IllegalStateException("Must Initialize Fabric before using singleton()");
    }

    public String c() {
        return "io.fabric.sdk.android:fabric";
    }

    public Handler e() {
        return this.d;
    }

    public String f() {
        return "1.3.17.dev";
    }

    private static void c(Fabric fabric) {
        l = fabric;
        fabric.h();
    }

    void b(Context context) {
        StringBuilder sb;
        Future<Map<String, KitInfo>> a = a(context);
        Collection<Kit> d = d();
        Onboarding onboarding = new Onboarding(a, d);
        ArrayList<Kit> arrayList = new ArrayList(d);
        Collections.sort(arrayList);
        onboarding.a(context, this, InitializationCallback.a, this.g);
        Iterator it = arrayList.iterator();
        while (it.hasNext()) {
            ((Kit) it.next()).a(context, this, this.f, this.g);
        }
        onboarding.n();
        if (g().a("Fabric", 3)) {
            sb = new StringBuilder("Initializing ");
            sb.append(c());
            sb.append(" [Version: ");
            sb.append(f());
            sb.append("], with the following kits:\n");
        } else {
            sb = null;
        }
        for (Kit kit : arrayList) {
            kit.b.a(onboarding.b);
            a(this.b, kit);
            kit.n();
            if (sb != null) {
                sb.append(kit.g());
                sb.append(" [Version: ");
                sb.append(kit.i());
                sb.append("]\n");
            }
        }
        if (sb != null) {
            g().d("Fabric", sb.toString());
        }
    }

    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 context) {
            if (context == null) {
                throw new IllegalArgumentException("Context must not be null.");
            }
            this.a = context;
        }

        public Builder a(Kit... kitArr) {
            if (this.b != null) {
                throw new IllegalStateException("Kits already set.");
            }
            this.b = kitArr;
            return this;
        }

        public Fabric a() {
            Map b;
            if (this.c == null) {
                this.c = PriorityThreadPoolExecutor.a();
            }
            if (this.d == null) {
                this.d = new Handler(Looper.getMainLooper());
            }
            if (this.e == null) {
                if (this.f) {
                    this.e = new DefaultLogger(3);
                } else {
                    this.e = new DefaultLogger();
                }
            }
            if (this.h == null) {
                this.h = this.a.getPackageName();
            }
            if (this.i == null) {
                this.i = InitializationCallback.a;
            }
            Kit[] kitArr = this.b;
            if (kitArr != null) {
                b = Fabric.b(Arrays.asList(kitArr));
            } else {
                b = new HashMap();
            }
            Map map = b;
            Context applicationContext = this.a.getApplicationContext();
            return new Fabric(applicationContext, map, this.c, this.d, this.e, this.f, this.i, new IdManager(applicationContext, this.h, this.g, map.values()), Fabric.d(this.a));
        }
    }

    public static Fabric a(Context context, Kit... kitArr) {
        if (l == null) {
            synchronized (Fabric.class) {
                if (l == null) {
                    Builder builder = new Builder(context);
                    builder.a(kitArr);
                    c(builder.a());
                }
            }
        }
        return l;
    }

    public Collection<Kit> d() {
        return this.b.values();
    }

    public Fabric a(Activity activity) {
        new WeakReference(activity);
        return this;
    }

    void a(Map<Class<? extends Kit>, Kit> map, Kit kit) {
        DependsOn dependsOn = kit.f;
        if (dependsOn != null) {
            for (Class<?> cls : dependsOn.value()) {
                if (cls.isInterface()) {
                    for (Kit kit2 : map.values()) {
                        if (cls.isAssignableFrom(kit2.getClass())) {
                            kit.b.a(kit2.b);
                        }
                    }
                } else if (map.get(cls) != null) {
                    kit.b.a(map.get(cls).b);
                } else {
                    throw new UnmetDependencyException("Referenced Kit was null, does the kit exist?");
                }
            }
        }
    }

    public ActivityLifecycleManager a() {
        return this.h;
    }

    public static <T extends Kit> T a(Class<T> cls) {
        return (T) j().b.get(cls);
    }

    /* JADX WARN: Multi-variable type inference failed */
    private static void a(Map<Class<? extends Kit>, Kit> map, Collection<? extends Kit> collection) {
        for (Object obj : collection) {
            map.put(obj.getClass(), obj);
            if (obj instanceof KitGroup) {
                a(map, ((KitGroup) obj).a());
            }
        }
    }

    InitializationCallback<?> a(final int i) {
        return new InitializationCallback() { // from class: io.fabric.sdk.android.Fabric.2
            final CountDownLatch b;

            {
                this.b = new CountDownLatch(i);
            }

            @Override // io.fabric.sdk.android.InitializationCallback
            public void a(Object obj) {
                this.b.countDown();
                if (this.b.getCount() == 0) {
                    Fabric.this.i.set(true);
                    Fabric.this.e.a((InitializationCallback) Fabric.this);
                }
            }

            @Override // io.fabric.sdk.android.InitializationCallback
            public void a(Exception exc) {
                Fabric.this.e.a(exc);
            }
        };
    }

    public ExecutorService b() {
        return this.c;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static Map<Class<? extends Kit>, Kit> b(Collection<? extends Kit> collection) {
        HashMap hashMap = new HashMap(collection.size());
        a(hashMap, collection);
        return hashMap;
    }

    Future<Map<String, KitInfo>> a(Context context) {
        return b().submit(new FabricKitsFinder(context.getPackageCodePath()));
    }
}