package com.android.org.conscrypt.metrics;

/* JADX INFO: loaded from: classes.dex */
public class ReflexiveStatsEvent {
    private static final Class<?> c_statsEvent;
    private static final OptionalMethod newBuilder;
    private Object statsEvent;

    public static final class Builder {
        private static final OptionalMethod build;
        private static final Class<?> c_statsEvent_Builder;
        private static final OptionalMethod setAtomId;
        private static final OptionalMethod usePooledBuffer;
        private static final OptionalMethod writeBoolean;
        private static final OptionalMethod writeInt;
        private Object builder;

        static {
            Class<?> clsInitStatsEventBuilderClass = initStatsEventBuilderClass();
            c_statsEvent_Builder = clsInitStatsEventBuilderClass;
            Class cls = Integer.TYPE;
            setAtomId = new OptionalMethod(clsInitStatsEventBuilderClass, "setAtomId", cls);
            writeBoolean = new OptionalMethod(clsInitStatsEventBuilderClass, "writeBoolean", Boolean.TYPE);
            writeInt = new OptionalMethod(clsInitStatsEventBuilderClass, "writeInt", cls);
            build = new OptionalMethod(clsInitStatsEventBuilderClass, "build", new Class[0]);
            usePooledBuffer = new OptionalMethod(clsInitStatsEventBuilderClass, "usePooledBuffer", new Class[0]);
        }

        private static Class<?> initStatsEventBuilderClass() {
            try {
                return Class.forName("android.util.StatsEvent$Builder");
            } catch (ClassNotFoundException unused) {
                return null;
            }
        }

        public ReflexiveStatsEvent build() {
            return new ReflexiveStatsEvent(build.invoke(this.builder, new Object[0]));
        }

        public Builder setAtomId(int i3) {
            setAtomId.invoke(this.builder, Integer.valueOf(i3));
            return this;
        }

        public void usePooledBuffer() {
            usePooledBuffer.invoke(this.builder, new Object[0]);
        }

        public Builder writeBoolean(boolean z2) {
            writeBoolean.invoke(this.builder, Boolean.valueOf(z2));
            return this;
        }

        public Builder writeInt(int i3) {
            writeInt.invoke(this.builder, Integer.valueOf(i3));
            return this;
        }

        private Builder() {
            this.builder = ReflexiveStatsEvent.newBuilder.invoke(null, new Object[0]);
        }
    }

    static {
        Class<?> clsInitStatsEventClass = initStatsEventClass();
        c_statsEvent = clsInitStatsEventClass;
        newBuilder = new OptionalMethod(clsInitStatsEventClass, "newBuilder", new Class[0]);
    }

    public static ReflexiveStatsEvent buildEvent(int i3, boolean z2, int i4, int i5, int i6) {
        Builder builderNewBuilder = newBuilder();
        builderNewBuilder.setAtomId(i3);
        builderNewBuilder.writeBoolean(z2);
        builderNewBuilder.writeInt(i4);
        builderNewBuilder.writeInt(i5);
        builderNewBuilder.writeInt(i6);
        builderNewBuilder.usePooledBuffer();
        return builderNewBuilder.build();
    }

    private static Class<?> initStatsEventClass() {
        try {
            return Class.forName("android.util.StatsEvent");
        } catch (ClassNotFoundException unused) {
            return null;
        }
    }

    public static Builder newBuilder() {
        return new Builder();
    }

    public Object getStatsEvent() {
        return this.statsEvent;
    }

    private ReflexiveStatsEvent(Object obj) {
        this.statsEvent = obj;
    }
}