package c.e.d;

import android.content.Context;
import android.content.res.AssetManager;
import android.content.res.Resources;
import android.graphics.Typeface;
import android.graphics.fonts.FontVariationAxis;
import android.net.Uri;
import android.os.CancellationSignal;
import android.os.ParcelFileDescriptor;
import android.util.Log;
import c.e.f.l;
import java.io.IOException;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.ByteBuffer;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

/* JADX INFO: loaded from: classes.dex */
public class e extends d {

    /* JADX INFO: renamed from: g, reason: collision with root package name */
    public final Class<?> f5199g;

    /* JADX INFO: renamed from: h, reason: collision with root package name */
    public final Constructor<?> f5200h;

    /* JADX INFO: renamed from: i, reason: collision with root package name */
    public final Method f5201i;

    /* JADX INFO: renamed from: j, reason: collision with root package name */
    public final Method f5202j;
    public final Method k;
    public final Method l;
    public final Method m;

    public e() throws NoSuchMethodException {
        Method methodO;
        Method method;
        Constructor<?> constructor;
        Method methodM;
        Method methodN;
        Method method2;
        Class<?> cls = null;
        try {
            Class<?> cls2 = Class.forName("android.graphics.FontFamily");
            constructor = cls2.getConstructor(new Class[0]);
            methodM = m(cls2);
            methodN = n(cls2);
            method2 = cls2.getMethod("freeze", new Class[0]);
            method = cls2.getMethod("abortCreation", new Class[0]);
            methodO = o(cls2);
            cls = cls2;
        } catch (ClassNotFoundException | NoSuchMethodException e2) {
            StringBuilder sbC = a.b.c.a.a.C("Unable to collect necessary methods for class ");
            sbC.append(e2.getClass().getName());
            Log.e("TypefaceCompatApi26Impl", sbC.toString(), e2);
            methodO = null;
            method = null;
            constructor = null;
            methodM = null;
            methodN = null;
            method2 = null;
        }
        this.f5199g = cls;
        this.f5200h = constructor;
        this.f5201i = methodM;
        this.f5202j = methodN;
        this.k = method2;
        this.l = method;
        this.m = methodO;
    }

    private Object l() {
        try {
            return this.f5200h.newInstance(new Object[0]);
        } catch (IllegalAccessException | InstantiationException | InvocationTargetException unused) {
            return null;
        }
    }

    @Override // c.e.d.d, c.e.d.i
    public Typeface a(Context context, c.e.c.b.b bVar, Resources resources, int i2) {
        if (!k()) {
            return super.a(context, bVar, resources, i2);
        }
        Object objL = l();
        if (objL == null) {
            return null;
        }
        for (c.e.c.b.c cVar : bVar.f5167a) {
            if (!h(context, objL, cVar.f5168a, cVar.f5172e, cVar.f5169b, cVar.f5170c ? 1 : 0, FontVariationAxis.fromFontVariationSettings(cVar.f5171d))) {
                g(objL);
                return null;
            }
        }
        if (j(objL)) {
            return i(objL);
        }
        return null;
    }

    @Override // c.e.d.i
    public Typeface b(Context context, CancellationSignal cancellationSignal, l[] lVarArr, int i2) {
        Typeface typefaceI;
        boolean zBooleanValue;
        if (lVarArr.length < 1) {
            return null;
        }
        if (!k()) {
            l lVar = (l) i.d(lVarArr, i2, new h(this));
            try {
                ParcelFileDescriptor parcelFileDescriptorOpenFileDescriptor = context.getContentResolver().openFileDescriptor(lVar.f5234a, "r", cancellationSignal);
                if (parcelFileDescriptorOpenFileDescriptor == null) {
                    if (parcelFileDescriptorOpenFileDescriptor != null) {
                        parcelFileDescriptorOpenFileDescriptor.close();
                    }
                    return null;
                }
                try {
                    Typeface typefaceBuild = new Typeface.Builder(parcelFileDescriptorOpenFileDescriptor.getFileDescriptor()).setWeight(lVar.f5236c).setItalic(lVar.f5237d).build();
                    parcelFileDescriptorOpenFileDescriptor.close();
                    return typefaceBuild;
                } finally {
                }
            } catch (IOException unused) {
                return null;
            }
        }
        HashMap map = new HashMap();
        for (l lVar2 : lVarArr) {
            if (lVar2.f5238e == 0) {
                Uri uri = lVar2.f5234a;
                if (!map.containsKey(uri)) {
                    map.put(uri, c.e.b.a.q(context, cancellationSignal, uri));
                }
            }
        }
        Map mapUnmodifiableMap = Collections.unmodifiableMap(map);
        Object objL = l();
        if (objL == null) {
            return null;
        }
        int length = lVarArr.length;
        int i3 = 0;
        boolean z = false;
        while (i3 < length) {
            l lVar3 = lVarArr[i3];
            ByteBuffer byteBuffer = (ByteBuffer) mapUnmodifiableMap.get(lVar3.f5234a);
            if (byteBuffer != null) {
                try {
                    zBooleanValue = ((Boolean) this.f5202j.invoke(objL, byteBuffer, Integer.valueOf(lVar3.f5235b), null, Integer.valueOf(lVar3.f5236c), Integer.valueOf(lVar3.f5237d ? 1 : 0))).booleanValue();
                } catch (IllegalAccessException | InvocationTargetException unused2) {
                    zBooleanValue = false;
                }
                if (!zBooleanValue) {
                    g(objL);
                    return null;
                }
                z = true;
            }
            i3++;
            z = z;
        }
        if (!z) {
            g(objL);
            return null;
        }
        if (j(objL) && (typefaceI = i(objL)) != null) {
            return Typeface.create(typefaceI, i2);
        }
        return null;
    }

    @Override // c.e.d.i
    public Typeface c(Context context, Resources resources, int i2, String str, int i3) {
        if (!k()) {
            return super.c(context, resources, i2, str, i3);
        }
        Object objL = l();
        if (objL == null) {
            return null;
        }
        if (!h(context, objL, str, 0, -1, -1, null)) {
            g(objL);
            return null;
        }
        if (j(objL)) {
            return i(objL);
        }
        return null;
    }

    public final void g(Object obj) {
        try {
            this.l.invoke(obj, new Object[0]);
        } catch (IllegalAccessException | InvocationTargetException unused) {
        }
    }

    public final boolean h(Context context, Object obj, String str, int i2, int i3, int i4, FontVariationAxis[] fontVariationAxisArr) {
        try {
            return ((Boolean) this.f5201i.invoke(obj, context.getAssets(), str, 0, Boolean.FALSE, Integer.valueOf(i2), Integer.valueOf(i3), Integer.valueOf(i4), fontVariationAxisArr)).booleanValue();
        } catch (IllegalAccessException | InvocationTargetException unused) {
            return false;
        }
    }

    public Typeface i(Object obj) {
        try {
            Object objNewInstance = Array.newInstance(this.f5199g, 1);
            Array.set(objNewInstance, 0, obj);
            return (Typeface) this.m.invoke(null, objNewInstance, -1, -1);
        } catch (IllegalAccessException | InvocationTargetException unused) {
            return null;
        }
    }

    public final boolean j(Object obj) {
        try {
            return ((Boolean) this.k.invoke(obj, new Object[0])).booleanValue();
        } catch (IllegalAccessException | InvocationTargetException unused) {
            return false;
        }
    }

    public final boolean k() {
        if (this.f5201i == null) {
            Log.w("TypefaceCompatApi26Impl", "Unable to collect necessary private methods. Fallback to legacy implementation.");
        }
        return this.f5201i != null;
    }

    public Method m(Class<?> cls) {
        Class<?> cls2 = Integer.TYPE;
        return cls.getMethod("addFontFromAssetManager", AssetManager.class, String.class, cls2, Boolean.TYPE, cls2, cls2, cls2, FontVariationAxis[].class);
    }

    public Method n(Class<?> cls) {
        Class<?> cls2 = Integer.TYPE;
        return cls.getMethod("addFontFromBuffer", ByteBuffer.class, cls2, FontVariationAxis[].class, cls2, cls2);
    }

    public Method o(Class<?> cls) throws NoSuchMethodException {
        Class cls2 = Integer.TYPE;
        Method declaredMethod = Typeface.class.getDeclaredMethod("createFromFamiliesWithDefault", Array.newInstance(cls, 1).getClass(), cls2, cls2);
        declaredMethod.setAccessible(true);
        return declaredMethod;
    }
}