Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/com/google/android/datatransport/runtime/AutoProtoEncoderDoNotUseEncoder.java

@@ -0,0 +1,120 @@
+package com.google.android.datatransport.runtime;
+
+import com.amazonaws.handlers.HandlerChainFactory$$ExternalSyntheticThrowCCEIfNotNull0;
+import com.google.android.datatransport.runtime.firebase.transport.ClientMetrics;
+import com.google.android.datatransport.runtime.firebase.transport.GlobalMetrics;
+import com.google.android.datatransport.runtime.firebase.transport.LogEventDropped;
+import com.google.android.datatransport.runtime.firebase.transport.LogSourceMetrics;
+import com.google.android.datatransport.runtime.firebase.transport.StorageMetrics;
+import com.google.android.datatransport.runtime.firebase.transport.TimeWindow;
+import com.google.firebase.encoders.FieldDescriptor;
+import com.google.firebase.encoders.ObjectEncoder;
+import com.google.firebase.encoders.ObjectEncoderContext;
+import com.google.firebase.encoders.config.Configurator;
+import com.google.firebase.encoders.config.EncoderConfig;
+import com.google.firebase.encoders.proto.AtProtobuf;
+
+/* loaded from: classes2.dex */
+public final class AutoProtoEncoderDoNotUseEncoder implements Configurator {
+    public static final Configurator CONFIG = new AutoProtoEncoderDoNotUseEncoder();
+
+    @Override // com.google.firebase.encoders.config.Configurator
+    public void configure(EncoderConfig encoderConfig) {
+        encoderConfig.registerEncoder(ProtoEncoderDoNotUse.class, ProtoEncoderDoNotUseEncoder.INSTANCE);
+        encoderConfig.registerEncoder(ClientMetrics.class, ClientMetricsEncoder.INSTANCE);
+        encoderConfig.registerEncoder(TimeWindow.class, TimeWindowEncoder.INSTANCE);
+        encoderConfig.registerEncoder(LogSourceMetrics.class, LogSourceMetricsEncoder.INSTANCE);
+        encoderConfig.registerEncoder(LogEventDropped.class, LogEventDroppedEncoder.INSTANCE);
+        encoderConfig.registerEncoder(GlobalMetrics.class, GlobalMetricsEncoder.INSTANCE);
+        encoderConfig.registerEncoder(StorageMetrics.class, StorageMetricsEncoder.INSTANCE);
+    }
+
+    public static final class ProtoEncoderDoNotUseEncoder implements ObjectEncoder {
+        public static final ProtoEncoderDoNotUseEncoder INSTANCE = new ProtoEncoderDoNotUseEncoder();
+        public static final FieldDescriptor CLIENTMETRICS_DESCRIPTOR = FieldDescriptor.of("clientMetrics");
+
+        @Override // com.google.firebase.encoders.ObjectEncoder
+        public /* bridge */ /* synthetic */ void encode(Object obj, Object obj2) {
+            HandlerChainFactory$$ExternalSyntheticThrowCCEIfNotNull0.m(obj);
+            encode((ProtoEncoderDoNotUse) null, (ObjectEncoderContext) obj2);
+        }
+
+        public void encode(ProtoEncoderDoNotUse protoEncoderDoNotUse, ObjectEncoderContext objectEncoderContext) {
+            throw null;
+        }
+    }
+
+    public static final class ClientMetricsEncoder implements ObjectEncoder {
+        public static final ClientMetricsEncoder INSTANCE = new ClientMetricsEncoder();
+        public static final FieldDescriptor WINDOW_DESCRIPTOR = FieldDescriptor.builder("window").withProperty(AtProtobuf.builder().tag(1).build()).build();
+        public static final FieldDescriptor LOGSOURCEMETRICS_DESCRIPTOR = FieldDescriptor.builder("logSourceMetrics").withProperty(AtProtobuf.builder().tag(2).build()).build();
+        public static final FieldDescriptor GLOBALMETRICS_DESCRIPTOR = FieldDescriptor.builder("globalMetrics").withProperty(AtProtobuf.builder().tag(3).build()).build();
+        public static final FieldDescriptor APPNAMESPACE_DESCRIPTOR = FieldDescriptor.builder("appNamespace").withProperty(AtProtobuf.builder().tag(4).build()).build();
+
+        @Override // com.google.firebase.encoders.ObjectEncoder
+        public void encode(ClientMetrics clientMetrics, ObjectEncoderContext objectEncoderContext) {
+            objectEncoderContext.add(WINDOW_DESCRIPTOR, clientMetrics.getWindowInternal());
+            objectEncoderContext.add(LOGSOURCEMETRICS_DESCRIPTOR, clientMetrics.getLogSourceMetricsList());
+            objectEncoderContext.add(GLOBALMETRICS_DESCRIPTOR, clientMetrics.getGlobalMetricsInternal());
+            objectEncoderContext.add(APPNAMESPACE_DESCRIPTOR, clientMetrics.getAppNamespace());
+        }
+    }
+
+    public static final class TimeWindowEncoder implements ObjectEncoder {
+        public static final TimeWindowEncoder INSTANCE = new TimeWindowEncoder();
+        public static final FieldDescriptor STARTMS_DESCRIPTOR = FieldDescriptor.builder("startMs").withProperty(AtProtobuf.builder().tag(1).build()).build();
+        public static final FieldDescriptor ENDMS_DESCRIPTOR = FieldDescriptor.builder("endMs").withProperty(AtProtobuf.builder().tag(2).build()).build();
+
+        @Override // com.google.firebase.encoders.ObjectEncoder
+        public void encode(TimeWindow timeWindow, ObjectEncoderContext objectEncoderContext) {
+            objectEncoderContext.add(STARTMS_DESCRIPTOR, timeWindow.getStartMs());
+            objectEncoderContext.add(ENDMS_DESCRIPTOR, timeWindow.getEndMs());
+        }
+    }
+
+    public static final class LogSourceMetricsEncoder implements ObjectEncoder {
+        public static final LogSourceMetricsEncoder INSTANCE = new LogSourceMetricsEncoder();
+        public static final FieldDescriptor LOGSOURCE_DESCRIPTOR = FieldDescriptor.builder("logSource").withProperty(AtProtobuf.builder().tag(1).build()).build();
+        public static final FieldDescriptor LOGEVENTDROPPED_DESCRIPTOR = FieldDescriptor.builder("logEventDropped").withProperty(AtProtobuf.builder().tag(2).build()).build();
+
+        @Override // com.google.firebase.encoders.ObjectEncoder
+        public void encode(LogSourceMetrics logSourceMetrics, ObjectEncoderContext objectEncoderContext) {
+            objectEncoderContext.add(LOGSOURCE_DESCRIPTOR, logSourceMetrics.getLogSource());
+            objectEncoderContext.add(LOGEVENTDROPPED_DESCRIPTOR, logSourceMetrics.getLogEventDroppedList());
+        }
+    }
+
+    public static final class LogEventDroppedEncoder implements ObjectEncoder {
+        public static final LogEventDroppedEncoder INSTANCE = new LogEventDroppedEncoder();
+        public static final FieldDescriptor EVENTSDROPPEDCOUNT_DESCRIPTOR = FieldDescriptor.builder("eventsDroppedCount").withProperty(AtProtobuf.builder().tag(1).build()).build();
+        public static final FieldDescriptor REASON_DESCRIPTOR = FieldDescriptor.builder("reason").withProperty(AtProtobuf.builder().tag(3).build()).build();
+
+        @Override // com.google.firebase.encoders.ObjectEncoder
+        public void encode(LogEventDropped logEventDropped, ObjectEncoderContext objectEncoderContext) {
+            objectEncoderContext.add(EVENTSDROPPEDCOUNT_DESCRIPTOR, logEventDropped.getEventsDroppedCount());
+            objectEncoderContext.add(REASON_DESCRIPTOR, logEventDropped.getReason());
+        }
+    }
+
+    public static final class GlobalMetricsEncoder implements ObjectEncoder {
+        public static final GlobalMetricsEncoder INSTANCE = new GlobalMetricsEncoder();
+        public static final FieldDescriptor STORAGEMETRICS_DESCRIPTOR = FieldDescriptor.builder("storageMetrics").withProperty(AtProtobuf.builder().tag(1).build()).build();
+
+        @Override // com.google.firebase.encoders.ObjectEncoder
+        public void encode(GlobalMetrics globalMetrics, ObjectEncoderContext objectEncoderContext) {
+            objectEncoderContext.add(STORAGEMETRICS_DESCRIPTOR, globalMetrics.getStorageMetricsInternal());
+        }
+    }
+
+    public static final class StorageMetricsEncoder implements ObjectEncoder {
+        public static final StorageMetricsEncoder INSTANCE = new StorageMetricsEncoder();
+        public static final FieldDescriptor CURRENTCACHESIZEBYTES_DESCRIPTOR = FieldDescriptor.builder("currentCacheSizeBytes").withProperty(AtProtobuf.builder().tag(1).build()).build();
+        public static final FieldDescriptor MAXCACHESIZEBYTES_DESCRIPTOR = FieldDescriptor.builder("maxCacheSizeBytes").withProperty(AtProtobuf.builder().tag(2).build()).build();
+
+        @Override // com.google.firebase.encoders.ObjectEncoder
+        public void encode(StorageMetrics storageMetrics, ObjectEncoderContext objectEncoderContext) {
+            objectEncoderContext.add(CURRENTCACHESIZEBYTES_DESCRIPTOR, storageMetrics.getCurrentCacheSizeBytes());
+            objectEncoderContext.add(MAXCACHESIZEBYTES_DESCRIPTOR, storageMetrics.getMaxCacheSizeBytes());
+        }
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/AutoValue_EventInternal.java

@@ -0,0 +1,166 @@
+package com.google.android.datatransport.runtime;
+
+import com.google.android.datatransport.runtime.EventInternal;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+public final class AutoValue_EventInternal extends EventInternal {
+    public final Map autoMetadata;
+    public final Integer code;
+    public final EncodedPayload encodedPayload;
+    public final long eventMillis;
+    public final String transportName;
+    public final long uptimeMillis;
+
+    @Override // com.google.android.datatransport.runtime.EventInternal
+    public Map getAutoMetadata() {
+        return this.autoMetadata;
+    }
+
+    @Override // com.google.android.datatransport.runtime.EventInternal
+    public Integer getCode() {
+        return this.code;
+    }
+
+    @Override // com.google.android.datatransport.runtime.EventInternal
+    public EncodedPayload getEncodedPayload() {
+        return this.encodedPayload;
+    }
+
+    @Override // com.google.android.datatransport.runtime.EventInternal
+    public long getEventMillis() {
+        return this.eventMillis;
+    }
+
+    @Override // com.google.android.datatransport.runtime.EventInternal
+    public String getTransportName() {
+        return this.transportName;
+    }
+
+    @Override // com.google.android.datatransport.runtime.EventInternal
+    public long getUptimeMillis() {
+        return this.uptimeMillis;
+    }
+
+    public AutoValue_EventInternal(String str, Integer num, EncodedPayload encodedPayload, long j, long j2, Map map) {
+        this.transportName = str;
+        this.code = num;
+        this.encodedPayload = encodedPayload;
+        this.eventMillis = j;
+        this.uptimeMillis = j2;
+        this.autoMetadata = map;
+    }
+
+    public String toString() {
+        return "EventInternal{transportName=" + this.transportName + ", code=" + this.code + ", encodedPayload=" + this.encodedPayload + ", eventMillis=" + this.eventMillis + ", uptimeMillis=" + this.uptimeMillis + ", autoMetadata=" + this.autoMetadata + "}";
+    }
+
+    public boolean equals(Object obj) {
+        Integer num;
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof EventInternal)) {
+            return false;
+        }
+        EventInternal eventInternal = (EventInternal) obj;
+        return this.transportName.equals(eventInternal.getTransportName()) && ((num = this.code) != null ? num.equals(eventInternal.getCode()) : eventInternal.getCode() == null) && this.encodedPayload.equals(eventInternal.getEncodedPayload()) && this.eventMillis == eventInternal.getEventMillis() && this.uptimeMillis == eventInternal.getUptimeMillis() && this.autoMetadata.equals(eventInternal.getAutoMetadata());
+    }
+
+    public int hashCode() {
+        int hashCode = (this.transportName.hashCode() ^ 1000003) * 1000003;
+        Integer num = this.code;
+        int hashCode2 = (((hashCode ^ (num == null ? 0 : num.hashCode())) * 1000003) ^ this.encodedPayload.hashCode()) * 1000003;
+        long j = this.eventMillis;
+        int i = (hashCode2 ^ ((int) (j ^ (j >>> 32)))) * 1000003;
+        long j2 = this.uptimeMillis;
+        return ((i ^ ((int) (j2 ^ (j2 >>> 32)))) * 1000003) ^ this.autoMetadata.hashCode();
+    }
+
+    public static final class Builder extends EventInternal.Builder {
+        public Map autoMetadata;
+        public Integer code;
+        public EncodedPayload encodedPayload;
+        public Long eventMillis;
+        public String transportName;
+        public Long uptimeMillis;
+
+        @Override // com.google.android.datatransport.runtime.EventInternal.Builder
+        public EventInternal.Builder setCode(Integer num) {
+            this.code = num;
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.EventInternal.Builder
+        public EventInternal.Builder setTransportName(String str) {
+            if (str == null) {
+                throw new NullPointerException("Null transportName");
+            }
+            this.transportName = str;
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.EventInternal.Builder
+        public EventInternal.Builder setEncodedPayload(EncodedPayload encodedPayload) {
+            if (encodedPayload == null) {
+                throw new NullPointerException("Null encodedPayload");
+            }
+            this.encodedPayload = encodedPayload;
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.EventInternal.Builder
+        public EventInternal.Builder setEventMillis(long j) {
+            this.eventMillis = Long.valueOf(j);
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.EventInternal.Builder
+        public EventInternal.Builder setUptimeMillis(long j) {
+            this.uptimeMillis = Long.valueOf(j);
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.EventInternal.Builder
+        public EventInternal.Builder setAutoMetadata(Map map) {
+            if (map == null) {
+                throw new NullPointerException("Null autoMetadata");
+            }
+            this.autoMetadata = map;
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.EventInternal.Builder
+        public Map getAutoMetadata() {
+            Map map = this.autoMetadata;
+            if (map != null) {
+                return map;
+            }
+            throw new IllegalStateException("Property \"autoMetadata\" has not been set");
+        }
+
+        @Override // com.google.android.datatransport.runtime.EventInternal.Builder
+        public EventInternal build() {
+            String str = "";
+            if (this.transportName == null) {
+                str = " transportName";
+            }
+            if (this.encodedPayload == null) {
+                str = str + " encodedPayload";
+            }
+            if (this.eventMillis == null) {
+                str = str + " eventMillis";
+            }
+            if (this.uptimeMillis == null) {
+                str = str + " uptimeMillis";
+            }
+            if (this.autoMetadata == null) {
+                str = str + " autoMetadata";
+            }
+            if (!str.isEmpty()) {
+                throw new IllegalStateException("Missing required properties:" + str);
+            }
+            return new AutoValue_EventInternal(this.transportName, this.code, this.encodedPayload, this.eventMillis.longValue(), this.uptimeMillis.longValue(), this.autoMetadata);
+        }
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/AutoValue_SendRequest.java

@@ -0,0 +1,144 @@
+package com.google.android.datatransport.runtime;
+
+import com.google.android.datatransport.Encoding;
+import com.google.android.datatransport.Event;
+import com.google.android.datatransport.Transformer;
+import com.google.android.datatransport.runtime.SendRequest;
+
+/* loaded from: classes2.dex */
+public final class AutoValue_SendRequest extends SendRequest {
+    public final Encoding encoding;
+    public final Event event;
+    public final Transformer transformer;
+    public final TransportContext transportContext;
+    public final String transportName;
+
+    @Override // com.google.android.datatransport.runtime.SendRequest
+    public Encoding getEncoding() {
+        return this.encoding;
+    }
+
+    @Override // com.google.android.datatransport.runtime.SendRequest
+    public Event getEvent() {
+        return this.event;
+    }
+
+    @Override // com.google.android.datatransport.runtime.SendRequest
+    public Transformer getTransformer() {
+        return this.transformer;
+    }
+
+    @Override // com.google.android.datatransport.runtime.SendRequest
+    public TransportContext getTransportContext() {
+        return this.transportContext;
+    }
+
+    @Override // com.google.android.datatransport.runtime.SendRequest
+    public String getTransportName() {
+        return this.transportName;
+    }
+
+    public AutoValue_SendRequest(TransportContext transportContext, String str, Event event, Transformer transformer, Encoding encoding) {
+        this.transportContext = transportContext;
+        this.transportName = str;
+        this.event = event;
+        this.transformer = transformer;
+        this.encoding = encoding;
+    }
+
+    public String toString() {
+        return "SendRequest{transportContext=" + this.transportContext + ", transportName=" + this.transportName + ", event=" + this.event + ", transformer=" + this.transformer + ", encoding=" + this.encoding + "}";
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof SendRequest)) {
+            return false;
+        }
+        SendRequest sendRequest = (SendRequest) obj;
+        return this.transportContext.equals(sendRequest.getTransportContext()) && this.transportName.equals(sendRequest.getTransportName()) && this.event.equals(sendRequest.getEvent()) && this.transformer.equals(sendRequest.getTransformer()) && this.encoding.equals(sendRequest.getEncoding());
+    }
+
+    public int hashCode() {
+        return ((((((((this.transportContext.hashCode() ^ 1000003) * 1000003) ^ this.transportName.hashCode()) * 1000003) ^ this.event.hashCode()) * 1000003) ^ this.transformer.hashCode()) * 1000003) ^ this.encoding.hashCode();
+    }
+
+    public static final class Builder extends SendRequest.Builder {
+        public Encoding encoding;
+        public Event event;
+        public Transformer transformer;
+        public TransportContext transportContext;
+        public String transportName;
+
+        @Override // com.google.android.datatransport.runtime.SendRequest.Builder
+        public SendRequest.Builder setTransportContext(TransportContext transportContext) {
+            if (transportContext == null) {
+                throw new NullPointerException("Null transportContext");
+            }
+            this.transportContext = transportContext;
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.SendRequest.Builder
+        public SendRequest.Builder setTransportName(String str) {
+            if (str == null) {
+                throw new NullPointerException("Null transportName");
+            }
+            this.transportName = str;
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.SendRequest.Builder
+        public SendRequest.Builder setEvent(Event event) {
+            if (event == null) {
+                throw new NullPointerException("Null event");
+            }
+            this.event = event;
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.SendRequest.Builder
+        public SendRequest.Builder setTransformer(Transformer transformer) {
+            if (transformer == null) {
+                throw new NullPointerException("Null transformer");
+            }
+            this.transformer = transformer;
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.SendRequest.Builder
+        public SendRequest.Builder setEncoding(Encoding encoding) {
+            if (encoding == null) {
+                throw new NullPointerException("Null encoding");
+            }
+            this.encoding = encoding;
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.SendRequest.Builder
+        public SendRequest build() {
+            String str = "";
+            if (this.transportContext == null) {
+                str = " transportContext";
+            }
+            if (this.transportName == null) {
+                str = str + " transportName";
+            }
+            if (this.event == null) {
+                str = str + " event";
+            }
+            if (this.transformer == null) {
+                str = str + " transformer";
+            }
+            if (this.encoding == null) {
+                str = str + " encoding";
+            }
+            if (!str.isEmpty()) {
+                throw new IllegalStateException("Missing required properties:" + str);
+            }
+            return new AutoValue_SendRequest(this.transportContext, this.transportName, this.event, this.transformer, this.encoding);
+        }
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/AutoValue_TransportContext.java

@@ -0,0 +1,98 @@
+package com.google.android.datatransport.runtime;
+
+import com.google.android.datatransport.Priority;
+import com.google.android.datatransport.runtime.TransportContext;
+import java.util.Arrays;
+
+/* loaded from: classes2.dex */
+public final class AutoValue_TransportContext extends TransportContext {
+    public final String backendName;
+    public final byte[] extras;
+    public final Priority priority;
+
+    @Override // com.google.android.datatransport.runtime.TransportContext
+    public String getBackendName() {
+        return this.backendName;
+    }
+
+    @Override // com.google.android.datatransport.runtime.TransportContext
+    public byte[] getExtras() {
+        return this.extras;
+    }
+
+    @Override // com.google.android.datatransport.runtime.TransportContext
+    public Priority getPriority() {
+        return this.priority;
+    }
+
+    public AutoValue_TransportContext(String str, byte[] bArr, Priority priority) {
+        this.backendName = str;
+        this.extras = bArr;
+        this.priority = priority;
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof TransportContext)) {
+            return false;
+        }
+        TransportContext transportContext = (TransportContext) obj;
+        if (this.backendName.equals(transportContext.getBackendName())) {
+            if (Arrays.equals(this.extras, transportContext instanceof AutoValue_TransportContext ? ((AutoValue_TransportContext) transportContext).extras : transportContext.getExtras()) && this.priority.equals(transportContext.getPriority())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        return ((((this.backendName.hashCode() ^ 1000003) * 1000003) ^ Arrays.hashCode(this.extras)) * 1000003) ^ this.priority.hashCode();
+    }
+
+    public static final class Builder extends TransportContext.Builder {
+        public String backendName;
+        public byte[] extras;
+        public Priority priority;
+
+        @Override // com.google.android.datatransport.runtime.TransportContext.Builder
+        public TransportContext.Builder setExtras(byte[] bArr) {
+            this.extras = bArr;
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.TransportContext.Builder
+        public TransportContext.Builder setBackendName(String str) {
+            if (str == null) {
+                throw new NullPointerException("Null backendName");
+            }
+            this.backendName = str;
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.TransportContext.Builder
+        public TransportContext.Builder setPriority(Priority priority) {
+            if (priority == null) {
+                throw new NullPointerException("Null priority");
+            }
+            this.priority = priority;
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.TransportContext.Builder
+        public TransportContext build() {
+            String str = "";
+            if (this.backendName == null) {
+                str = " backendName";
+            }
+            if (this.priority == null) {
+                str = str + " priority";
+            }
+            if (!str.isEmpty()) {
+                throw new IllegalStateException("Missing required properties:" + str);
+            }
+            return new AutoValue_TransportContext(this.backendName, this.extras, this.priority);
+        }
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/DaggerTransportRuntimeComponent.java

@@ -0,0 +1,107 @@
+package com.google.android.datatransport.runtime;
+
+import android.content.Context;
+import com.google.android.datatransport.runtime.TransportRuntimeComponent;
+import com.google.android.datatransport.runtime.backends.CreationContextFactory_Factory;
+import com.google.android.datatransport.runtime.backends.MetadataBackendRegistry_Factory;
+import com.google.android.datatransport.runtime.dagger.internal.DoubleCheck;
+import com.google.android.datatransport.runtime.dagger.internal.Factory;
+import com.google.android.datatransport.runtime.dagger.internal.InstanceFactory;
+import com.google.android.datatransport.runtime.dagger.internal.Preconditions;
+import com.google.android.datatransport.runtime.scheduling.DefaultScheduler_Factory;
+import com.google.android.datatransport.runtime.scheduling.SchedulingConfigModule_ConfigFactory;
+import com.google.android.datatransport.runtime.scheduling.SchedulingModule_WorkSchedulerFactory;
+import com.google.android.datatransport.runtime.scheduling.jobscheduling.Uploader_Factory;
+import com.google.android.datatransport.runtime.scheduling.jobscheduling.WorkInitializer_Factory;
+import com.google.android.datatransport.runtime.scheduling.persistence.EventStore;
+import com.google.android.datatransport.runtime.scheduling.persistence.EventStoreModule_DbNameFactory;
+import com.google.android.datatransport.runtime.scheduling.persistence.EventStoreModule_PackageNameFactory;
+import com.google.android.datatransport.runtime.scheduling.persistence.EventStoreModule_SchemaVersionFactory;
+import com.google.android.datatransport.runtime.scheduling.persistence.EventStoreModule_StoreConfigFactory;
+import com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore_Factory;
+import com.google.android.datatransport.runtime.scheduling.persistence.SchemaManager_Factory;
+import com.google.android.datatransport.runtime.time.TimeModule_EventClockFactory;
+import com.google.android.datatransport.runtime.time.TimeModule_UptimeClockFactory;
+import javax.inject.Provider;
+
+/* loaded from: classes2.dex */
+public final class DaggerTransportRuntimeComponent extends TransportRuntimeComponent {
+    public Provider configProvider;
+    public Provider creationContextFactoryProvider;
+    public Provider defaultSchedulerProvider;
+    public Provider executorProvider;
+    public Provider metadataBackendRegistryProvider;
+    public Provider packageNameProvider;
+    public Provider sQLiteEventStoreProvider;
+    public Provider schemaManagerProvider;
+    public Provider setApplicationContextProvider;
+    public Provider transportRuntimeProvider;
+    public Provider uploaderProvider;
+    public Provider workInitializerProvider;
+    public Provider workSchedulerProvider;
+
+    public DaggerTransportRuntimeComponent(Context context) {
+        initialize(context);
+    }
+
+    public static TransportRuntimeComponent.Builder builder() {
+        return new Builder();
+    }
+
+    public final void initialize(Context context) {
+        this.executorProvider = DoubleCheck.provider(ExecutionModule_ExecutorFactory.create());
+        Factory create = InstanceFactory.create(context);
+        this.setApplicationContextProvider = create;
+        CreationContextFactory_Factory create2 = CreationContextFactory_Factory.create(create, TimeModule_EventClockFactory.create(), TimeModule_UptimeClockFactory.create());
+        this.creationContextFactoryProvider = create2;
+        this.metadataBackendRegistryProvider = DoubleCheck.provider(MetadataBackendRegistry_Factory.create(this.setApplicationContextProvider, create2));
+        this.schemaManagerProvider = SchemaManager_Factory.create(this.setApplicationContextProvider, EventStoreModule_DbNameFactory.create(), EventStoreModule_SchemaVersionFactory.create());
+        this.packageNameProvider = DoubleCheck.provider(EventStoreModule_PackageNameFactory.create(this.setApplicationContextProvider));
+        this.sQLiteEventStoreProvider = DoubleCheck.provider(SQLiteEventStore_Factory.create(TimeModule_EventClockFactory.create(), TimeModule_UptimeClockFactory.create(), EventStoreModule_StoreConfigFactory.create(), this.schemaManagerProvider, this.packageNameProvider));
+        SchedulingConfigModule_ConfigFactory create3 = SchedulingConfigModule_ConfigFactory.create(TimeModule_EventClockFactory.create());
+        this.configProvider = create3;
+        SchedulingModule_WorkSchedulerFactory create4 = SchedulingModule_WorkSchedulerFactory.create(this.setApplicationContextProvider, this.sQLiteEventStoreProvider, create3, TimeModule_UptimeClockFactory.create());
+        this.workSchedulerProvider = create4;
+        Provider provider = this.executorProvider;
+        Provider provider2 = this.metadataBackendRegistryProvider;
+        Provider provider3 = this.sQLiteEventStoreProvider;
+        this.defaultSchedulerProvider = DefaultScheduler_Factory.create(provider, provider2, create4, provider3, provider3);
+        Provider provider4 = this.setApplicationContextProvider;
+        Provider provider5 = this.metadataBackendRegistryProvider;
+        Provider provider6 = this.sQLiteEventStoreProvider;
+        this.uploaderProvider = Uploader_Factory.create(provider4, provider5, provider6, this.workSchedulerProvider, this.executorProvider, provider6, TimeModule_EventClockFactory.create(), TimeModule_UptimeClockFactory.create(), this.sQLiteEventStoreProvider);
+        Provider provider7 = this.executorProvider;
+        Provider provider8 = this.sQLiteEventStoreProvider;
+        this.workInitializerProvider = WorkInitializer_Factory.create(provider7, provider8, this.workSchedulerProvider, provider8);
+        this.transportRuntimeProvider = DoubleCheck.provider(TransportRuntime_Factory.create(TimeModule_EventClockFactory.create(), TimeModule_UptimeClockFactory.create(), this.defaultSchedulerProvider, this.uploaderProvider, this.workInitializerProvider));
+    }
+
+    @Override // com.google.android.datatransport.runtime.TransportRuntimeComponent
+    public TransportRuntime getTransportRuntime() {
+        return (TransportRuntime) this.transportRuntimeProvider.get();
+    }
+
+    @Override // com.google.android.datatransport.runtime.TransportRuntimeComponent
+    public EventStore getEventStore() {
+        return (EventStore) this.sQLiteEventStoreProvider.get();
+    }
+
+    public static final class Builder implements TransportRuntimeComponent.Builder {
+        public Context setApplicationContext;
+
+        public Builder() {
+        }
+
+        @Override // com.google.android.datatransport.runtime.TransportRuntimeComponent.Builder
+        public Builder setApplicationContext(Context context) {
+            this.setApplicationContext = (Context) Preconditions.checkNotNull(context);
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.TransportRuntimeComponent.Builder
+        public TransportRuntimeComponent build() {
+            Preconditions.checkBuilderRequirement(this.setApplicationContext, Context.class);
+            return new DaggerTransportRuntimeComponent(this.setApplicationContext);
+        }
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/Destination.java

@@ -0,0 +1,8 @@
+package com.google.android.datatransport.runtime;
+
+/* loaded from: classes2.dex */
+public interface Destination {
+    byte[] getExtras();
+
+    String getName();
+}

decompiled/sources/com/google/android/datatransport/runtime/EncodedDestination.java

@@ -0,0 +1,8 @@
+package com.google.android.datatransport.runtime;
+
+import java.util.Set;
+
+/* loaded from: classes2.dex */
+public interface EncodedDestination extends Destination {
+    Set getSupportedEncodings();
+}

decompiled/sources/com/google/android/datatransport/runtime/EncodedPayload.java

@@ -0,0 +1,51 @@
+package com.google.android.datatransport.runtime;
+
+import com.google.android.datatransport.Encoding;
+import java.util.Arrays;
+
+/* loaded from: classes2.dex */
+public final class EncodedPayload {
+    public final byte[] bytes;
+    public final Encoding encoding;
+
+    public byte[] getBytes() {
+        return this.bytes;
+    }
+
+    public Encoding getEncoding() {
+        return this.encoding;
+    }
+
+    public EncodedPayload(Encoding encoding, byte[] bArr) {
+        if (encoding == null) {
+            throw new NullPointerException("encoding is null");
+        }
+        if (bArr == null) {
+            throw new NullPointerException("bytes is null");
+        }
+        this.encoding = encoding;
+        this.bytes = bArr;
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof EncodedPayload)) {
+            return false;
+        }
+        EncodedPayload encodedPayload = (EncodedPayload) obj;
+        if (this.encoding.equals(encodedPayload.encoding)) {
+            return Arrays.equals(this.bytes, encodedPayload.bytes);
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        return ((this.encoding.hashCode() ^ 1000003) * 1000003) ^ Arrays.hashCode(this.bytes);
+    }
+
+    public String toString() {
+        return "EncodedPayload{encoding=" + this.encoding + ", bytes=[...]}";
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/EventInternal.java

@@ -0,0 +1,87 @@
+package com.google.android.datatransport.runtime;
+
+import com.google.android.datatransport.runtime.AutoValue_EventInternal;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+public abstract class EventInternal {
+    public abstract Map getAutoMetadata();
+
+    public abstract Integer getCode();
+
+    public abstract EncodedPayload getEncodedPayload();
+
+    public abstract long getEventMillis();
+
+    public abstract String getTransportName();
+
+    public abstract long getUptimeMillis();
+
+    public final Map getMetadata() {
+        return Collections.unmodifiableMap(getAutoMetadata());
+    }
+
+    public final int getInteger(String str) {
+        String str2 = (String) getAutoMetadata().get(str);
+        if (str2 == null) {
+            return 0;
+        }
+        return Integer.valueOf(str2).intValue();
+    }
+
+    public final long getLong(String str) {
+        String str2 = (String) getAutoMetadata().get(str);
+        if (str2 == null) {
+            return 0L;
+        }
+        return Long.valueOf(str2).longValue();
+    }
+
+    public final String get(String str) {
+        String str2 = (String) getAutoMetadata().get(str);
+        return str2 == null ? "" : str2;
+    }
+
+    public Builder toBuilder() {
+        return new AutoValue_EventInternal.Builder().setTransportName(getTransportName()).setCode(getCode()).setEncodedPayload(getEncodedPayload()).setEventMillis(getEventMillis()).setUptimeMillis(getUptimeMillis()).setAutoMetadata(new HashMap(getAutoMetadata()));
+    }
+
+    public static Builder builder() {
+        return new AutoValue_EventInternal.Builder().setAutoMetadata(new HashMap());
+    }
+
+    public static abstract class Builder {
+        public abstract EventInternal build();
+
+        public abstract Map getAutoMetadata();
+
+        public abstract Builder setAutoMetadata(Map map);
+
+        public abstract Builder setCode(Integer num);
+
+        public abstract Builder setEncodedPayload(EncodedPayload encodedPayload);
+
+        public abstract Builder setEventMillis(long j);
+
+        public abstract Builder setTransportName(String str);
+
+        public abstract Builder setUptimeMillis(long j);
+
+        public final Builder addMetadata(String str, String str2) {
+            getAutoMetadata().put(str, str2);
+            return this;
+        }
+
+        public final Builder addMetadata(String str, long j) {
+            getAutoMetadata().put(str, String.valueOf(j));
+            return this;
+        }
+
+        public final Builder addMetadata(String str, int i) {
+            getAutoMetadata().put(str, String.valueOf(i));
+            return this;
+        }
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/ExecutionModule.java

@@ -0,0 +1,11 @@
+package com.google.android.datatransport.runtime;
+
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+
+/* loaded from: classes2.dex */
+public abstract class ExecutionModule {
+    public static Executor executor() {
+        return new SafeLoggingExecutor(Executors.newSingleThreadExecutor());
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/ExecutionModule_ExecutorFactory.java

@@ -0,0 +1,26 @@
+package com.google.android.datatransport.runtime;
+
+import com.google.android.datatransport.runtime.dagger.internal.Factory;
+import com.google.android.datatransport.runtime.dagger.internal.Preconditions;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes2.dex */
+public final class ExecutionModule_ExecutorFactory implements Factory {
+
+    public static final class InstanceHolder {
+        public static final ExecutionModule_ExecutorFactory INSTANCE = new ExecutionModule_ExecutorFactory();
+    }
+
+    @Override // javax.inject.Provider
+    public Executor get() {
+        return executor();
+    }
+
+    public static ExecutionModule_ExecutorFactory create() {
+        return InstanceHolder.INSTANCE;
+    }
+
+    public static Executor executor() {
+        return (Executor) Preconditions.checkNotNull(ExecutionModule.executor(), "Cannot return null from a non-@Nullable @Provides method");
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/ForcedSender.java

@@ -0,0 +1,16 @@
+package com.google.android.datatransport.runtime;
+
+import com.google.android.datatransport.Priority;
+import com.google.android.datatransport.Transport;
+import com.google.android.datatransport.runtime.logging.Logging;
+
+/* loaded from: classes2.dex */
+public abstract class ForcedSender {
+    public static void sendBlocking(Transport transport, Priority priority) {
+        if (transport instanceof TransportImpl) {
+            TransportRuntime.getInstance().getUploader().logAndUpdateState(((TransportImpl) transport).getTransportContext().withPriority(priority), 1);
+        } else {
+            Logging.w("ForcedSender", "Expected instance of `TransportImpl`, got `%s`.", transport);
+        }
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/ProtoEncoderDoNotUse.java

@@ -0,0 +1,12 @@
+package com.google.android.datatransport.runtime;
+
+import com.google.firebase.encoders.proto.ProtobufEncoder;
+
+/* loaded from: classes2.dex */
+public abstract class ProtoEncoderDoNotUse {
+    public static final ProtobufEncoder ENCODER = ProtobufEncoder.builder().configureWith(AutoProtoEncoderDoNotUseEncoder.CONFIG).build();
+
+    public static byte[] encode(Object obj) {
+        return ENCODER.encode(obj);
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/SafeLoggingExecutor.java

@@ -0,0 +1,35 @@
+package com.google.android.datatransport.runtime;
+
+import com.google.android.datatransport.runtime.logging.Logging;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes2.dex */
+public class SafeLoggingExecutor implements Executor {
+    public final Executor delegate;
+
+    public SafeLoggingExecutor(Executor executor) {
+        this.delegate = executor;
+    }
+
+    @Override // java.util.concurrent.Executor
+    public void execute(Runnable runnable) {
+        this.delegate.execute(new SafeLoggingRunnable(runnable));
+    }
+
+    public static class SafeLoggingRunnable implements Runnable {
+        public final Runnable delegate;
+
+        public SafeLoggingRunnable(Runnable runnable) {
+            this.delegate = runnable;
+        }
+
+        @Override // java.lang.Runnable
+        public void run() {
+            try {
+                this.delegate.run();
+            } catch (Exception e) {
+                Logging.e("Executor", "Background execution failure.", e);
+            }
+        }
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/SendRequest.java

@@ -0,0 +1,42 @@
+package com.google.android.datatransport.runtime;
+
+import com.google.android.datatransport.Encoding;
+import com.google.android.datatransport.Event;
+import com.google.android.datatransport.Transformer;
+import com.google.android.datatransport.runtime.AutoValue_SendRequest;
+
+/* loaded from: classes2.dex */
+public abstract class SendRequest {
+
+    public static abstract class Builder {
+        public abstract SendRequest build();
+
+        public abstract Builder setEncoding(Encoding encoding);
+
+        public abstract Builder setEvent(Event event);
+
+        public abstract Builder setTransformer(Transformer transformer);
+
+        public abstract Builder setTransportContext(TransportContext transportContext);
+
+        public abstract Builder setTransportName(String str);
+    }
+
+    public abstract Encoding getEncoding();
+
+    public abstract Event getEvent();
+
+    public abstract Transformer getTransformer();
+
+    public abstract TransportContext getTransportContext();
+
+    public abstract String getTransportName();
+
+    public byte[] getPayload() {
+        return (byte[]) getTransformer().apply(getEvent().getPayload());
+    }
+
+    public static Builder builder() {
+        return new AutoValue_SendRequest.Builder();
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/TransportContext.java

@@ -0,0 +1,45 @@
+package com.google.android.datatransport.runtime;
+
+import android.util.Base64;
+import com.google.android.datatransport.Priority;
+import com.google.android.datatransport.runtime.AutoValue_TransportContext;
+
+/* loaded from: classes2.dex */
+public abstract class TransportContext {
+
+    public static abstract class Builder {
+        public abstract TransportContext build();
+
+        public abstract Builder setBackendName(String str);
+
+        public abstract Builder setExtras(byte[] bArr);
+
+        public abstract Builder setPriority(Priority priority);
+    }
+
+    public abstract String getBackendName();
+
+    public abstract byte[] getExtras();
+
+    public abstract Priority getPriority();
+
+    public boolean shouldUploadClientHealthMetrics() {
+        return getExtras() != null;
+    }
+
+    public final String toString() {
+        Object[] objArr = new Object[3];
+        objArr[0] = getBackendName();
+        objArr[1] = getPriority();
+        objArr[2] = getExtras() == null ? "" : Base64.encodeToString(getExtras(), 2);
+        return String.format("TransportContext(%s, %s, %s)", objArr);
+    }
+
+    public static Builder builder() {
+        return new AutoValue_TransportContext.Builder().setPriority(Priority.DEFAULT);
+    }
+
+    public TransportContext withPriority(Priority priority) {
+        return builder().setBackendName(getBackendName()).setPriority(priority).setExtras(getExtras()).build();
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/TransportFactoryImpl.java

@@ -0,0 +1,28 @@
+package com.google.android.datatransport.runtime;
+
+import com.google.android.datatransport.Encoding;
+import com.google.android.datatransport.Transformer;
+import com.google.android.datatransport.Transport;
+import com.google.android.datatransport.TransportFactory;
+import java.util.Set;
+
+/* loaded from: classes2.dex */
+public final class TransportFactoryImpl implements TransportFactory {
+    public final Set supportedPayloadEncodings;
+    public final TransportContext transportContext;
+    public final TransportInternal transportInternal;
+
+    public TransportFactoryImpl(Set set, TransportContext transportContext, TransportInternal transportInternal) {
+        this.supportedPayloadEncodings = set;
+        this.transportContext = transportContext;
+        this.transportInternal = transportInternal;
+    }
+
+    @Override // com.google.android.datatransport.TransportFactory
+    public Transport getTransport(String str, Class cls, Encoding encoding, Transformer transformer) {
+        if (!this.supportedPayloadEncodings.contains(encoding)) {
+            throw new IllegalArgumentException(String.format("%s is not supported byt this factory. Supported encodings are: %s.", encoding, this.supportedPayloadEncodings));
+        }
+        return new TransportImpl(this.transportContext, str, encoding, transformer, this.transportInternal);
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/TransportImpl.java

@@ -0,0 +1,46 @@
+package com.google.android.datatransport.runtime;
+
+import com.google.android.datatransport.Encoding;
+import com.google.android.datatransport.Event;
+import com.google.android.datatransport.Transformer;
+import com.google.android.datatransport.Transport;
+import com.google.android.datatransport.TransportScheduleCallback;
+
+/* loaded from: classes2.dex */
+public final class TransportImpl implements Transport {
+    public final String name;
+    public final Encoding payloadEncoding;
+    public final Transformer transformer;
+    public final TransportContext transportContext;
+    public final TransportInternal transportInternal;
+
+    public static /* synthetic */ void lambda$send$0(Exception exc) {
+    }
+
+    public TransportContext getTransportContext() {
+        return this.transportContext;
+    }
+
+    public TransportImpl(TransportContext transportContext, String str, Encoding encoding, Transformer transformer, TransportInternal transportInternal) {
+        this.transportContext = transportContext;
+        this.name = str;
+        this.payloadEncoding = encoding;
+        this.transformer = transformer;
+        this.transportInternal = transportInternal;
+    }
+
+    @Override // com.google.android.datatransport.Transport
+    public void send(Event event) {
+        schedule(event, new TransportScheduleCallback() { // from class: com.google.android.datatransport.runtime.TransportImpl$$ExternalSyntheticLambda0
+            @Override // com.google.android.datatransport.TransportScheduleCallback
+            public final void onSchedule(Exception exc) {
+                TransportImpl.lambda$send$0(exc);
+            }
+        });
+    }
+
+    @Override // com.google.android.datatransport.Transport
+    public void schedule(Event event, TransportScheduleCallback transportScheduleCallback) {
+        this.transportInternal.send(SendRequest.builder().setTransportContext(this.transportContext).setEvent(event).setTransportName(this.name).setTransformer(this.transformer).setEncoding(this.payloadEncoding).build(), transportScheduleCallback);
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/TransportInternal.java

@@ -0,0 +1,8 @@
+package com.google.android.datatransport.runtime;
+
+import com.google.android.datatransport.TransportScheduleCallback;
+
+/* loaded from: classes2.dex */
+public interface TransportInternal {
+    void send(SendRequest sendRequest, TransportScheduleCallback transportScheduleCallback);
+}

decompiled/sources/com/google/android/datatransport/runtime/TransportRuntime.java

@@ -0,0 +1,74 @@
+package com.google.android.datatransport.runtime;
+
+import android.content.Context;
+import com.google.android.datatransport.Encoding;
+import com.google.android.datatransport.TransportFactory;
+import com.google.android.datatransport.TransportScheduleCallback;
+import com.google.android.datatransport.runtime.scheduling.Scheduler;
+import com.google.android.datatransport.runtime.scheduling.jobscheduling.Uploader;
+import com.google.android.datatransport.runtime.scheduling.jobscheduling.WorkInitializer;
+import com.google.android.datatransport.runtime.time.Clock;
+import java.util.Collections;
+import java.util.Set;
+
+/* loaded from: classes2.dex */
+public class TransportRuntime implements TransportInternal {
+    public static volatile TransportRuntimeComponent instance;
+    public final Clock eventClock;
+    public final Scheduler scheduler;
+    public final Uploader uploader;
+    public final Clock uptimeClock;
+
+    public Uploader getUploader() {
+        return this.uploader;
+    }
+
+    public TransportRuntime(Clock clock, Clock clock2, Scheduler scheduler, Uploader uploader, WorkInitializer workInitializer) {
+        this.eventClock = clock;
+        this.uptimeClock = clock2;
+        this.scheduler = scheduler;
+        this.uploader = uploader;
+        workInitializer.ensureContextsScheduled();
+    }
+
+    public static void initialize(Context context) {
+        if (instance == null) {
+            synchronized (TransportRuntime.class) {
+                try {
+                    if (instance == null) {
+                        instance = DaggerTransportRuntimeComponent.builder().setApplicationContext(context).build();
+                    }
+                } finally {
+                }
+            }
+        }
+    }
+
+    public static TransportRuntime getInstance() {
+        TransportRuntimeComponent transportRuntimeComponent = instance;
+        if (transportRuntimeComponent == null) {
+            throw new IllegalStateException("Not initialized!");
+        }
+        return transportRuntimeComponent.getTransportRuntime();
+    }
+
+    public TransportFactory newFactory(Destination destination) {
+        return new TransportFactoryImpl(getSupportedEncodings(destination), TransportContext.builder().setBackendName(destination.getName()).setExtras(destination.getExtras()).build(), this);
+    }
+
+    public static Set getSupportedEncodings(Destination destination) {
+        if (destination instanceof EncodedDestination) {
+            return Collections.unmodifiableSet(((EncodedDestination) destination).getSupportedEncodings());
+        }
+        return Collections.singleton(Encoding.of("proto"));
+    }
+
+    @Override // com.google.android.datatransport.runtime.TransportInternal
+    public void send(SendRequest sendRequest, TransportScheduleCallback transportScheduleCallback) {
+        this.scheduler.schedule(sendRequest.getTransportContext().withPriority(sendRequest.getEvent().getPriority()), convert(sendRequest), transportScheduleCallback);
+    }
+
+    public final EventInternal convert(SendRequest sendRequest) {
+        return EventInternal.builder().setEventMillis(this.eventClock.getTime()).setUptimeMillis(this.uptimeClock.getTime()).setTransportName(sendRequest.getTransportName()).setEncodedPayload(new EncodedPayload(sendRequest.getEncoding(), sendRequest.getPayload())).setCode(sendRequest.getEvent().getCode()).build();
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/TransportRuntimeComponent.java

@@ -0,0 +1,24 @@
+package com.google.android.datatransport.runtime;
+
+import android.content.Context;
+import com.google.android.datatransport.runtime.scheduling.persistence.EventStore;
+import java.io.Closeable;
+
+/* loaded from: classes2.dex */
+public abstract class TransportRuntimeComponent implements Closeable {
+
+    public interface Builder {
+        TransportRuntimeComponent build();
+
+        Builder setApplicationContext(Context context);
+    }
+
+    public abstract EventStore getEventStore();
+
+    public abstract TransportRuntime getTransportRuntime();
+
+    @Override // java.io.Closeable, java.lang.AutoCloseable
+    public void close() {
+        getEventStore().close();
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/TransportRuntime_Factory.java

@@ -0,0 +1,38 @@
+package com.google.android.datatransport.runtime;
+
+import com.google.android.datatransport.runtime.dagger.internal.Factory;
+import com.google.android.datatransport.runtime.scheduling.Scheduler;
+import com.google.android.datatransport.runtime.scheduling.jobscheduling.Uploader;
+import com.google.android.datatransport.runtime.scheduling.jobscheduling.WorkInitializer;
+import com.google.android.datatransport.runtime.time.Clock;
+import javax.inject.Provider;
+
+/* loaded from: classes2.dex */
+public final class TransportRuntime_Factory implements Factory {
+    public final Provider eventClockProvider;
+    public final Provider initializerProvider;
+    public final Provider schedulerProvider;
+    public final Provider uploaderProvider;
+    public final Provider uptimeClockProvider;
+
+    public TransportRuntime_Factory(Provider provider, Provider provider2, Provider provider3, Provider provider4, Provider provider5) {
+        this.eventClockProvider = provider;
+        this.uptimeClockProvider = provider2;
+        this.schedulerProvider = provider3;
+        this.uploaderProvider = provider4;
+        this.initializerProvider = provider5;
+    }
+
+    @Override // javax.inject.Provider
+    public TransportRuntime get() {
+        return newInstance((Clock) this.eventClockProvider.get(), (Clock) this.uptimeClockProvider.get(), (Scheduler) this.schedulerProvider.get(), (Uploader) this.uploaderProvider.get(), (WorkInitializer) this.initializerProvider.get());
+    }
+
+    public static TransportRuntime_Factory create(Provider provider, Provider provider2, Provider provider3, Provider provider4, Provider provider5) {
+        return new TransportRuntime_Factory(provider, provider2, provider3, provider4, provider5);
+    }
+
+    public static TransportRuntime newInstance(Clock clock, Clock clock2, Scheduler scheduler, Uploader uploader, WorkInitializer workInitializer) {
+        return new TransportRuntime(clock, clock2, scheduler, uploader, workInitializer);
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/backends/AutoValue_BackendRequest.java

@@ -0,0 +1,81 @@
+package com.google.android.datatransport.runtime.backends;
+
+import com.google.android.datatransport.runtime.backends.BackendRequest;
+import java.util.Arrays;
+
+/* loaded from: classes2.dex */
+public final class AutoValue_BackendRequest extends BackendRequest {
+    public final Iterable events;
+    public final byte[] extras;
+
+    @Override // com.google.android.datatransport.runtime.backends.BackendRequest
+    public Iterable getEvents() {
+        return this.events;
+    }
+
+    @Override // com.google.android.datatransport.runtime.backends.BackendRequest
+    public byte[] getExtras() {
+        return this.extras;
+    }
+
+    public AutoValue_BackendRequest(Iterable iterable, byte[] bArr) {
+        this.events = iterable;
+        this.extras = bArr;
+    }
+
+    public String toString() {
+        return "BackendRequest{events=" + this.events + ", extras=" + Arrays.toString(this.extras) + "}";
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof BackendRequest)) {
+            return false;
+        }
+        BackendRequest backendRequest = (BackendRequest) obj;
+        if (this.events.equals(backendRequest.getEvents())) {
+            if (Arrays.equals(this.extras, backendRequest instanceof AutoValue_BackendRequest ? ((AutoValue_BackendRequest) backendRequest).extras : backendRequest.getExtras())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        return ((this.events.hashCode() ^ 1000003) * 1000003) ^ Arrays.hashCode(this.extras);
+    }
+
+    public static final class Builder extends BackendRequest.Builder {
+        public Iterable events;
+        public byte[] extras;
+
+        @Override // com.google.android.datatransport.runtime.backends.BackendRequest.Builder
+        public BackendRequest.Builder setExtras(byte[] bArr) {
+            this.extras = bArr;
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.backends.BackendRequest.Builder
+        public BackendRequest.Builder setEvents(Iterable iterable) {
+            if (iterable == null) {
+                throw new NullPointerException("Null events");
+            }
+            this.events = iterable;
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.backends.BackendRequest.Builder
+        public BackendRequest build() {
+            String str = "";
+            if (this.events == null) {
+                str = " events";
+            }
+            if (!str.isEmpty()) {
+                throw new IllegalStateException("Missing required properties:" + str);
+            }
+            return new AutoValue_BackendRequest(this.events, this.extras);
+        }
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/backends/AutoValue_BackendResponse.java

@@ -0,0 +1,48 @@
+package com.google.android.datatransport.runtime.backends;
+
+import com.google.android.datatransport.runtime.backends.BackendResponse;
+
+/* loaded from: classes2.dex */
+public final class AutoValue_BackendResponse extends BackendResponse {
+    public final long nextRequestWaitMillis;
+    public final BackendResponse.Status status;
+
+    @Override // com.google.android.datatransport.runtime.backends.BackendResponse
+    public long getNextRequestWaitMillis() {
+        return this.nextRequestWaitMillis;
+    }
+
+    @Override // com.google.android.datatransport.runtime.backends.BackendResponse
+    public BackendResponse.Status getStatus() {
+        return this.status;
+    }
+
+    public AutoValue_BackendResponse(BackendResponse.Status status, long j) {
+        if (status == null) {
+            throw new NullPointerException("Null status");
+        }
+        this.status = status;
+        this.nextRequestWaitMillis = j;
+    }
+
+    public String toString() {
+        return "BackendResponse{status=" + this.status + ", nextRequestWaitMillis=" + this.nextRequestWaitMillis + "}";
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof BackendResponse)) {
+            return false;
+        }
+        BackendResponse backendResponse = (BackendResponse) obj;
+        return this.status.equals(backendResponse.getStatus()) && this.nextRequestWaitMillis == backendResponse.getNextRequestWaitMillis();
+    }
+
+    public int hashCode() {
+        int hashCode = (this.status.hashCode() ^ 1000003) * 1000003;
+        long j = this.nextRequestWaitMillis;
+        return hashCode ^ ((int) (j ^ (j >>> 32)));
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/backends/AutoValue_CreationContext.java

@@ -0,0 +1,70 @@
+package com.google.android.datatransport.runtime.backends;
+
+import android.content.Context;
+import com.google.android.datatransport.runtime.time.Clock;
+
+/* loaded from: classes2.dex */
+public final class AutoValue_CreationContext extends CreationContext {
+    public final Context applicationContext;
+    public final String backendName;
+    public final Clock monotonicClock;
+    public final Clock wallClock;
+
+    @Override // com.google.android.datatransport.runtime.backends.CreationContext
+    public Context getApplicationContext() {
+        return this.applicationContext;
+    }
+
+    @Override // com.google.android.datatransport.runtime.backends.CreationContext
+    public String getBackendName() {
+        return this.backendName;
+    }
+
+    @Override // com.google.android.datatransport.runtime.backends.CreationContext
+    public Clock getMonotonicClock() {
+        return this.monotonicClock;
+    }
+
+    @Override // com.google.android.datatransport.runtime.backends.CreationContext
+    public Clock getWallClock() {
+        return this.wallClock;
+    }
+
+    public AutoValue_CreationContext(Context context, Clock clock, Clock clock2, String str) {
+        if (context == null) {
+            throw new NullPointerException("Null applicationContext");
+        }
+        this.applicationContext = context;
+        if (clock == null) {
+            throw new NullPointerException("Null wallClock");
+        }
+        this.wallClock = clock;
+        if (clock2 == null) {
+            throw new NullPointerException("Null monotonicClock");
+        }
+        this.monotonicClock = clock2;
+        if (str == null) {
+            throw new NullPointerException("Null backendName");
+        }
+        this.backendName = str;
+    }
+
+    public String toString() {
+        return "CreationContext{applicationContext=" + this.applicationContext + ", wallClock=" + this.wallClock + ", monotonicClock=" + this.monotonicClock + ", backendName=" + this.backendName + "}";
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof CreationContext)) {
+            return false;
+        }
+        CreationContext creationContext = (CreationContext) obj;
+        return this.applicationContext.equals(creationContext.getApplicationContext()) && this.wallClock.equals(creationContext.getWallClock()) && this.monotonicClock.equals(creationContext.getMonotonicClock()) && this.backendName.equals(creationContext.getBackendName());
+    }
+
+    public int hashCode() {
+        return ((((((this.applicationContext.hashCode() ^ 1000003) * 1000003) ^ this.wallClock.hashCode()) * 1000003) ^ this.monotonicClock.hashCode()) * 1000003) ^ this.backendName.hashCode();
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/backends/BackendFactory.java

@@ -0,0 +1,6 @@
+package com.google.android.datatransport.runtime.backends;
+
+/* loaded from: classes2.dex */
+public interface BackendFactory {
+    TransportBackend create(CreationContext creationContext);
+}

decompiled/sources/com/google/android/datatransport/runtime/backends/BackendRegistry.java

@@ -0,0 +1,6 @@
+package com.google.android.datatransport.runtime.backends;
+
+/* loaded from: classes2.dex */
+public interface BackendRegistry {
+    TransportBackend get(String str);
+}

decompiled/sources/com/google/android/datatransport/runtime/backends/BackendRequest.java

@@ -0,0 +1,23 @@
+package com.google.android.datatransport.runtime.backends;
+
+import com.google.android.datatransport.runtime.backends.AutoValue_BackendRequest;
+
+/* loaded from: classes2.dex */
+public abstract class BackendRequest {
+
+    public static abstract class Builder {
+        public abstract BackendRequest build();
+
+        public abstract Builder setEvents(Iterable iterable);
+
+        public abstract Builder setExtras(byte[] bArr);
+    }
+
+    public abstract Iterable getEvents();
+
+    public abstract byte[] getExtras();
+
+    public static Builder builder() {
+        return new AutoValue_BackendRequest.Builder();
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/backends/BackendResponse.java

@@ -0,0 +1,32 @@
+package com.google.android.datatransport.runtime.backends;
+
+/* loaded from: classes2.dex */
+public abstract class BackendResponse {
+
+    public enum Status {
+        OK,
+        TRANSIENT_ERROR,
+        FATAL_ERROR,
+        INVALID_PAYLOAD
+    }
+
+    public abstract long getNextRequestWaitMillis();
+
+    public abstract Status getStatus();
+
+    public static BackendResponse transientError() {
+        return new AutoValue_BackendResponse(Status.TRANSIENT_ERROR, -1L);
+    }
+
+    public static BackendResponse fatalError() {
+        return new AutoValue_BackendResponse(Status.FATAL_ERROR, -1L);
+    }
+
+    public static BackendResponse invalidPayload() {
+        return new AutoValue_BackendResponse(Status.INVALID_PAYLOAD, -1L);
+    }
+
+    public static BackendResponse ok(long j) {
+        return new AutoValue_BackendResponse(Status.OK, j);
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/backends/CreationContext.java

@@ -0,0 +1,19 @@
+package com.google.android.datatransport.runtime.backends;
+
+import android.content.Context;
+import com.google.android.datatransport.runtime.time.Clock;
+
+/* loaded from: classes2.dex */
+public abstract class CreationContext {
+    public abstract Context getApplicationContext();
+
+    public abstract String getBackendName();
+
+    public abstract Clock getMonotonicClock();
+
+    public abstract Clock getWallClock();
+
+    public static CreationContext create(Context context, Clock clock, Clock clock2, String str) {
+        return new AutoValue_CreationContext(context, clock, clock2, str);
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/backends/CreationContextFactory.java

@@ -0,0 +1,21 @@
+package com.google.android.datatransport.runtime.backends;
+
+import android.content.Context;
+import com.google.android.datatransport.runtime.time.Clock;
+
+/* loaded from: classes2.dex */
+public class CreationContextFactory {
+    public final Context applicationContext;
+    public final Clock monotonicClock;
+    public final Clock wallClock;
+
+    public CreationContextFactory(Context context, Clock clock, Clock clock2) {
+        this.applicationContext = context;
+        this.wallClock = clock;
+        this.monotonicClock = clock2;
+    }
+
+    public CreationContext create(String str) {
+        return CreationContext.create(this.applicationContext, this.wallClock, this.monotonicClock, str);
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/backends/CreationContextFactory_Factory.java

@@ -0,0 +1,32 @@
+package com.google.android.datatransport.runtime.backends;
+
+import android.content.Context;
+import com.google.android.datatransport.runtime.dagger.internal.Factory;
+import com.google.android.datatransport.runtime.time.Clock;
+import javax.inject.Provider;
+
+/* loaded from: classes2.dex */
+public final class CreationContextFactory_Factory implements Factory {
+    public final Provider applicationContextProvider;
+    public final Provider monotonicClockProvider;
+    public final Provider wallClockProvider;
+
+    public CreationContextFactory_Factory(Provider provider, Provider provider2, Provider provider3) {
+        this.applicationContextProvider = provider;
+        this.wallClockProvider = provider2;
+        this.monotonicClockProvider = provider3;
+    }
+
+    @Override // javax.inject.Provider
+    public CreationContextFactory get() {
+        return newInstance((Context) this.applicationContextProvider.get(), (Clock) this.wallClockProvider.get(), (Clock) this.monotonicClockProvider.get());
+    }
+
+    public static CreationContextFactory_Factory create(Provider provider, Provider provider2, Provider provider3) {
+        return new CreationContextFactory_Factory(provider, provider2, provider3);
+    }
+
+    public static CreationContextFactory newInstance(Context context, Clock clock, Clock clock2) {
+        return new CreationContextFactory(context, clock, clock2);
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/backends/MetadataBackendRegistry.java

@@ -0,0 +1,124 @@
+package com.google.android.datatransport.runtime.backends;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.content.pm.ServiceInfo;
+import android.os.Bundle;
+import android.util.Log;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+public class MetadataBackendRegistry implements BackendRegistry {
+    public final BackendFactoryProvider backendFactoryProvider;
+    public final Map backends;
+    public final CreationContextFactory creationContextFactory;
+
+    public MetadataBackendRegistry(Context context, CreationContextFactory creationContextFactory) {
+        this(new BackendFactoryProvider(context), creationContextFactory);
+    }
+
+    public MetadataBackendRegistry(BackendFactoryProvider backendFactoryProvider, CreationContextFactory creationContextFactory) {
+        this.backends = new HashMap();
+        this.backendFactoryProvider = backendFactoryProvider;
+        this.creationContextFactory = creationContextFactory;
+    }
+
+    @Override // com.google.android.datatransport.runtime.backends.BackendRegistry
+    public synchronized TransportBackend get(String str) {
+        if (this.backends.containsKey(str)) {
+            return (TransportBackend) this.backends.get(str);
+        }
+        BackendFactory backendFactory = this.backendFactoryProvider.get(str);
+        if (backendFactory == null) {
+            return null;
+        }
+        TransportBackend create = backendFactory.create(this.creationContextFactory.create(str));
+        this.backends.put(str, create);
+        return create;
+    }
+
+    public static class BackendFactoryProvider {
+        public final Context applicationContext;
+        public Map backendProviders = null;
+
+        public BackendFactoryProvider(Context context) {
+            this.applicationContext = context;
+        }
+
+        public BackendFactory get(String str) {
+            String str2 = (String) getBackendProviders().get(str);
+            if (str2 == null) {
+                return null;
+            }
+            try {
+                return (BackendFactory) Class.forName(str2).asSubclass(BackendFactory.class).getDeclaredConstructor(new Class[0]).newInstance(new Object[0]);
+            } catch (ClassNotFoundException e) {
+                Log.w("BackendRegistry", String.format("Class %s is not found.", str2), e);
+                return null;
+            } catch (IllegalAccessException e2) {
+                Log.w("BackendRegistry", String.format("Could not instantiate %s.", str2), e2);
+                return null;
+            } catch (InstantiationException e3) {
+                Log.w("BackendRegistry", String.format("Could not instantiate %s.", str2), e3);
+                return null;
+            } catch (NoSuchMethodException e4) {
+                Log.w("BackendRegistry", String.format("Could not instantiate %s", str2), e4);
+                return null;
+            } catch (InvocationTargetException e5) {
+                Log.w("BackendRegistry", String.format("Could not instantiate %s", str2), e5);
+                return null;
+            }
+        }
+
+        public final Map getBackendProviders() {
+            if (this.backendProviders == null) {
+                this.backendProviders = discover(this.applicationContext);
+            }
+            return this.backendProviders;
+        }
+
+        public final Map discover(Context context) {
+            Bundle metadata = getMetadata(context);
+            if (metadata == null) {
+                Log.w("BackendRegistry", "Could not retrieve metadata, returning empty list of transport backends.");
+                return Collections.emptyMap();
+            }
+            HashMap hashMap = new HashMap();
+            for (String str : metadata.keySet()) {
+                Object obj = metadata.get(str);
+                if ((obj instanceof String) && str.startsWith("backend:")) {
+                    for (String str2 : ((String) obj).split(",", -1)) {
+                        String trim = str2.trim();
+                        if (!trim.isEmpty()) {
+                            hashMap.put(trim, str.substring(8));
+                        }
+                    }
+                }
+            }
+            return hashMap;
+        }
+
+        public static Bundle getMetadata(Context context) {
+            try {
+                PackageManager packageManager = context.getPackageManager();
+                if (packageManager == null) {
+                    Log.w("BackendRegistry", "Context has no PackageManager.");
+                    return null;
+                }
+                ServiceInfo serviceInfo = packageManager.getServiceInfo(new ComponentName(context, (Class<?>) TransportBackendDiscovery.class), 128);
+                if (serviceInfo == null) {
+                    Log.w("BackendRegistry", "TransportBackendDiscovery has no service info.");
+                    return null;
+                }
+                return serviceInfo.metaData;
+            } catch (PackageManager.NameNotFoundException unused) {
+                Log.w("BackendRegistry", "Application info not found.");
+                return null;
+            }
+        }
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/backends/MetadataBackendRegistry_Factory.java

@@ -0,0 +1,29 @@
+package com.google.android.datatransport.runtime.backends;
+
+import android.content.Context;
+import com.google.android.datatransport.runtime.dagger.internal.Factory;
+import javax.inject.Provider;
+
+/* loaded from: classes2.dex */
+public final class MetadataBackendRegistry_Factory implements Factory {
+    public final Provider applicationContextProvider;
+    public final Provider creationContextFactoryProvider;
+
+    public MetadataBackendRegistry_Factory(Provider provider, Provider provider2) {
+        this.applicationContextProvider = provider;
+        this.creationContextFactoryProvider = provider2;
+    }
+
+    @Override // javax.inject.Provider
+    public MetadataBackendRegistry get() {
+        return newInstance((Context) this.applicationContextProvider.get(), this.creationContextFactoryProvider.get());
+    }
+
+    public static MetadataBackendRegistry_Factory create(Provider provider, Provider provider2) {
+        return new MetadataBackendRegistry_Factory(provider, provider2);
+    }
+
+    public static MetadataBackendRegistry newInstance(Context context, Object obj) {
+        return new MetadataBackendRegistry(context, (CreationContextFactory) obj);
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/backends/TransportBackend.java

@@ -0,0 +1,10 @@
+package com.google.android.datatransport.runtime.backends;
+
+import com.google.android.datatransport.runtime.EventInternal;
+
+/* loaded from: classes2.dex */
+public interface TransportBackend {
+    EventInternal decorate(EventInternal eventInternal);
+
+    BackendResponse send(BackendRequest backendRequest);
+}

decompiled/sources/com/google/android/datatransport/runtime/backends/TransportBackendDiscovery.java

@@ -0,0 +1,13 @@
+package com.google.android.datatransport.runtime.backends;
+
+import android.app.Service;
+import android.content.Intent;
+import android.os.IBinder;
+
+/* loaded from: classes2.dex */
+public class TransportBackendDiscovery extends Service {
+    @Override // android.app.Service
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/dagger/internal/DoubleCheck.java

@@ -0,0 +1,46 @@
+package com.google.android.datatransport.runtime.dagger.internal;
+
+import javax.inject.Provider;
+
+/* loaded from: classes2.dex */
+public final class DoubleCheck implements Provider {
+    public static final Object UNINITIALIZED = new Object();
+    public volatile Object instance = UNINITIALIZED;
+    public volatile Provider provider;
+
+    public DoubleCheck(Provider provider) {
+        this.provider = provider;
+    }
+
+    @Override // javax.inject.Provider
+    public Object get() {
+        Object obj = this.instance;
+        Object obj2 = UNINITIALIZED;
+        if (obj == obj2) {
+            synchronized (this) {
+                try {
+                    obj = this.instance;
+                    if (obj == obj2) {
+                        obj = this.provider.get();
+                        this.instance = reentrantCheck(this.instance, obj);
+                        this.provider = null;
+                    }
+                } finally {
+                }
+            }
+        }
+        return obj;
+    }
+
+    public static Object reentrantCheck(Object obj, Object obj2) {
+        if (obj == UNINITIALIZED || obj == obj2) {
+            return obj2;
+        }
+        throw new IllegalStateException("Scoped provider was invoked recursively returning different results: " + obj + " & " + obj2 + ". This is likely due to a circular dependency.");
+    }
+
+    public static Provider provider(Provider provider) {
+        Preconditions.checkNotNull(provider);
+        return provider instanceof DoubleCheck ? provider : new DoubleCheck(provider);
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/dagger/internal/Factory.java

@@ -0,0 +1,7 @@
+package com.google.android.datatransport.runtime.dagger.internal;
+
+import javax.inject.Provider;
+
+/* loaded from: classes2.dex */
+public interface Factory extends Provider {
+}

decompiled/sources/com/google/android/datatransport/runtime/dagger/internal/InstanceFactory.java

@@ -0,0 +1,20 @@
+package com.google.android.datatransport.runtime.dagger.internal;
+
+/* loaded from: classes2.dex */
+public final class InstanceFactory implements Factory {
+    public static final InstanceFactory NULL_INSTANCE_FACTORY = new InstanceFactory(null);
+    public final Object instance;
+
+    @Override // javax.inject.Provider
+    public Object get() {
+        return this.instance;
+    }
+
+    public static Factory create(Object obj) {
+        return new InstanceFactory(Preconditions.checkNotNull(obj, "instance cannot be null"));
+    }
+
+    public InstanceFactory(Object obj) {
+        this.instance = obj;
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/dagger/internal/Preconditions.java

@@ -0,0 +1,23 @@
+package com.google.android.datatransport.runtime.dagger.internal;
+
+/* loaded from: classes2.dex */
+public abstract class Preconditions {
+    public static Object checkNotNull(Object obj) {
+        obj.getClass();
+        return obj;
+    }
+
+    public static Object checkNotNull(Object obj, String str) {
+        if (obj != null) {
+            return obj;
+        }
+        throw new NullPointerException(str);
+    }
+
+    public static void checkBuilderRequirement(Object obj, Class cls) {
+        if (obj != null) {
+            return;
+        }
+        throw new IllegalStateException(cls.getCanonicalName() + " must be set");
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/firebase/transport/ClientMetrics.java

@@ -0,0 +1,77 @@
+package com.google.android.datatransport.runtime.firebase.transport;
+
+import com.google.android.datatransport.runtime.ProtoEncoderDoNotUse;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes2.dex */
+public final class ClientMetrics {
+    public static final ClientMetrics DEFAULT_INSTANCE = new Builder().build();
+    public final String app_namespace_;
+    public final GlobalMetrics global_metrics_;
+    public final List log_source_metrics_;
+    public final TimeWindow window_;
+
+    public String getAppNamespace() {
+        return this.app_namespace_;
+    }
+
+    public GlobalMetrics getGlobalMetricsInternal() {
+        return this.global_metrics_;
+    }
+
+    public List getLogSourceMetricsList() {
+        return this.log_source_metrics_;
+    }
+
+    public TimeWindow getWindowInternal() {
+        return this.window_;
+    }
+
+    public ClientMetrics(TimeWindow timeWindow, List list, GlobalMetrics globalMetrics, String str) {
+        this.window_ = timeWindow;
+        this.log_source_metrics_ = list;
+        this.global_metrics_ = globalMetrics;
+        this.app_namespace_ = str;
+    }
+
+    public byte[] toByteArray() {
+        return ProtoEncoderDoNotUse.encode(this);
+    }
+
+    public static Builder newBuilder() {
+        return new Builder();
+    }
+
+    public static final class Builder {
+        public TimeWindow window_ = null;
+        public List log_source_metrics_ = new ArrayList();
+        public GlobalMetrics global_metrics_ = null;
+        public String app_namespace_ = "";
+
+        public Builder setAppNamespace(String str) {
+            this.app_namespace_ = str;
+            return this;
+        }
+
+        public Builder setGlobalMetrics(GlobalMetrics globalMetrics) {
+            this.global_metrics_ = globalMetrics;
+            return this;
+        }
+
+        public Builder setWindow(TimeWindow timeWindow) {
+            this.window_ = timeWindow;
+            return this;
+        }
+
+        public ClientMetrics build() {
+            return new ClientMetrics(this.window_, Collections.unmodifiableList(this.log_source_metrics_), this.global_metrics_, this.app_namespace_);
+        }
+
+        public Builder addLogSourceMetrics(LogSourceMetrics logSourceMetrics) {
+            this.log_source_metrics_.add(logSourceMetrics);
+            return this;
+        }
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/firebase/transport/GlobalMetrics.java

@@ -0,0 +1,32 @@
+package com.google.android.datatransport.runtime.firebase.transport;
+
+/* loaded from: classes2.dex */
+public final class GlobalMetrics {
+    public static final GlobalMetrics DEFAULT_INSTANCE = new Builder().build();
+    public final StorageMetrics storage_metrics_;
+
+    public StorageMetrics getStorageMetricsInternal() {
+        return this.storage_metrics_;
+    }
+
+    public GlobalMetrics(StorageMetrics storageMetrics) {
+        this.storage_metrics_ = storageMetrics;
+    }
+
+    public static Builder newBuilder() {
+        return new Builder();
+    }
+
+    public static final class Builder {
+        public StorageMetrics storage_metrics_ = null;
+
+        public Builder setStorageMetrics(StorageMetrics storageMetrics) {
+            this.storage_metrics_ = storageMetrics;
+            return this;
+        }
+
+        public GlobalMetrics build() {
+            return new GlobalMetrics(this.storage_metrics_);
+        }
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/firebase/transport/LogEventDropped.java

@@ -0,0 +1,67 @@
+package com.google.android.datatransport.runtime.firebase.transport;
+
+import com.google.firebase.encoders.proto.ProtoEnum;
+
+/* loaded from: classes2.dex */
+public final class LogEventDropped {
+    public static final LogEventDropped DEFAULT_INSTANCE = new Builder().build();
+    public final long events_dropped_count_;
+    public final Reason reason_;
+
+    public long getEventsDroppedCount() {
+        return this.events_dropped_count_;
+    }
+
+    public Reason getReason() {
+        return this.reason_;
+    }
+
+    public LogEventDropped(long j, Reason reason) {
+        this.events_dropped_count_ = j;
+        this.reason_ = reason;
+    }
+
+    public static Builder newBuilder() {
+        return new Builder();
+    }
+
+    public static final class Builder {
+        public long events_dropped_count_ = 0;
+        public Reason reason_ = Reason.REASON_UNKNOWN;
+
+        public Builder setEventsDroppedCount(long j) {
+            this.events_dropped_count_ = j;
+            return this;
+        }
+
+        public Builder setReason(Reason reason) {
+            this.reason_ = reason;
+            return this;
+        }
+
+        public LogEventDropped build() {
+            return new LogEventDropped(this.events_dropped_count_, this.reason_);
+        }
+    }
+
+    public enum Reason implements ProtoEnum {
+        REASON_UNKNOWN(0),
+        MESSAGE_TOO_OLD(1),
+        CACHE_FULL(2),
+        PAYLOAD_TOO_BIG(3),
+        MAX_RETRIES_REACHED(4),
+        INVALID_PAYLOD(5),
+        SERVER_ERROR(6);
+
+        private final int number_;
+
+        @Override // com.google.firebase.encoders.proto.ProtoEnum
+        public int getNumber() {
+            return this.number_;
+        }
+
+        Reason(int i) {
+            this.number_ = i;
+        }
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/firebase/transport/LogSourceMetrics.java

@@ -0,0 +1,48 @@
+package com.google.android.datatransport.runtime.firebase.transport;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes2.dex */
+public final class LogSourceMetrics {
+    public static final LogSourceMetrics DEFAULT_INSTANCE = new Builder().build();
+    public final List log_event_dropped_;
+    public final String log_source_;
+
+    public List getLogEventDroppedList() {
+        return this.log_event_dropped_;
+    }
+
+    public String getLogSource() {
+        return this.log_source_;
+    }
+
+    public LogSourceMetrics(String str, List list) {
+        this.log_source_ = str;
+        this.log_event_dropped_ = list;
+    }
+
+    public static Builder newBuilder() {
+        return new Builder();
+    }
+
+    public static final class Builder {
+        public String log_source_ = "";
+        public List log_event_dropped_ = new ArrayList();
+
+        public Builder setLogEventDroppedList(List list) {
+            this.log_event_dropped_ = list;
+            return this;
+        }
+
+        public Builder setLogSource(String str) {
+            this.log_source_ = str;
+            return this;
+        }
+
+        public LogSourceMetrics build() {
+            return new LogSourceMetrics(this.log_source_, Collections.unmodifiableList(this.log_event_dropped_));
+        }
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/firebase/transport/StorageMetrics.java

@@ -0,0 +1,44 @@
+package com.google.android.datatransport.runtime.firebase.transport;
+
+/* loaded from: classes2.dex */
+public final class StorageMetrics {
+    public static final StorageMetrics DEFAULT_INSTANCE = new Builder().build();
+    public final long current_cache_size_bytes_;
+    public final long max_cache_size_bytes_;
+
+    public long getCurrentCacheSizeBytes() {
+        return this.current_cache_size_bytes_;
+    }
+
+    public long getMaxCacheSizeBytes() {
+        return this.max_cache_size_bytes_;
+    }
+
+    public StorageMetrics(long j, long j2) {
+        this.current_cache_size_bytes_ = j;
+        this.max_cache_size_bytes_ = j2;
+    }
+
+    public static Builder newBuilder() {
+        return new Builder();
+    }
+
+    public static final class Builder {
+        public long current_cache_size_bytes_ = 0;
+        public long max_cache_size_bytes_ = 0;
+
+        public Builder setCurrentCacheSizeBytes(long j) {
+            this.current_cache_size_bytes_ = j;
+            return this;
+        }
+
+        public Builder setMaxCacheSizeBytes(long j) {
+            this.max_cache_size_bytes_ = j;
+            return this;
+        }
+
+        public StorageMetrics build() {
+            return new StorageMetrics(this.current_cache_size_bytes_, this.max_cache_size_bytes_);
+        }
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/firebase/transport/TimeWindow.java

@@ -0,0 +1,44 @@
+package com.google.android.datatransport.runtime.firebase.transport;
+
+/* loaded from: classes2.dex */
+public final class TimeWindow {
+    public static final TimeWindow DEFAULT_INSTANCE = new Builder().build();
+    public final long end_ms_;
+    public final long start_ms_;
+
+    public long getEndMs() {
+        return this.end_ms_;
+    }
+
+    public long getStartMs() {
+        return this.start_ms_;
+    }
+
+    public TimeWindow(long j, long j2) {
+        this.start_ms_ = j;
+        this.end_ms_ = j2;
+    }
+
+    public static Builder newBuilder() {
+        return new Builder();
+    }
+
+    public static final class Builder {
+        public long start_ms_ = 0;
+        public long end_ms_ = 0;
+
+        public Builder setEndMs(long j) {
+            this.end_ms_ = j;
+            return this;
+        }
+
+        public Builder setStartMs(long j) {
+            this.start_ms_ = j;
+            return this;
+        }
+
+        public TimeWindow build() {
+            return new TimeWindow(this.start_ms_, this.end_ms_);
+        }
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/logging/Logging.java

@@ -0,0 +1,42 @@
+package com.google.android.datatransport.runtime.logging;
+
+import android.util.Log;
+
+/* loaded from: classes2.dex */
+public abstract class Logging {
+    public static String getTag(String str) {
+        return "TRuntime." + str;
+    }
+
+    public static void d(String str, String str2, Object obj) {
+        if (Log.isLoggable(getTag(str), 3)) {
+            String.format(str2, obj);
+        }
+    }
+
+    public static void d(String str, String str2, Object... objArr) {
+        if (Log.isLoggable(getTag(str), 3)) {
+            String.format(str2, objArr);
+        }
+    }
+
+    public static void i(String str, String str2, Object obj) {
+        if (Log.isLoggable(getTag(str), 4)) {
+            String.format(str2, obj);
+        }
+    }
+
+    public static void e(String str, String str2, Throwable th) {
+        String tag = getTag(str);
+        if (Log.isLoggable(tag, 6)) {
+            Log.e(tag, str2, th);
+        }
+    }
+
+    public static void w(String str, String str2, Object obj) {
+        String tag = getTag(str);
+        if (Log.isLoggable(tag, 5)) {
+            Log.w(tag, String.format(str2, obj));
+        }
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/retries/Function.java

@@ -0,0 +1,6 @@
+package com.google.android.datatransport.runtime.retries;
+
+/* loaded from: classes2.dex */
+public interface Function {
+    Object apply(Object obj);
+}

decompiled/sources/com/google/android/datatransport/runtime/retries/Retries.java

@@ -0,0 +1,20 @@
+package com.google.android.datatransport.runtime.retries;
+
+/* loaded from: classes2.dex */
+public abstract class Retries {
+    public static Object retry(int i, Object obj, Function function, RetryStrategy retryStrategy) {
+        Object apply;
+        if (i < 1) {
+            return function.apply(obj);
+        }
+        do {
+            apply = function.apply(obj);
+            obj = retryStrategy.shouldRetry(obj, apply);
+            if (obj == null) {
+                break;
+            }
+            i--;
+        } while (i >= 1);
+        return apply;
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/retries/RetryStrategy.java

@@ -0,0 +1,6 @@
+package com.google.android.datatransport.runtime.retries;
+
+/* loaded from: classes2.dex */
+public interface RetryStrategy {
+    Object shouldRetry(Object obj, Object obj2);
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/DefaultScheduler.java

@@ -0,0 +1,72 @@
+package com.google.android.datatransport.runtime.scheduling;
+
+import com.google.android.datatransport.TransportScheduleCallback;
+import com.google.android.datatransport.runtime.EventInternal;
+import com.google.android.datatransport.runtime.TransportContext;
+import com.google.android.datatransport.runtime.TransportRuntime;
+import com.google.android.datatransport.runtime.backends.BackendRegistry;
+import com.google.android.datatransport.runtime.backends.TransportBackend;
+import com.google.android.datatransport.runtime.scheduling.jobscheduling.WorkScheduler;
+import com.google.android.datatransport.runtime.scheduling.persistence.EventStore;
+import com.google.android.datatransport.runtime.synchronization.SynchronizationGuard;
+import java.util.concurrent.Executor;
+import java.util.logging.Logger;
+
+/* loaded from: classes2.dex */
+public class DefaultScheduler implements Scheduler {
+    public static final Logger LOGGER = Logger.getLogger(TransportRuntime.class.getName());
+    public final BackendRegistry backendRegistry;
+    public final EventStore eventStore;
+    public final Executor executor;
+    public final SynchronizationGuard guard;
+    public final WorkScheduler workScheduler;
+
+    public DefaultScheduler(Executor executor, BackendRegistry backendRegistry, WorkScheduler workScheduler, EventStore eventStore, SynchronizationGuard synchronizationGuard) {
+        this.executor = executor;
+        this.backendRegistry = backendRegistry;
+        this.workScheduler = workScheduler;
+        this.eventStore = eventStore;
+        this.guard = synchronizationGuard;
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.Scheduler
+    public void schedule(final TransportContext transportContext, final EventInternal eventInternal, final TransportScheduleCallback transportScheduleCallback) {
+        this.executor.execute(new Runnable() { // from class: com.google.android.datatransport.runtime.scheduling.DefaultScheduler$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                DefaultScheduler.this.lambda$schedule$1(transportContext, transportScheduleCallback, eventInternal);
+            }
+        });
+    }
+
+    public final /* synthetic */ void lambda$schedule$1(final TransportContext transportContext, TransportScheduleCallback transportScheduleCallback, EventInternal eventInternal) {
+        try {
+            TransportBackend transportBackend = this.backendRegistry.get(transportContext.getBackendName());
+            if (transportBackend == null) {
+                String format = String.format("Transport backend '%s' is not registered", transportContext.getBackendName());
+                LOGGER.warning(format);
+                transportScheduleCallback.onSchedule(new IllegalArgumentException(format));
+            } else {
+                final EventInternal decorate = transportBackend.decorate(eventInternal);
+                this.guard.runCriticalSection(new SynchronizationGuard.CriticalSection() { // from class: com.google.android.datatransport.runtime.scheduling.DefaultScheduler$$ExternalSyntheticLambda1
+                    @Override // com.google.android.datatransport.runtime.synchronization.SynchronizationGuard.CriticalSection
+                    public final Object execute() {
+                        Object lambda$schedule$0;
+                        lambda$schedule$0 = DefaultScheduler.this.lambda$schedule$0(transportContext, decorate);
+                        return lambda$schedule$0;
+                    }
+                });
+                transportScheduleCallback.onSchedule(null);
+            }
+        } catch (Exception e) {
+            LOGGER.warning("Error scheduling event " + e.getMessage());
+            transportScheduleCallback.onSchedule(e);
+        }
+    }
+
+    public final /* synthetic */ Object lambda$schedule$0(TransportContext transportContext, EventInternal eventInternal) {
+        this.eventStore.persist(transportContext, eventInternal);
+        this.workScheduler.schedule(transportContext, 1);
+        return null;
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/DefaultScheduler_Factory.java

@@ -0,0 +1,39 @@
+package com.google.android.datatransport.runtime.scheduling;
+
+import com.google.android.datatransport.runtime.backends.BackendRegistry;
+import com.google.android.datatransport.runtime.dagger.internal.Factory;
+import com.google.android.datatransport.runtime.scheduling.jobscheduling.WorkScheduler;
+import com.google.android.datatransport.runtime.scheduling.persistence.EventStore;
+import com.google.android.datatransport.runtime.synchronization.SynchronizationGuard;
+import java.util.concurrent.Executor;
+import javax.inject.Provider;
+
+/* loaded from: classes2.dex */
+public final class DefaultScheduler_Factory implements Factory {
+    public final Provider backendRegistryProvider;
+    public final Provider eventStoreProvider;
+    public final Provider executorProvider;
+    public final Provider guardProvider;
+    public final Provider workSchedulerProvider;
+
+    public DefaultScheduler_Factory(Provider provider, Provider provider2, Provider provider3, Provider provider4, Provider provider5) {
+        this.executorProvider = provider;
+        this.backendRegistryProvider = provider2;
+        this.workSchedulerProvider = provider3;
+        this.eventStoreProvider = provider4;
+        this.guardProvider = provider5;
+    }
+
+    @Override // javax.inject.Provider
+    public DefaultScheduler get() {
+        return newInstance((Executor) this.executorProvider.get(), (BackendRegistry) this.backendRegistryProvider.get(), (WorkScheduler) this.workSchedulerProvider.get(), (EventStore) this.eventStoreProvider.get(), (SynchronizationGuard) this.guardProvider.get());
+    }
+
+    public static DefaultScheduler_Factory create(Provider provider, Provider provider2, Provider provider3, Provider provider4, Provider provider5) {
+        return new DefaultScheduler_Factory(provider, provider2, provider3, provider4, provider5);
+    }
+
+    public static DefaultScheduler newInstance(Executor executor, BackendRegistry backendRegistry, WorkScheduler workScheduler, EventStore eventStore, SynchronizationGuard synchronizationGuard) {
+        return new DefaultScheduler(executor, backendRegistry, workScheduler, eventStore, synchronizationGuard);
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/Scheduler.java

@@ -0,0 +1,10 @@
+package com.google.android.datatransport.runtime.scheduling;
+
+import com.google.android.datatransport.TransportScheduleCallback;
+import com.google.android.datatransport.runtime.EventInternal;
+import com.google.android.datatransport.runtime.TransportContext;
+
+/* loaded from: classes2.dex */
+public interface Scheduler {
+    void schedule(TransportContext transportContext, EventInternal eventInternal, TransportScheduleCallback transportScheduleCallback);
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/SchedulingConfigModule.java

@@ -0,0 +1,11 @@
+package com.google.android.datatransport.runtime.scheduling;
+
+import com.google.android.datatransport.runtime.scheduling.jobscheduling.SchedulerConfig;
+import com.google.android.datatransport.runtime.time.Clock;
+
+/* loaded from: classes2.dex */
+public abstract class SchedulingConfigModule {
+    public static SchedulerConfig config(Clock clock) {
+        return SchedulerConfig.getDefault(clock);
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/SchedulingConfigModule_ConfigFactory.java

@@ -0,0 +1,29 @@
+package com.google.android.datatransport.runtime.scheduling;
+
+import com.google.android.datatransport.runtime.dagger.internal.Factory;
+import com.google.android.datatransport.runtime.dagger.internal.Preconditions;
+import com.google.android.datatransport.runtime.scheduling.jobscheduling.SchedulerConfig;
+import com.google.android.datatransport.runtime.time.Clock;
+import javax.inject.Provider;
+
+/* loaded from: classes2.dex */
+public final class SchedulingConfigModule_ConfigFactory implements Factory {
+    public final Provider clockProvider;
+
+    public SchedulingConfigModule_ConfigFactory(Provider provider) {
+        this.clockProvider = provider;
+    }
+
+    @Override // javax.inject.Provider
+    public SchedulerConfig get() {
+        return config((Clock) this.clockProvider.get());
+    }
+
+    public static SchedulingConfigModule_ConfigFactory create(Provider provider) {
+        return new SchedulingConfigModule_ConfigFactory(provider);
+    }
+
+    public static SchedulerConfig config(Clock clock) {
+        return (SchedulerConfig) Preconditions.checkNotNull(SchedulingConfigModule.config(clock), "Cannot return null from a non-@Nullable @Provides method");
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/SchedulingModule.java

@@ -0,0 +1,15 @@
+package com.google.android.datatransport.runtime.scheduling;
+
+import android.content.Context;
+import com.google.android.datatransport.runtime.scheduling.jobscheduling.JobInfoScheduler;
+import com.google.android.datatransport.runtime.scheduling.jobscheduling.SchedulerConfig;
+import com.google.android.datatransport.runtime.scheduling.jobscheduling.WorkScheduler;
+import com.google.android.datatransport.runtime.scheduling.persistence.EventStore;
+import com.google.android.datatransport.runtime.time.Clock;
+
+/* loaded from: classes2.dex */
+public abstract class SchedulingModule {
+    public static WorkScheduler workScheduler(Context context, EventStore eventStore, SchedulerConfig schedulerConfig, Clock clock) {
+        return new JobInfoScheduler(context, eventStore, schedulerConfig);
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/SchedulingModule_WorkSchedulerFactory.java

@@ -0,0 +1,38 @@
+package com.google.android.datatransport.runtime.scheduling;
+
+import android.content.Context;
+import com.google.android.datatransport.runtime.dagger.internal.Factory;
+import com.google.android.datatransport.runtime.dagger.internal.Preconditions;
+import com.google.android.datatransport.runtime.scheduling.jobscheduling.SchedulerConfig;
+import com.google.android.datatransport.runtime.scheduling.jobscheduling.WorkScheduler;
+import com.google.android.datatransport.runtime.scheduling.persistence.EventStore;
+import com.google.android.datatransport.runtime.time.Clock;
+import javax.inject.Provider;
+
+/* loaded from: classes2.dex */
+public final class SchedulingModule_WorkSchedulerFactory implements Factory {
+    public final Provider clockProvider;
+    public final Provider configProvider;
+    public final Provider contextProvider;
+    public final Provider eventStoreProvider;
+
+    public SchedulingModule_WorkSchedulerFactory(Provider provider, Provider provider2, Provider provider3, Provider provider4) {
+        this.contextProvider = provider;
+        this.eventStoreProvider = provider2;
+        this.configProvider = provider3;
+        this.clockProvider = provider4;
+    }
+
+    @Override // javax.inject.Provider
+    public WorkScheduler get() {
+        return workScheduler((Context) this.contextProvider.get(), (EventStore) this.eventStoreProvider.get(), (SchedulerConfig) this.configProvider.get(), (Clock) this.clockProvider.get());
+    }
+
+    public static SchedulingModule_WorkSchedulerFactory create(Provider provider, Provider provider2, Provider provider3, Provider provider4) {
+        return new SchedulingModule_WorkSchedulerFactory(provider, provider2, provider3, provider4);
+    }
+
+    public static WorkScheduler workScheduler(Context context, EventStore eventStore, SchedulerConfig schedulerConfig, Clock clock) {
+        return (WorkScheduler) Preconditions.checkNotNull(SchedulingModule.workScheduler(context, eventStore, schedulerConfig, clock), "Cannot return null from a non-@Nullable @Provides method");
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/jobscheduling/AlarmManagerSchedulerBroadcastReceiver.java

@@ -0,0 +1,35 @@
+package com.google.android.datatransport.runtime.scheduling.jobscheduling;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.util.Base64;
+import com.google.android.datatransport.runtime.TransportContext;
+import com.google.android.datatransport.runtime.TransportRuntime;
+import com.google.android.datatransport.runtime.util.PriorityMapping;
+import com.unity3d.ads.core.domain.HandleInvocationsFromAdViewer;
+
+/* loaded from: classes2.dex */
+public class AlarmManagerSchedulerBroadcastReceiver extends BroadcastReceiver {
+    public static /* synthetic */ void lambda$onReceive$0() {
+    }
+
+    @Override // android.content.BroadcastReceiver
+    public void onReceive(Context context, Intent intent) {
+        String queryParameter = intent.getData().getQueryParameter("backendName");
+        String queryParameter2 = intent.getData().getQueryParameter("extras");
+        int intValue = Integer.valueOf(intent.getData().getQueryParameter(HandleInvocationsFromAdViewer.KEY_DOWNLOAD_PRIORITY)).intValue();
+        int i = intent.getExtras().getInt("attemptNumber");
+        TransportRuntime.initialize(context);
+        TransportContext.Builder priority = TransportContext.builder().setBackendName(queryParameter).setPriority(PriorityMapping.valueOf(intValue));
+        if (queryParameter2 != null) {
+            priority.setExtras(Base64.decode(queryParameter2, 0));
+        }
+        TransportRuntime.getInstance().getUploader().upload(priority.build(), i, new Runnable() { // from class: com.google.android.datatransport.runtime.scheduling.jobscheduling.AlarmManagerSchedulerBroadcastReceiver$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                AlarmManagerSchedulerBroadcastReceiver.lambda$onReceive$0();
+            }
+        });
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/jobscheduling/AutoValue_SchedulerConfig.java

@@ -0,0 +1,50 @@
+package com.google.android.datatransport.runtime.scheduling.jobscheduling;
+
+import com.google.android.datatransport.runtime.time.Clock;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+public final class AutoValue_SchedulerConfig extends SchedulerConfig {
+    public final Clock clock;
+    public final Map values;
+
+    @Override // com.google.android.datatransport.runtime.scheduling.jobscheduling.SchedulerConfig
+    public Clock getClock() {
+        return this.clock;
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.jobscheduling.SchedulerConfig
+    public Map getValues() {
+        return this.values;
+    }
+
+    public AutoValue_SchedulerConfig(Clock clock, Map map) {
+        if (clock == null) {
+            throw new NullPointerException("Null clock");
+        }
+        this.clock = clock;
+        if (map == null) {
+            throw new NullPointerException("Null values");
+        }
+        this.values = map;
+    }
+
+    public String toString() {
+        return "SchedulerConfig{clock=" + this.clock + ", values=" + this.values + "}";
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof SchedulerConfig)) {
+            return false;
+        }
+        SchedulerConfig schedulerConfig = (SchedulerConfig) obj;
+        return this.clock.equals(schedulerConfig.getClock()) && this.values.equals(schedulerConfig.getValues());
+    }
+
+    public int hashCode() {
+        return ((this.clock.hashCode() ^ 1000003) * 1000003) ^ this.values.hashCode();
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/jobscheduling/AutoValue_SchedulerConfig_ConfigValue.java

@@ -0,0 +1,99 @@
+package com.google.android.datatransport.runtime.scheduling.jobscheduling;
+
+import com.google.android.datatransport.runtime.scheduling.jobscheduling.SchedulerConfig;
+import java.util.Set;
+
+/* loaded from: classes2.dex */
+public final class AutoValue_SchedulerConfig_ConfigValue extends SchedulerConfig.ConfigValue {
+    public final long delta;
+    public final Set flags;
+    public final long maxAllowedDelay;
+
+    @Override // com.google.android.datatransport.runtime.scheduling.jobscheduling.SchedulerConfig.ConfigValue
+    public long getDelta() {
+        return this.delta;
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.jobscheduling.SchedulerConfig.ConfigValue
+    public Set getFlags() {
+        return this.flags;
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.jobscheduling.SchedulerConfig.ConfigValue
+    public long getMaxAllowedDelay() {
+        return this.maxAllowedDelay;
+    }
+
+    public AutoValue_SchedulerConfig_ConfigValue(long j, long j2, Set set) {
+        this.delta = j;
+        this.maxAllowedDelay = j2;
+        this.flags = set;
+    }
+
+    public String toString() {
+        return "ConfigValue{delta=" + this.delta + ", maxAllowedDelay=" + this.maxAllowedDelay + ", flags=" + this.flags + "}";
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof SchedulerConfig.ConfigValue)) {
+            return false;
+        }
+        SchedulerConfig.ConfigValue configValue = (SchedulerConfig.ConfigValue) obj;
+        return this.delta == configValue.getDelta() && this.maxAllowedDelay == configValue.getMaxAllowedDelay() && this.flags.equals(configValue.getFlags());
+    }
+
+    public int hashCode() {
+        long j = this.delta;
+        int i = (((int) (j ^ (j >>> 32))) ^ 1000003) * 1000003;
+        long j2 = this.maxAllowedDelay;
+        return ((i ^ ((int) ((j2 >>> 32) ^ j2))) * 1000003) ^ this.flags.hashCode();
+    }
+
+    public static final class Builder extends SchedulerConfig.ConfigValue.Builder {
+        public Long delta;
+        public Set flags;
+        public Long maxAllowedDelay;
+
+        @Override // com.google.android.datatransport.runtime.scheduling.jobscheduling.SchedulerConfig.ConfigValue.Builder
+        public SchedulerConfig.ConfigValue.Builder setDelta(long j) {
+            this.delta = Long.valueOf(j);
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.scheduling.jobscheduling.SchedulerConfig.ConfigValue.Builder
+        public SchedulerConfig.ConfigValue.Builder setMaxAllowedDelay(long j) {
+            this.maxAllowedDelay = Long.valueOf(j);
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.scheduling.jobscheduling.SchedulerConfig.ConfigValue.Builder
+        public SchedulerConfig.ConfigValue.Builder setFlags(Set set) {
+            if (set == null) {
+                throw new NullPointerException("Null flags");
+            }
+            this.flags = set;
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.scheduling.jobscheduling.SchedulerConfig.ConfigValue.Builder
+        public SchedulerConfig.ConfigValue build() {
+            String str = "";
+            if (this.delta == null) {
+                str = " delta";
+            }
+            if (this.maxAllowedDelay == null) {
+                str = str + " maxAllowedDelay";
+            }
+            if (this.flags == null) {
+                str = str + " flags";
+            }
+            if (!str.isEmpty()) {
+                throw new IllegalStateException("Missing required properties:" + str);
+            }
+            return new AutoValue_SchedulerConfig_ConfigValue(this.delta.longValue(), this.maxAllowedDelay.longValue(), this.flags);
+        }
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/jobscheduling/JobInfoScheduler.java

@@ -0,0 +1,78 @@
+package com.google.android.datatransport.runtime.scheduling.jobscheduling;
+
+import android.app.job.JobInfo;
+import android.app.job.JobScheduler;
+import android.content.ComponentName;
+import android.content.Context;
+import android.os.PersistableBundle;
+import android.util.Base64;
+import com.google.android.datatransport.runtime.TransportContext;
+import com.google.android.datatransport.runtime.logging.Logging;
+import com.google.android.datatransport.runtime.scheduling.persistence.EventStore;
+import com.google.android.datatransport.runtime.util.PriorityMapping;
+import com.unity3d.ads.core.domain.HandleInvocationsFromAdViewer;
+import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+import java.util.zip.Adler32;
+
+/* loaded from: classes2.dex */
+public class JobInfoScheduler implements WorkScheduler {
+    public final SchedulerConfig config;
+    public final Context context;
+    public final EventStore eventStore;
+
+    public JobInfoScheduler(Context context, EventStore eventStore, SchedulerConfig schedulerConfig) {
+        this.context = context;
+        this.eventStore = eventStore;
+        this.config = schedulerConfig;
+    }
+
+    public int getJobId(TransportContext transportContext) {
+        Adler32 adler32 = new Adler32();
+        adler32.update(this.context.getPackageName().getBytes(Charset.forName("UTF-8")));
+        adler32.update(transportContext.getBackendName().getBytes(Charset.forName("UTF-8")));
+        adler32.update(ByteBuffer.allocate(4).putInt(PriorityMapping.toInt(transportContext.getPriority())).array());
+        if (transportContext.getExtras() != null) {
+            adler32.update(transportContext.getExtras());
+        }
+        return (int) adler32.getValue();
+    }
+
+    public final boolean isJobServiceOn(JobScheduler jobScheduler, int i, int i2) {
+        for (JobInfo jobInfo : jobScheduler.getAllPendingJobs()) {
+            int i3 = jobInfo.getExtras().getInt("attemptNumber");
+            if (jobInfo.getId() == i) {
+                return i3 >= i2;
+            }
+        }
+        return false;
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.jobscheduling.WorkScheduler
+    public void schedule(TransportContext transportContext, int i) {
+        schedule(transportContext, i, false);
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.jobscheduling.WorkScheduler
+    public void schedule(TransportContext transportContext, int i, boolean z) {
+        ComponentName componentName = new ComponentName(this.context, (Class<?>) JobInfoSchedulerService.class);
+        JobScheduler jobScheduler = (JobScheduler) this.context.getSystemService("jobscheduler");
+        int jobId = getJobId(transportContext);
+        if (!z && isJobServiceOn(jobScheduler, jobId, i)) {
+            Logging.d("JobInfoScheduler", "Upload for context %s is already scheduled. Returning...", transportContext);
+            return;
+        }
+        long nextCallTime = this.eventStore.getNextCallTime(transportContext);
+        JobInfo.Builder configureJob = this.config.configureJob(new JobInfo.Builder(jobId, componentName), transportContext.getPriority(), nextCallTime, i);
+        PersistableBundle persistableBundle = new PersistableBundle();
+        persistableBundle.putInt("attemptNumber", i);
+        persistableBundle.putString("backendName", transportContext.getBackendName());
+        persistableBundle.putInt(HandleInvocationsFromAdViewer.KEY_DOWNLOAD_PRIORITY, PriorityMapping.toInt(transportContext.getPriority()));
+        if (transportContext.getExtras() != null) {
+            persistableBundle.putString("extras", Base64.encodeToString(transportContext.getExtras(), 0));
+        }
+        configureJob.setExtras(persistableBundle);
+        Logging.d("JobInfoScheduler", "Scheduling upload for context %s with jobId=%d in %dms(Backend next call timestamp %d). Attempt %d", transportContext, Integer.valueOf(jobId), Long.valueOf(this.config.getScheduleDelay(transportContext.getPriority(), nextCallTime, i)), Long.valueOf(nextCallTime), Integer.valueOf(i));
+        jobScheduler.schedule(configureJob.build());
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/jobscheduling/JobInfoSchedulerService.java

@@ -0,0 +1,43 @@
+package com.google.android.datatransport.runtime.scheduling.jobscheduling;
+
+import android.app.job.JobParameters;
+import android.app.job.JobService;
+import android.util.Base64;
+import androidx.annotation.RequiresApi;
+import com.google.android.datatransport.runtime.TransportContext;
+import com.google.android.datatransport.runtime.TransportRuntime;
+import com.google.android.datatransport.runtime.util.PriorityMapping;
+import com.unity3d.ads.core.domain.HandleInvocationsFromAdViewer;
+
+@RequiresApi(api = 21)
+/* loaded from: classes2.dex */
+public class JobInfoSchedulerService extends JobService {
+    @Override // android.app.job.JobService
+    public boolean onStopJob(JobParameters jobParameters) {
+        return true;
+    }
+
+    @Override // android.app.job.JobService
+    public boolean onStartJob(final JobParameters jobParameters) {
+        String string = jobParameters.getExtras().getString("backendName");
+        String string2 = jobParameters.getExtras().getString("extras");
+        int i = jobParameters.getExtras().getInt(HandleInvocationsFromAdViewer.KEY_DOWNLOAD_PRIORITY);
+        int i2 = jobParameters.getExtras().getInt("attemptNumber");
+        TransportRuntime.initialize(getApplicationContext());
+        TransportContext.Builder priority = TransportContext.builder().setBackendName(string).setPriority(PriorityMapping.valueOf(i));
+        if (string2 != null) {
+            priority.setExtras(Base64.decode(string2, 0));
+        }
+        TransportRuntime.getInstance().getUploader().upload(priority.build(), i2, new Runnable() { // from class: com.google.android.datatransport.runtime.scheduling.jobscheduling.JobInfoSchedulerService$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                JobInfoSchedulerService.this.lambda$onStartJob$0(jobParameters);
+            }
+        });
+        return true;
+    }
+
+    public final /* synthetic */ void lambda$onStartJob$0(JobParameters jobParameters) {
+        jobFinished(jobParameters, false);
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/jobscheduling/SchedulerConfig.java

@@ -0,0 +1,124 @@
+package com.google.android.datatransport.runtime.scheduling.jobscheduling;
+
+import android.app.job.JobInfo;
+import androidx.work.WorkRequest;
+import com.google.android.datatransport.Priority;
+import com.google.android.datatransport.runtime.scheduling.jobscheduling.AutoValue_SchedulerConfig_ConfigValue;
+import com.google.android.datatransport.runtime.time.Clock;
+import com.vungle.ads.internal.signals.SignalManager;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/* loaded from: classes2.dex */
+public abstract class SchedulerConfig {
+
+    public enum Flag {
+        NETWORK_UNMETERED,
+        DEVICE_IDLE,
+        DEVICE_CHARGING
+    }
+
+    public abstract Clock getClock();
+
+    public abstract Map getValues();
+
+    public static abstract class ConfigValue {
+
+        public static abstract class Builder {
+            public abstract ConfigValue build();
+
+            public abstract Builder setDelta(long j);
+
+            public abstract Builder setFlags(Set set);
+
+            public abstract Builder setMaxAllowedDelay(long j);
+        }
+
+        public abstract long getDelta();
+
+        public abstract Set getFlags();
+
+        public abstract long getMaxAllowedDelay();
+
+        public static Builder builder() {
+            return new AutoValue_SchedulerConfig_ConfigValue.Builder().setFlags(Collections.emptySet());
+        }
+    }
+
+    public static SchedulerConfig getDefault(Clock clock) {
+        return builder().addConfig(Priority.DEFAULT, ConfigValue.builder().setDelta(WorkRequest.DEFAULT_BACKOFF_DELAY_MILLIS).setMaxAllowedDelay(SignalManager.TWENTY_FOUR_HOURS_MILLIS).build()).addConfig(Priority.HIGHEST, ConfigValue.builder().setDelta(1000L).setMaxAllowedDelay(SignalManager.TWENTY_FOUR_HOURS_MILLIS).build()).addConfig(Priority.VERY_LOW, ConfigValue.builder().setDelta(SignalManager.TWENTY_FOUR_HOURS_MILLIS).setMaxAllowedDelay(SignalManager.TWENTY_FOUR_HOURS_MILLIS).setFlags(immutableSetOf(Flag.DEVICE_IDLE)).build()).setClock(clock).build();
+    }
+
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    public static SchedulerConfig create(Clock clock, Map map) {
+        return new AutoValue_SchedulerConfig(clock, map);
+    }
+
+    public static class Builder {
+        public Clock clock;
+        public Map values = new HashMap();
+
+        public Builder setClock(Clock clock) {
+            this.clock = clock;
+            return this;
+        }
+
+        public Builder addConfig(Priority priority, ConfigValue configValue) {
+            this.values.put(priority, configValue);
+            return this;
+        }
+
+        public SchedulerConfig build() {
+            if (this.clock == null) {
+                throw new NullPointerException("missing required property: clock");
+            }
+            if (this.values.keySet().size() < Priority.values().length) {
+                throw new IllegalStateException("Not all priorities have been configured");
+            }
+            Map map = this.values;
+            this.values = new HashMap();
+            return SchedulerConfig.create(this.clock, map);
+        }
+    }
+
+    public long getScheduleDelay(Priority priority, long j, int i) {
+        long time = j - getClock().getTime();
+        ConfigValue configValue = (ConfigValue) getValues().get(priority);
+        return Math.min(Math.max(adjustedExponentialBackoff(i, configValue.getDelta()), time), configValue.getMaxAllowedDelay());
+    }
+
+    public final long adjustedExponentialBackoff(int i, long j) {
+        return (long) (Math.pow(3.0d, i - 1) * j * Math.max(1.0d, Math.log(10000.0d) / Math.log((j > 1 ? j : 2L) * r7)));
+    }
+
+    public JobInfo.Builder configureJob(JobInfo.Builder builder, Priority priority, long j, int i) {
+        builder.setMinimumLatency(getScheduleDelay(priority, j, i));
+        populateFlags(builder, ((ConfigValue) getValues().get(priority)).getFlags());
+        return builder;
+    }
+
+    public final void populateFlags(JobInfo.Builder builder, Set set) {
+        if (set.contains(Flag.NETWORK_UNMETERED)) {
+            builder.setRequiredNetworkType(2);
+        } else {
+            builder.setRequiredNetworkType(1);
+        }
+        if (set.contains(Flag.DEVICE_CHARGING)) {
+            builder.setRequiresCharging(true);
+        }
+        if (set.contains(Flag.DEVICE_IDLE)) {
+            builder.setRequiresDeviceIdle(true);
+        }
+    }
+
+    public static Set immutableSetOf(Object... objArr) {
+        return Collections.unmodifiableSet(new HashSet(Arrays.asList(objArr)));
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/jobscheduling/Uploader.java

@@ -0,0 +1,261 @@
+package com.google.android.datatransport.runtime.scheduling.jobscheduling;
+
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+import com.google.android.datatransport.Encoding;
+import com.google.android.datatransport.runtime.EncodedPayload;
+import com.google.android.datatransport.runtime.EventInternal;
+import com.google.android.datatransport.runtime.TransportContext;
+import com.google.android.datatransport.runtime.backends.BackendRegistry;
+import com.google.android.datatransport.runtime.backends.BackendRequest;
+import com.google.android.datatransport.runtime.backends.BackendResponse;
+import com.google.android.datatransport.runtime.backends.TransportBackend;
+import com.google.android.datatransport.runtime.firebase.transport.ClientMetrics;
+import com.google.android.datatransport.runtime.firebase.transport.LogEventDropped;
+import com.google.android.datatransport.runtime.logging.Logging;
+import com.google.android.datatransport.runtime.scheduling.persistence.ClientHealthMetricsStore;
+import com.google.android.datatransport.runtime.scheduling.persistence.EventStore;
+import com.google.android.datatransport.runtime.scheduling.persistence.PersistedEvent;
+import com.google.android.datatransport.runtime.synchronization.SynchronizationException;
+import com.google.android.datatransport.runtime.synchronization.SynchronizationGuard;
+import com.google.android.datatransport.runtime.time.Clock;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes2.dex */
+public class Uploader {
+    public final BackendRegistry backendRegistry;
+    public final ClientHealthMetricsStore clientHealthMetricsStore;
+    public final Clock clock;
+    public final Context context;
+    public final EventStore eventStore;
+    public final Executor executor;
+    public final SynchronizationGuard guard;
+    public final Clock uptimeClock;
+    public final WorkScheduler workScheduler;
+
+    public Uploader(Context context, BackendRegistry backendRegistry, EventStore eventStore, WorkScheduler workScheduler, Executor executor, SynchronizationGuard synchronizationGuard, Clock clock, Clock clock2, ClientHealthMetricsStore clientHealthMetricsStore) {
+        this.context = context;
+        this.backendRegistry = backendRegistry;
+        this.eventStore = eventStore;
+        this.workScheduler = workScheduler;
+        this.executor = executor;
+        this.guard = synchronizationGuard;
+        this.clock = clock;
+        this.uptimeClock = clock2;
+        this.clientHealthMetricsStore = clientHealthMetricsStore;
+    }
+
+    public boolean isNetworkAvailable() {
+        NetworkInfo activeNetworkInfo = ((ConnectivityManager) this.context.getSystemService("connectivity")).getActiveNetworkInfo();
+        return activeNetworkInfo != null && activeNetworkInfo.isConnected();
+    }
+
+    public void upload(final TransportContext transportContext, final int i, final Runnable runnable) {
+        this.executor.execute(new Runnable() { // from class: com.google.android.datatransport.runtime.scheduling.jobscheduling.Uploader$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                Uploader.this.lambda$upload$1(transportContext, i, runnable);
+            }
+        });
+    }
+
+    public final /* synthetic */ void lambda$upload$1(final TransportContext transportContext, final int i, Runnable runnable) {
+        try {
+            try {
+                SynchronizationGuard synchronizationGuard = this.guard;
+                final EventStore eventStore = this.eventStore;
+                Objects.requireNonNull(eventStore);
+                synchronizationGuard.runCriticalSection(new SynchronizationGuard.CriticalSection() { // from class: com.google.android.datatransport.runtime.scheduling.jobscheduling.Uploader$$ExternalSyntheticLambda1
+                    @Override // com.google.android.datatransport.runtime.synchronization.SynchronizationGuard.CriticalSection
+                    public final Object execute() {
+                        return Integer.valueOf(EventStore.this.cleanUp());
+                    }
+                });
+                if (!isNetworkAvailable()) {
+                    this.guard.runCriticalSection(new SynchronizationGuard.CriticalSection() { // from class: com.google.android.datatransport.runtime.scheduling.jobscheduling.Uploader$$ExternalSyntheticLambda2
+                        @Override // com.google.android.datatransport.runtime.synchronization.SynchronizationGuard.CriticalSection
+                        public final Object execute() {
+                            Object lambda$upload$0;
+                            lambda$upload$0 = Uploader.this.lambda$upload$0(transportContext, i);
+                            return lambda$upload$0;
+                        }
+                    });
+                } else {
+                    logAndUpdateState(transportContext, i);
+                }
+            } catch (SynchronizationException unused) {
+                this.workScheduler.schedule(transportContext, i + 1);
+            }
+            runnable.run();
+        } catch (Throwable th) {
+            runnable.run();
+            throw th;
+        }
+    }
+
+    public final /* synthetic */ Object lambda$upload$0(TransportContext transportContext, int i) {
+        this.workScheduler.schedule(transportContext, i + 1);
+        return null;
+    }
+
+    public BackendResponse logAndUpdateState(final TransportContext transportContext, int i) {
+        BackendResponse send;
+        TransportBackend transportBackend = this.backendRegistry.get(transportContext.getBackendName());
+        long j = 0;
+        BackendResponse ok = BackendResponse.ok(0L);
+        while (true) {
+            final long j2 = j;
+            while (((Boolean) this.guard.runCriticalSection(new SynchronizationGuard.CriticalSection() { // from class: com.google.android.datatransport.runtime.scheduling.jobscheduling.Uploader$$ExternalSyntheticLambda3
+                @Override // com.google.android.datatransport.runtime.synchronization.SynchronizationGuard.CriticalSection
+                public final Object execute() {
+                    Boolean lambda$logAndUpdateState$2;
+                    lambda$logAndUpdateState$2 = Uploader.this.lambda$logAndUpdateState$2(transportContext);
+                    return lambda$logAndUpdateState$2;
+                }
+            })).booleanValue()) {
+                final Iterable iterable = (Iterable) this.guard.runCriticalSection(new SynchronizationGuard.CriticalSection() { // from class: com.google.android.datatransport.runtime.scheduling.jobscheduling.Uploader$$ExternalSyntheticLambda4
+                    @Override // com.google.android.datatransport.runtime.synchronization.SynchronizationGuard.CriticalSection
+                    public final Object execute() {
+                        Iterable lambda$logAndUpdateState$3;
+                        lambda$logAndUpdateState$3 = Uploader.this.lambda$logAndUpdateState$3(transportContext);
+                        return lambda$logAndUpdateState$3;
+                    }
+                });
+                if (!iterable.iterator().hasNext()) {
+                    return ok;
+                }
+                if (transportBackend == null) {
+                    Logging.d("Uploader", "Unknown backend for %s, deleting event batch for it...", transportContext);
+                    send = BackendResponse.fatalError();
+                } else {
+                    ArrayList arrayList = new ArrayList();
+                    Iterator it = iterable.iterator();
+                    while (it.hasNext()) {
+                        arrayList.add(((PersistedEvent) it.next()).getEvent());
+                    }
+                    if (transportContext.shouldUploadClientHealthMetrics()) {
+                        arrayList.add(createMetricsEvent(transportBackend));
+                    }
+                    send = transportBackend.send(BackendRequest.builder().setEvents(arrayList).setExtras(transportContext.getExtras()).build());
+                }
+                ok = send;
+                if (ok.getStatus() == BackendResponse.Status.TRANSIENT_ERROR) {
+                    this.guard.runCriticalSection(new SynchronizationGuard.CriticalSection() { // from class: com.google.android.datatransport.runtime.scheduling.jobscheduling.Uploader$$ExternalSyntheticLambda5
+                        @Override // com.google.android.datatransport.runtime.synchronization.SynchronizationGuard.CriticalSection
+                        public final Object execute() {
+                            Object lambda$logAndUpdateState$4;
+                            lambda$logAndUpdateState$4 = Uploader.this.lambda$logAndUpdateState$4(iterable, transportContext, j2);
+                            return lambda$logAndUpdateState$4;
+                        }
+                    });
+                    this.workScheduler.schedule(transportContext, i + 1, true);
+                    return ok;
+                }
+                this.guard.runCriticalSection(new SynchronizationGuard.CriticalSection() { // from class: com.google.android.datatransport.runtime.scheduling.jobscheduling.Uploader$$ExternalSyntheticLambda6
+                    @Override // com.google.android.datatransport.runtime.synchronization.SynchronizationGuard.CriticalSection
+                    public final Object execute() {
+                        Object lambda$logAndUpdateState$5;
+                        lambda$logAndUpdateState$5 = Uploader.this.lambda$logAndUpdateState$5(iterable);
+                        return lambda$logAndUpdateState$5;
+                    }
+                });
+                if (ok.getStatus() == BackendResponse.Status.OK) {
+                    j = Math.max(j2, ok.getNextRequestWaitMillis());
+                    if (transportContext.shouldUploadClientHealthMetrics()) {
+                        this.guard.runCriticalSection(new SynchronizationGuard.CriticalSection() { // from class: com.google.android.datatransport.runtime.scheduling.jobscheduling.Uploader$$ExternalSyntheticLambda7
+                            @Override // com.google.android.datatransport.runtime.synchronization.SynchronizationGuard.CriticalSection
+                            public final Object execute() {
+                                Object lambda$logAndUpdateState$6;
+                                lambda$logAndUpdateState$6 = Uploader.this.lambda$logAndUpdateState$6();
+                                return lambda$logAndUpdateState$6;
+                            }
+                        });
+                    }
+                } else if (ok.getStatus() == BackendResponse.Status.INVALID_PAYLOAD) {
+                    final HashMap hashMap = new HashMap();
+                    Iterator it2 = iterable.iterator();
+                    while (it2.hasNext()) {
+                        String transportName = ((PersistedEvent) it2.next()).getEvent().getTransportName();
+                        if (!hashMap.containsKey(transportName)) {
+                            hashMap.put(transportName, 1);
+                        } else {
+                            hashMap.put(transportName, Integer.valueOf(((Integer) hashMap.get(transportName)).intValue() + 1));
+                        }
+                    }
+                    this.guard.runCriticalSection(new SynchronizationGuard.CriticalSection() { // from class: com.google.android.datatransport.runtime.scheduling.jobscheduling.Uploader$$ExternalSyntheticLambda8
+                        @Override // com.google.android.datatransport.runtime.synchronization.SynchronizationGuard.CriticalSection
+                        public final Object execute() {
+                            Object lambda$logAndUpdateState$7;
+                            lambda$logAndUpdateState$7 = Uploader.this.lambda$logAndUpdateState$7(hashMap);
+                            return lambda$logAndUpdateState$7;
+                        }
+                    });
+                }
+            }
+            this.guard.runCriticalSection(new SynchronizationGuard.CriticalSection() { // from class: com.google.android.datatransport.runtime.scheduling.jobscheduling.Uploader$$ExternalSyntheticLambda9
+                @Override // com.google.android.datatransport.runtime.synchronization.SynchronizationGuard.CriticalSection
+                public final Object execute() {
+                    Object lambda$logAndUpdateState$8;
+                    lambda$logAndUpdateState$8 = Uploader.this.lambda$logAndUpdateState$8(transportContext, j2);
+                    return lambda$logAndUpdateState$8;
+                }
+            });
+            return ok;
+        }
+    }
+
+    public final /* synthetic */ Boolean lambda$logAndUpdateState$2(TransportContext transportContext) {
+        return Boolean.valueOf(this.eventStore.hasPendingEventsFor(transportContext));
+    }
+
+    public final /* synthetic */ Iterable lambda$logAndUpdateState$3(TransportContext transportContext) {
+        return this.eventStore.loadBatch(transportContext);
+    }
+
+    public final /* synthetic */ Object lambda$logAndUpdateState$4(Iterable iterable, TransportContext transportContext, long j) {
+        this.eventStore.recordFailure(iterable);
+        this.eventStore.recordNextCallTime(transportContext, this.clock.getTime() + j);
+        return null;
+    }
+
+    public final /* synthetic */ Object lambda$logAndUpdateState$5(Iterable iterable) {
+        this.eventStore.recordSuccess(iterable);
+        return null;
+    }
+
+    public final /* synthetic */ Object lambda$logAndUpdateState$6() {
+        this.clientHealthMetricsStore.resetClientMetrics();
+        return null;
+    }
+
+    public final /* synthetic */ Object lambda$logAndUpdateState$7(Map map) {
+        Iterator it = map.entrySet().iterator();
+        while (it.hasNext()) {
+            this.clientHealthMetricsStore.recordLogEventDropped(((Integer) r0.getValue()).intValue(), LogEventDropped.Reason.INVALID_PAYLOD, (String) ((Map.Entry) it.next()).getKey());
+        }
+        return null;
+    }
+
+    public final /* synthetic */ Object lambda$logAndUpdateState$8(TransportContext transportContext, long j) {
+        this.eventStore.recordNextCallTime(transportContext, this.clock.getTime() + j);
+        return null;
+    }
+
+    public EventInternal createMetricsEvent(TransportBackend transportBackend) {
+        SynchronizationGuard synchronizationGuard = this.guard;
+        final ClientHealthMetricsStore clientHealthMetricsStore = this.clientHealthMetricsStore;
+        Objects.requireNonNull(clientHealthMetricsStore);
+        return transportBackend.decorate(EventInternal.builder().setEventMillis(this.clock.getTime()).setUptimeMillis(this.uptimeClock.getTime()).setTransportName("GDT_CLIENT_METRICS").setEncodedPayload(new EncodedPayload(Encoding.of("proto"), ((ClientMetrics) synchronizationGuard.runCriticalSection(new SynchronizationGuard.CriticalSection() { // from class: com.google.android.datatransport.runtime.scheduling.jobscheduling.Uploader$$ExternalSyntheticLambda10
+            @Override // com.google.android.datatransport.runtime.synchronization.SynchronizationGuard.CriticalSection
+            public final Object execute() {
+                return ClientHealthMetricsStore.this.loadClientMetrics();
+            }
+        })).toByteArray())).build());
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/jobscheduling/Uploader_Factory.java

@@ -0,0 +1,49 @@
+package com.google.android.datatransport.runtime.scheduling.jobscheduling;
+
+import android.content.Context;
+import com.google.android.datatransport.runtime.backends.BackendRegistry;
+import com.google.android.datatransport.runtime.dagger.internal.Factory;
+import com.google.android.datatransport.runtime.scheduling.persistence.ClientHealthMetricsStore;
+import com.google.android.datatransport.runtime.scheduling.persistence.EventStore;
+import com.google.android.datatransport.runtime.synchronization.SynchronizationGuard;
+import com.google.android.datatransport.runtime.time.Clock;
+import java.util.concurrent.Executor;
+import javax.inject.Provider;
+
+/* loaded from: classes2.dex */
+public final class Uploader_Factory implements Factory {
+    public final Provider backendRegistryProvider;
+    public final Provider clientHealthMetricsStoreProvider;
+    public final Provider clockProvider;
+    public final Provider contextProvider;
+    public final Provider eventStoreProvider;
+    public final Provider executorProvider;
+    public final Provider guardProvider;
+    public final Provider uptimeClockProvider;
+    public final Provider workSchedulerProvider;
+
+    public Uploader_Factory(Provider provider, Provider provider2, Provider provider3, Provider provider4, Provider provider5, Provider provider6, Provider provider7, Provider provider8, Provider provider9) {
+        this.contextProvider = provider;
+        this.backendRegistryProvider = provider2;
+        this.eventStoreProvider = provider3;
+        this.workSchedulerProvider = provider4;
+        this.executorProvider = provider5;
+        this.guardProvider = provider6;
+        this.clockProvider = provider7;
+        this.uptimeClockProvider = provider8;
+        this.clientHealthMetricsStoreProvider = provider9;
+    }
+
+    @Override // javax.inject.Provider
+    public Uploader get() {
+        return newInstance((Context) this.contextProvider.get(), (BackendRegistry) this.backendRegistryProvider.get(), (EventStore) this.eventStoreProvider.get(), (WorkScheduler) this.workSchedulerProvider.get(), (Executor) this.executorProvider.get(), (SynchronizationGuard) this.guardProvider.get(), (Clock) this.clockProvider.get(), (Clock) this.uptimeClockProvider.get(), (ClientHealthMetricsStore) this.clientHealthMetricsStoreProvider.get());
+    }
+
+    public static Uploader_Factory create(Provider provider, Provider provider2, Provider provider3, Provider provider4, Provider provider5, Provider provider6, Provider provider7, Provider provider8, Provider provider9) {
+        return new Uploader_Factory(provider, provider2, provider3, provider4, provider5, provider6, provider7, provider8, provider9);
+    }
+
+    public static Uploader newInstance(Context context, BackendRegistry backendRegistry, EventStore eventStore, WorkScheduler workScheduler, Executor executor, SynchronizationGuard synchronizationGuard, Clock clock, Clock clock2, ClientHealthMetricsStore clientHealthMetricsStore) {
+        return new Uploader(context, backendRegistry, eventStore, workScheduler, executor, synchronizationGuard, clock, clock2, clientHealthMetricsStore);
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/jobscheduling/WorkInitializer.java

@@ -0,0 +1,50 @@
+package com.google.android.datatransport.runtime.scheduling.jobscheduling;
+
+import com.google.android.datatransport.runtime.TransportContext;
+import com.google.android.datatransport.runtime.scheduling.persistence.EventStore;
+import com.google.android.datatransport.runtime.synchronization.SynchronizationGuard;
+import java.util.Iterator;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes2.dex */
+public class WorkInitializer {
+    public final Executor executor;
+    public final SynchronizationGuard guard;
+    public final WorkScheduler scheduler;
+    public final EventStore store;
+
+    public WorkInitializer(Executor executor, EventStore eventStore, WorkScheduler workScheduler, SynchronizationGuard synchronizationGuard) {
+        this.executor = executor;
+        this.store = eventStore;
+        this.scheduler = workScheduler;
+        this.guard = synchronizationGuard;
+    }
+
+    public void ensureContextsScheduled() {
+        this.executor.execute(new Runnable() { // from class: com.google.android.datatransport.runtime.scheduling.jobscheduling.WorkInitializer$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                WorkInitializer.this.lambda$ensureContextsScheduled$1();
+            }
+        });
+    }
+
+    public final /* synthetic */ void lambda$ensureContextsScheduled$1() {
+        this.guard.runCriticalSection(new SynchronizationGuard.CriticalSection() { // from class: com.google.android.datatransport.runtime.scheduling.jobscheduling.WorkInitializer$$ExternalSyntheticLambda1
+            @Override // com.google.android.datatransport.runtime.synchronization.SynchronizationGuard.CriticalSection
+            public final Object execute() {
+                Object lambda$ensureContextsScheduled$0;
+                lambda$ensureContextsScheduled$0 = WorkInitializer.this.lambda$ensureContextsScheduled$0();
+                return lambda$ensureContextsScheduled$0;
+            }
+        });
+    }
+
+    public final /* synthetic */ Object lambda$ensureContextsScheduled$0() {
+        Iterator it = this.store.loadActiveContexts().iterator();
+        while (it.hasNext()) {
+            this.scheduler.schedule((TransportContext) it.next(), 1);
+        }
+        return null;
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/jobscheduling/WorkInitializer_Factory.java

@@ -0,0 +1,35 @@
+package com.google.android.datatransport.runtime.scheduling.jobscheduling;
+
+import com.google.android.datatransport.runtime.dagger.internal.Factory;
+import com.google.android.datatransport.runtime.scheduling.persistence.EventStore;
+import com.google.android.datatransport.runtime.synchronization.SynchronizationGuard;
+import java.util.concurrent.Executor;
+import javax.inject.Provider;
+
+/* loaded from: classes2.dex */
+public final class WorkInitializer_Factory implements Factory {
+    public final Provider executorProvider;
+    public final Provider guardProvider;
+    public final Provider schedulerProvider;
+    public final Provider storeProvider;
+
+    public WorkInitializer_Factory(Provider provider, Provider provider2, Provider provider3, Provider provider4) {
+        this.executorProvider = provider;
+        this.storeProvider = provider2;
+        this.schedulerProvider = provider3;
+        this.guardProvider = provider4;
+    }
+
+    @Override // javax.inject.Provider
+    public WorkInitializer get() {
+        return newInstance((Executor) this.executorProvider.get(), (EventStore) this.storeProvider.get(), (WorkScheduler) this.schedulerProvider.get(), (SynchronizationGuard) this.guardProvider.get());
+    }
+
+    public static WorkInitializer_Factory create(Provider provider, Provider provider2, Provider provider3, Provider provider4) {
+        return new WorkInitializer_Factory(provider, provider2, provider3, provider4);
+    }
+
+    public static WorkInitializer newInstance(Executor executor, EventStore eventStore, WorkScheduler workScheduler, SynchronizationGuard synchronizationGuard) {
+        return new WorkInitializer(executor, eventStore, workScheduler, synchronizationGuard);
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/jobscheduling/WorkScheduler.java

@@ -0,0 +1,10 @@
+package com.google.android.datatransport.runtime.scheduling.jobscheduling;
+
+import com.google.android.datatransport.runtime.TransportContext;
+
+/* loaded from: classes2.dex */
+public interface WorkScheduler {
+    void schedule(TransportContext transportContext, int i);
+
+    void schedule(TransportContext transportContext, int i, boolean z);
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/persistence/AutoValue_EventStoreConfig.java

@@ -0,0 +1,129 @@
+package com.google.android.datatransport.runtime.scheduling.persistence;
+
+import com.google.android.datatransport.runtime.scheduling.persistence.EventStoreConfig;
+
+/* loaded from: classes2.dex */
+public final class AutoValue_EventStoreConfig extends EventStoreConfig {
+    public final int criticalSectionEnterTimeoutMs;
+    public final long eventCleanUpAge;
+    public final int loadBatchSize;
+    public final int maxBlobByteSizePerRow;
+    public final long maxStorageSizeInBytes;
+
+    @Override // com.google.android.datatransport.runtime.scheduling.persistence.EventStoreConfig
+    public int getCriticalSectionEnterTimeoutMs() {
+        return this.criticalSectionEnterTimeoutMs;
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.persistence.EventStoreConfig
+    public long getEventCleanUpAge() {
+        return this.eventCleanUpAge;
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.persistence.EventStoreConfig
+    public int getLoadBatchSize() {
+        return this.loadBatchSize;
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.persistence.EventStoreConfig
+    public int getMaxBlobByteSizePerRow() {
+        return this.maxBlobByteSizePerRow;
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.persistence.EventStoreConfig
+    public long getMaxStorageSizeInBytes() {
+        return this.maxStorageSizeInBytes;
+    }
+
+    public int hashCode() {
+        long j = this.maxStorageSizeInBytes;
+        int i = (((((((int) (j ^ (j >>> 32))) ^ 1000003) * 1000003) ^ this.loadBatchSize) * 1000003) ^ this.criticalSectionEnterTimeoutMs) * 1000003;
+        long j2 = this.eventCleanUpAge;
+        return ((i ^ ((int) ((j2 >>> 32) ^ j2))) * 1000003) ^ this.maxBlobByteSizePerRow;
+    }
+
+    public AutoValue_EventStoreConfig(long j, int i, int i2, long j2, int i3) {
+        this.maxStorageSizeInBytes = j;
+        this.loadBatchSize = i;
+        this.criticalSectionEnterTimeoutMs = i2;
+        this.eventCleanUpAge = j2;
+        this.maxBlobByteSizePerRow = i3;
+    }
+
+    public String toString() {
+        return "EventStoreConfig{maxStorageSizeInBytes=" + this.maxStorageSizeInBytes + ", loadBatchSize=" + this.loadBatchSize + ", criticalSectionEnterTimeoutMs=" + this.criticalSectionEnterTimeoutMs + ", eventCleanUpAge=" + this.eventCleanUpAge + ", maxBlobByteSizePerRow=" + this.maxBlobByteSizePerRow + "}";
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof EventStoreConfig)) {
+            return false;
+        }
+        EventStoreConfig eventStoreConfig = (EventStoreConfig) obj;
+        return this.maxStorageSizeInBytes == eventStoreConfig.getMaxStorageSizeInBytes() && this.loadBatchSize == eventStoreConfig.getLoadBatchSize() && this.criticalSectionEnterTimeoutMs == eventStoreConfig.getCriticalSectionEnterTimeoutMs() && this.eventCleanUpAge == eventStoreConfig.getEventCleanUpAge() && this.maxBlobByteSizePerRow == eventStoreConfig.getMaxBlobByteSizePerRow();
+    }
+
+    public static final class Builder extends EventStoreConfig.Builder {
+        public Integer criticalSectionEnterTimeoutMs;
+        public Long eventCleanUpAge;
+        public Integer loadBatchSize;
+        public Integer maxBlobByteSizePerRow;
+        public Long maxStorageSizeInBytes;
+
+        @Override // com.google.android.datatransport.runtime.scheduling.persistence.EventStoreConfig.Builder
+        public EventStoreConfig.Builder setMaxStorageSizeInBytes(long j) {
+            this.maxStorageSizeInBytes = Long.valueOf(j);
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.scheduling.persistence.EventStoreConfig.Builder
+        public EventStoreConfig.Builder setLoadBatchSize(int i) {
+            this.loadBatchSize = Integer.valueOf(i);
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.scheduling.persistence.EventStoreConfig.Builder
+        public EventStoreConfig.Builder setCriticalSectionEnterTimeoutMs(int i) {
+            this.criticalSectionEnterTimeoutMs = Integer.valueOf(i);
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.scheduling.persistence.EventStoreConfig.Builder
+        public EventStoreConfig.Builder setEventCleanUpAge(long j) {
+            this.eventCleanUpAge = Long.valueOf(j);
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.scheduling.persistence.EventStoreConfig.Builder
+        public EventStoreConfig.Builder setMaxBlobByteSizePerRow(int i) {
+            this.maxBlobByteSizePerRow = Integer.valueOf(i);
+            return this;
+        }
+
+        @Override // com.google.android.datatransport.runtime.scheduling.persistence.EventStoreConfig.Builder
+        public EventStoreConfig build() {
+            String str = "";
+            if (this.maxStorageSizeInBytes == null) {
+                str = " maxStorageSizeInBytes";
+            }
+            if (this.loadBatchSize == null) {
+                str = str + " loadBatchSize";
+            }
+            if (this.criticalSectionEnterTimeoutMs == null) {
+                str = str + " criticalSectionEnterTimeoutMs";
+            }
+            if (this.eventCleanUpAge == null) {
+                str = str + " eventCleanUpAge";
+            }
+            if (this.maxBlobByteSizePerRow == null) {
+                str = str + " maxBlobByteSizePerRow";
+            }
+            if (!str.isEmpty()) {
+                throw new IllegalStateException("Missing required properties:" + str);
+            }
+            return new AutoValue_EventStoreConfig(this.maxStorageSizeInBytes.longValue(), this.loadBatchSize.intValue(), this.criticalSectionEnterTimeoutMs.intValue(), this.eventCleanUpAge.longValue(), this.maxBlobByteSizePerRow.intValue());
+        }
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/persistence/AutoValue_PersistedEvent.java

@@ -0,0 +1,58 @@
+package com.google.android.datatransport.runtime.scheduling.persistence;
+
+import com.google.android.datatransport.runtime.EventInternal;
+import com.google.android.datatransport.runtime.TransportContext;
+
+/* loaded from: classes2.dex */
+public final class AutoValue_PersistedEvent extends PersistedEvent {
+    public final EventInternal event;
+    public final long id;
+    public final TransportContext transportContext;
+
+    @Override // com.google.android.datatransport.runtime.scheduling.persistence.PersistedEvent
+    public EventInternal getEvent() {
+        return this.event;
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.persistence.PersistedEvent
+    public long getId() {
+        return this.id;
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.persistence.PersistedEvent
+    public TransportContext getTransportContext() {
+        return this.transportContext;
+    }
+
+    public AutoValue_PersistedEvent(long j, TransportContext transportContext, EventInternal eventInternal) {
+        this.id = j;
+        if (transportContext == null) {
+            throw new NullPointerException("Null transportContext");
+        }
+        this.transportContext = transportContext;
+        if (eventInternal == null) {
+            throw new NullPointerException("Null event");
+        }
+        this.event = eventInternal;
+    }
+
+    public String toString() {
+        return "PersistedEvent{id=" + this.id + ", transportContext=" + this.transportContext + ", event=" + this.event + "}";
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof PersistedEvent)) {
+            return false;
+        }
+        PersistedEvent persistedEvent = (PersistedEvent) obj;
+        return this.id == persistedEvent.getId() && this.transportContext.equals(persistedEvent.getTransportContext()) && this.event.equals(persistedEvent.getEvent());
+    }
+
+    public int hashCode() {
+        long j = this.id;
+        return ((((((int) (j ^ (j >>> 32))) ^ 1000003) * 1000003) ^ this.transportContext.hashCode()) * 1000003) ^ this.event.hashCode();
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/persistence/ClientHealthMetricsStore.java

@@ -0,0 +1,13 @@
+package com.google.android.datatransport.runtime.scheduling.persistence;
+
+import com.google.android.datatransport.runtime.firebase.transport.ClientMetrics;
+import com.google.android.datatransport.runtime.firebase.transport.LogEventDropped;
+
+/* loaded from: classes2.dex */
+public interface ClientHealthMetricsStore {
+    ClientMetrics loadClientMetrics();
+
+    void recordLogEventDropped(long j, LogEventDropped.Reason reason, String str);
+
+    void resetClientMetrics();
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/persistence/EventStore.java

@@ -0,0 +1,26 @@
+package com.google.android.datatransport.runtime.scheduling.persistence;
+
+import com.google.android.datatransport.runtime.EventInternal;
+import com.google.android.datatransport.runtime.TransportContext;
+import java.io.Closeable;
+
+/* loaded from: classes2.dex */
+public interface EventStore extends Closeable {
+    int cleanUp();
+
+    long getNextCallTime(TransportContext transportContext);
+
+    boolean hasPendingEventsFor(TransportContext transportContext);
+
+    Iterable loadActiveContexts();
+
+    Iterable loadBatch(TransportContext transportContext);
+
+    PersistedEvent persist(TransportContext transportContext, EventInternal eventInternal);
+
+    void recordFailure(Iterable iterable);
+
+    void recordNextCallTime(TransportContext transportContext, long j);
+
+    void recordSuccess(Iterable iterable);
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/persistence/EventStoreConfig.java

@@ -0,0 +1,36 @@
+package com.google.android.datatransport.runtime.scheduling.persistence;
+
+import com.google.android.datatransport.runtime.scheduling.persistence.AutoValue_EventStoreConfig;
+
+/* loaded from: classes2.dex */
+public abstract class EventStoreConfig {
+    public static final EventStoreConfig DEFAULT = builder().setMaxStorageSizeInBytes(10485760).setLoadBatchSize(200).setCriticalSectionEnterTimeoutMs(10000).setEventCleanUpAge(604800000).setMaxBlobByteSizePerRow(81920).build();
+
+    public static abstract class Builder {
+        public abstract EventStoreConfig build();
+
+        public abstract Builder setCriticalSectionEnterTimeoutMs(int i);
+
+        public abstract Builder setEventCleanUpAge(long j);
+
+        public abstract Builder setLoadBatchSize(int i);
+
+        public abstract Builder setMaxBlobByteSizePerRow(int i);
+
+        public abstract Builder setMaxStorageSizeInBytes(long j);
+    }
+
+    public abstract int getCriticalSectionEnterTimeoutMs();
+
+    public abstract long getEventCleanUpAge();
+
+    public abstract int getLoadBatchSize();
+
+    public abstract int getMaxBlobByteSizePerRow();
+
+    public abstract long getMaxStorageSizeInBytes();
+
+    public static Builder builder() {
+        return new AutoValue_EventStoreConfig.Builder();
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/persistence/EventStoreModule.java

@@ -0,0 +1,22 @@
+package com.google.android.datatransport.runtime.scheduling.persistence;
+
+import android.content.Context;
+
+/* loaded from: classes2.dex */
+public abstract class EventStoreModule {
+    public static String dbName() {
+        return "com.google.android.datatransport.events";
+    }
+
+    public static EventStoreConfig storeConfig() {
+        return EventStoreConfig.DEFAULT;
+    }
+
+    public static int schemaVersion() {
+        return SchemaManager.SCHEMA_VERSION;
+    }
+
+    public static String packageName(Context context) {
+        return context.getPackageName();
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/persistence/EventStoreModule_DbNameFactory.java

@@ -0,0 +1,25 @@
+package com.google.android.datatransport.runtime.scheduling.persistence;
+
+import com.google.android.datatransport.runtime.dagger.internal.Factory;
+import com.google.android.datatransport.runtime.dagger.internal.Preconditions;
+
+/* loaded from: classes2.dex */
+public final class EventStoreModule_DbNameFactory implements Factory {
+
+    public static final class InstanceHolder {
+        public static final EventStoreModule_DbNameFactory INSTANCE = new EventStoreModule_DbNameFactory();
+    }
+
+    @Override // javax.inject.Provider
+    public String get() {
+        return dbName();
+    }
+
+    public static EventStoreModule_DbNameFactory create() {
+        return InstanceHolder.INSTANCE;
+    }
+
+    public static String dbName() {
+        return (String) Preconditions.checkNotNull(EventStoreModule.dbName(), "Cannot return null from a non-@Nullable @Provides method");
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/persistence/EventStoreModule_PackageNameFactory.java

@@ -0,0 +1,28 @@
+package com.google.android.datatransport.runtime.scheduling.persistence;
+
+import android.content.Context;
+import com.google.android.datatransport.runtime.dagger.internal.Factory;
+import com.google.android.datatransport.runtime.dagger.internal.Preconditions;
+import javax.inject.Provider;
+
+/* loaded from: classes2.dex */
+public final class EventStoreModule_PackageNameFactory implements Factory {
+    public final Provider contextProvider;
+
+    public EventStoreModule_PackageNameFactory(Provider provider) {
+        this.contextProvider = provider;
+    }
+
+    @Override // javax.inject.Provider
+    public String get() {
+        return packageName((Context) this.contextProvider.get());
+    }
+
+    public static EventStoreModule_PackageNameFactory create(Provider provider) {
+        return new EventStoreModule_PackageNameFactory(provider);
+    }
+
+    public static String packageName(Context context) {
+        return (String) Preconditions.checkNotNull(EventStoreModule.packageName(context), "Cannot return null from a non-@Nullable @Provides method");
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/persistence/EventStoreModule_SchemaVersionFactory.java

@@ -0,0 +1,24 @@
+package com.google.android.datatransport.runtime.scheduling.persistence;
+
+import com.google.android.datatransport.runtime.dagger.internal.Factory;
+
+/* loaded from: classes2.dex */
+public final class EventStoreModule_SchemaVersionFactory implements Factory {
+
+    public static final class InstanceHolder {
+        public static final EventStoreModule_SchemaVersionFactory INSTANCE = new EventStoreModule_SchemaVersionFactory();
+    }
+
+    @Override // javax.inject.Provider
+    public Integer get() {
+        return Integer.valueOf(schemaVersion());
+    }
+
+    public static EventStoreModule_SchemaVersionFactory create() {
+        return InstanceHolder.INSTANCE;
+    }
+
+    public static int schemaVersion() {
+        return EventStoreModule.schemaVersion();
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/persistence/EventStoreModule_StoreConfigFactory.java

@@ -0,0 +1,25 @@
+package com.google.android.datatransport.runtime.scheduling.persistence;
+
+import com.google.android.datatransport.runtime.dagger.internal.Factory;
+import com.google.android.datatransport.runtime.dagger.internal.Preconditions;
+
+/* loaded from: classes2.dex */
+public final class EventStoreModule_StoreConfigFactory implements Factory {
+
+    public static final class InstanceHolder {
+        public static final EventStoreModule_StoreConfigFactory INSTANCE = new EventStoreModule_StoreConfigFactory();
+    }
+
+    @Override // javax.inject.Provider
+    public EventStoreConfig get() {
+        return storeConfig();
+    }
+
+    public static EventStoreModule_StoreConfigFactory create() {
+        return InstanceHolder.INSTANCE;
+    }
+
+    public static EventStoreConfig storeConfig() {
+        return (EventStoreConfig) Preconditions.checkNotNull(EventStoreModule.storeConfig(), "Cannot return null from a non-@Nullable @Provides method");
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/persistence/PersistedEvent.java

@@ -0,0 +1,17 @@
+package com.google.android.datatransport.runtime.scheduling.persistence;
+
+import com.google.android.datatransport.runtime.EventInternal;
+import com.google.android.datatransport.runtime.TransportContext;
+
+/* loaded from: classes2.dex */
+public abstract class PersistedEvent {
+    public abstract EventInternal getEvent();
+
+    public abstract long getId();
+
+    public abstract TransportContext getTransportContext();
+
+    public static PersistedEvent create(long j, TransportContext transportContext, EventInternal eventInternal) {
+        return new AutoValue_PersistedEvent(j, transportContext, eventInternal);
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/persistence/SQLiteEventStore.java

@@ -0,0 +1,794 @@
+package com.google.android.datatransport.runtime.scheduling.persistence;
+
+import android.content.ContentValues;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteDatabaseLockedException;
+import android.os.SystemClock;
+import android.util.Base64;
+import com.facebook.gamingservices.cloudgaming.internal.SDKConstants;
+import com.google.android.datatransport.Encoding;
+import com.google.android.datatransport.Priority;
+import com.google.android.datatransport.runtime.EncodedPayload;
+import com.google.android.datatransport.runtime.EventInternal;
+import com.google.android.datatransport.runtime.TransportContext;
+import com.google.android.datatransport.runtime.firebase.transport.ClientMetrics;
+import com.google.android.datatransport.runtime.firebase.transport.GlobalMetrics;
+import com.google.android.datatransport.runtime.firebase.transport.LogEventDropped;
+import com.google.android.datatransport.runtime.firebase.transport.LogSourceMetrics;
+import com.google.android.datatransport.runtime.firebase.transport.StorageMetrics;
+import com.google.android.datatransport.runtime.firebase.transport.TimeWindow;
+import com.google.android.datatransport.runtime.logging.Logging;
+import com.google.android.datatransport.runtime.synchronization.SynchronizationException;
+import com.google.android.datatransport.runtime.synchronization.SynchronizationGuard;
+import com.google.android.datatransport.runtime.time.Clock;
+import com.google.android.datatransport.runtime.util.PriorityMapping;
+import com.unity3d.ads.core.domain.HandleInvocationsFromAdViewer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import javax.inject.Provider;
+
+/* loaded from: classes2.dex */
+public class SQLiteEventStore implements EventStore, SynchronizationGuard, ClientHealthMetricsStore {
+    public static final Encoding PROTOBUF_ENCODING = Encoding.of("proto");
+    public final EventStoreConfig config;
+    public final Clock monotonicClock;
+    public final Provider packageName;
+    public final SchemaManager schemaManager;
+    public final Clock wallClock;
+
+    public interface Function {
+        Object apply(Object obj);
+    }
+
+    public interface Producer {
+        Object produce();
+    }
+
+    public SQLiteEventStore(Clock clock, Clock clock2, EventStoreConfig eventStoreConfig, SchemaManager schemaManager, Provider provider) {
+        this.schemaManager = schemaManager;
+        this.wallClock = clock;
+        this.monotonicClock = clock2;
+        this.config = eventStoreConfig;
+        this.packageName = provider;
+    }
+
+    public SQLiteDatabase getDb() {
+        final SchemaManager schemaManager = this.schemaManager;
+        Objects.requireNonNull(schemaManager);
+        return (SQLiteDatabase) retryIfDbLocked(new Producer() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda1
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Producer
+            public final Object produce() {
+                return SchemaManager.this.getWritableDatabase();
+            }
+        }, new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda2
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                SQLiteDatabase lambda$getDb$0;
+                lambda$getDb$0 = SQLiteEventStore.lambda$getDb$0((Throwable) obj);
+                return lambda$getDb$0;
+            }
+        });
+    }
+
+    public static /* synthetic */ SQLiteDatabase lambda$getDb$0(Throwable th) {
+        throw new SynchronizationException("Timed out while trying to open db.", th);
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.persistence.EventStore
+    public PersistedEvent persist(final TransportContext transportContext, final EventInternal eventInternal) {
+        Logging.d("SQLiteEventStore", "Storing event with priority=%s, name=%s for destination %s", transportContext.getPriority(), eventInternal.getTransportName(), transportContext.getBackendName());
+        long longValue = ((Long) inTransaction(new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda6
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                Long lambda$persist$1;
+                lambda$persist$1 = SQLiteEventStore.this.lambda$persist$1(eventInternal, transportContext, (SQLiteDatabase) obj);
+                return lambda$persist$1;
+            }
+        })).longValue();
+        if (longValue < 1) {
+            return null;
+        }
+        return PersistedEvent.create(longValue, transportContext, eventInternal);
+    }
+
+    public final /* synthetic */ Long lambda$persist$1(EventInternal eventInternal, TransportContext transportContext, SQLiteDatabase sQLiteDatabase) {
+        if (isStorageAtLimit()) {
+            recordLogEventDropped(1L, LogEventDropped.Reason.CACHE_FULL, eventInternal.getTransportName());
+            return -1L;
+        }
+        long ensureTransportContext = ensureTransportContext(sQLiteDatabase, transportContext);
+        int maxBlobByteSizePerRow = this.config.getMaxBlobByteSizePerRow();
+        byte[] bytes = eventInternal.getEncodedPayload().getBytes();
+        boolean z = bytes.length <= maxBlobByteSizePerRow;
+        ContentValues contentValues = new ContentValues();
+        contentValues.put(SDKConstants.PARAM_CONTEXT_CONTEXT_ID, Long.valueOf(ensureTransportContext));
+        contentValues.put("transport_name", eventInternal.getTransportName());
+        contentValues.put("timestamp_ms", Long.valueOf(eventInternal.getEventMillis()));
+        contentValues.put("uptime_ms", Long.valueOf(eventInternal.getUptimeMillis()));
+        contentValues.put("payload_encoding", eventInternal.getEncodedPayload().getEncoding().getName());
+        contentValues.put("code", eventInternal.getCode());
+        contentValues.put("num_attempts", (Integer) 0);
+        contentValues.put("inline", Boolean.valueOf(z));
+        contentValues.put("payload", z ? bytes : new byte[0]);
+        long insert = sQLiteDatabase.insert("events", null, contentValues);
+        if (!z) {
+            int ceil = (int) Math.ceil(bytes.length / maxBlobByteSizePerRow);
+            for (int i = 1; i <= ceil; i++) {
+                byte[] copyOfRange = Arrays.copyOfRange(bytes, (i - 1) * maxBlobByteSizePerRow, Math.min(i * maxBlobByteSizePerRow, bytes.length));
+                ContentValues contentValues2 = new ContentValues();
+                contentValues2.put("event_id", Long.valueOf(insert));
+                contentValues2.put("sequence_num", Integer.valueOf(i));
+                contentValues2.put("bytes", copyOfRange);
+                sQLiteDatabase.insert("event_payloads", null, contentValues2);
+            }
+        }
+        for (Map.Entry entry : eventInternal.getMetadata().entrySet()) {
+            ContentValues contentValues3 = new ContentValues();
+            contentValues3.put("event_id", Long.valueOf(insert));
+            contentValues3.put("name", (String) entry.getKey());
+            contentValues3.put("value", (String) entry.getValue());
+            sQLiteDatabase.insert("event_metadata", null, contentValues3);
+        }
+        return Long.valueOf(insert);
+    }
+
+    public final long ensureTransportContext(SQLiteDatabase sQLiteDatabase, TransportContext transportContext) {
+        Long transportContextId = getTransportContextId(sQLiteDatabase, transportContext);
+        if (transportContextId != null) {
+            return transportContextId.longValue();
+        }
+        ContentValues contentValues = new ContentValues();
+        contentValues.put("backend_name", transportContext.getBackendName());
+        contentValues.put(HandleInvocationsFromAdViewer.KEY_DOWNLOAD_PRIORITY, Integer.valueOf(PriorityMapping.toInt(transportContext.getPriority())));
+        contentValues.put("next_request_ms", (Integer) 0);
+        if (transportContext.getExtras() != null) {
+            contentValues.put("extras", Base64.encodeToString(transportContext.getExtras(), 0));
+        }
+        return sQLiteDatabase.insert("transport_contexts", null, contentValues);
+    }
+
+    public final Long getTransportContextId(SQLiteDatabase sQLiteDatabase, TransportContext transportContext) {
+        StringBuilder sb = new StringBuilder("backend_name = ? and priority = ?");
+        ArrayList arrayList = new ArrayList(Arrays.asList(transportContext.getBackendName(), String.valueOf(PriorityMapping.toInt(transportContext.getPriority()))));
+        if (transportContext.getExtras() != null) {
+            sb.append(" and extras = ?");
+            arrayList.add(Base64.encodeToString(transportContext.getExtras(), 0));
+        } else {
+            sb.append(" and extras is null");
+        }
+        return (Long) tryWithCursor(sQLiteDatabase.query("transport_contexts", new String[]{"_id"}, sb.toString(), (String[]) arrayList.toArray(new String[0]), null, null, null), new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda16
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                Long lambda$getTransportContextId$2;
+                lambda$getTransportContextId$2 = SQLiteEventStore.lambda$getTransportContextId$2((Cursor) obj);
+                return lambda$getTransportContextId$2;
+            }
+        });
+    }
+
+    public static /* synthetic */ Long lambda$getTransportContextId$2(Cursor cursor) {
+        if (cursor.moveToNext()) {
+            return Long.valueOf(cursor.getLong(0));
+        }
+        return null;
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.persistence.EventStore
+    public void recordFailure(Iterable iterable) {
+        if (iterable.iterator().hasNext()) {
+            final String str = "UPDATE events SET num_attempts = num_attempts + 1 WHERE _id in " + toIdList(iterable);
+            final String str2 = "SELECT COUNT(*), transport_name FROM events WHERE num_attempts >= 16 GROUP BY transport_name";
+            inTransaction(new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda14
+                @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+                public final Object apply(Object obj) {
+                    Object lambda$recordFailure$4;
+                    lambda$recordFailure$4 = SQLiteEventStore.this.lambda$recordFailure$4(str, str2, (SQLiteDatabase) obj);
+                    return lambda$recordFailure$4;
+                }
+            });
+        }
+    }
+
+    public final /* synthetic */ Object lambda$recordFailure$4(String str, String str2, SQLiteDatabase sQLiteDatabase) {
+        sQLiteDatabase.compileStatement(str).execute();
+        tryWithCursor(sQLiteDatabase.rawQuery(str2, null), new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda20
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                Object lambda$recordFailure$3;
+                lambda$recordFailure$3 = SQLiteEventStore.this.lambda$recordFailure$3((Cursor) obj);
+                return lambda$recordFailure$3;
+            }
+        });
+        sQLiteDatabase.compileStatement("DELETE FROM events WHERE num_attempts >= 16").execute();
+        return null;
+    }
+
+    public final /* synthetic */ Object lambda$recordFailure$3(Cursor cursor) {
+        while (cursor.moveToNext()) {
+            recordLogEventDropped(cursor.getInt(0), LogEventDropped.Reason.MAX_RETRIES_REACHED, cursor.getString(1));
+        }
+        return null;
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.persistence.EventStore
+    public void recordSuccess(Iterable iterable) {
+        if (iterable.iterator().hasNext()) {
+            getDb().compileStatement("DELETE FROM events WHERE _id in " + toIdList(iterable)).execute();
+        }
+    }
+
+    public static String toIdList(Iterable iterable) {
+        StringBuilder sb = new StringBuilder("(");
+        Iterator it = iterable.iterator();
+        while (it.hasNext()) {
+            sb.append(((PersistedEvent) it.next()).getId());
+            if (it.hasNext()) {
+                sb.append(',');
+            }
+        }
+        sb.append(')');
+        return sb.toString();
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.persistence.EventStore
+    public long getNextCallTime(TransportContext transportContext) {
+        return ((Long) tryWithCursor(getDb().rawQuery("SELECT next_request_ms FROM transport_contexts WHERE backend_name = ? and priority = ?", new String[]{transportContext.getBackendName(), String.valueOf(PriorityMapping.toInt(transportContext.getPriority()))}), new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda3
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                Long lambda$getNextCallTime$5;
+                lambda$getNextCallTime$5 = SQLiteEventStore.lambda$getNextCallTime$5((Cursor) obj);
+                return lambda$getNextCallTime$5;
+            }
+        })).longValue();
+    }
+
+    public static /* synthetic */ Long lambda$getNextCallTime$5(Cursor cursor) {
+        if (cursor.moveToNext()) {
+            return Long.valueOf(cursor.getLong(0));
+        }
+        return 0L;
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.persistence.EventStore
+    public boolean hasPendingEventsFor(final TransportContext transportContext) {
+        return ((Boolean) inTransaction(new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda9
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                Boolean lambda$hasPendingEventsFor$6;
+                lambda$hasPendingEventsFor$6 = SQLiteEventStore.this.lambda$hasPendingEventsFor$6(transportContext, (SQLiteDatabase) obj);
+                return lambda$hasPendingEventsFor$6;
+            }
+        })).booleanValue();
+    }
+
+    public final /* synthetic */ Boolean lambda$hasPendingEventsFor$6(TransportContext transportContext, SQLiteDatabase sQLiteDatabase) {
+        Long transportContextId = getTransportContextId(sQLiteDatabase, transportContext);
+        return transportContextId == null ? Boolean.FALSE : (Boolean) tryWithCursor(getDb().rawQuery("SELECT 1 FROM events WHERE context_id = ? LIMIT 1", new String[]{transportContextId.toString()}), new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda22
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                return Boolean.valueOf(((Cursor) obj).moveToNext());
+            }
+        });
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.persistence.EventStore
+    public void recordNextCallTime(final TransportContext transportContext, final long j) {
+        inTransaction(new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda11
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                Object lambda$recordNextCallTime$7;
+                lambda$recordNextCallTime$7 = SQLiteEventStore.lambda$recordNextCallTime$7(j, transportContext, (SQLiteDatabase) obj);
+                return lambda$recordNextCallTime$7;
+            }
+        });
+    }
+
+    public static /* synthetic */ Object lambda$recordNextCallTime$7(long j, TransportContext transportContext, SQLiteDatabase sQLiteDatabase) {
+        ContentValues contentValues = new ContentValues();
+        contentValues.put("next_request_ms", Long.valueOf(j));
+        if (sQLiteDatabase.update("transport_contexts", contentValues, "backend_name = ? and priority = ?", new String[]{transportContext.getBackendName(), String.valueOf(PriorityMapping.toInt(transportContext.getPriority()))}) < 1) {
+            contentValues.put("backend_name", transportContext.getBackendName());
+            contentValues.put(HandleInvocationsFromAdViewer.KEY_DOWNLOAD_PRIORITY, Integer.valueOf(PriorityMapping.toInt(transportContext.getPriority())));
+            sQLiteDatabase.insert("transport_contexts", null, contentValues);
+        }
+        return null;
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.persistence.EventStore
+    public Iterable loadBatch(final TransportContext transportContext) {
+        return (Iterable) inTransaction(new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda13
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                List lambda$loadBatch$8;
+                lambda$loadBatch$8 = SQLiteEventStore.this.lambda$loadBatch$8(transportContext, (SQLiteDatabase) obj);
+                return lambda$loadBatch$8;
+            }
+        });
+    }
+
+    public final /* synthetic */ List lambda$loadBatch$8(TransportContext transportContext, SQLiteDatabase sQLiteDatabase) {
+        List loadEvents = loadEvents(sQLiteDatabase, transportContext, this.config.getLoadBatchSize());
+        for (Priority priority : Priority.values()) {
+            if (priority != transportContext.getPriority()) {
+                int loadBatchSize = this.config.getLoadBatchSize() - loadEvents.size();
+                if (loadBatchSize <= 0) {
+                    break;
+                }
+                loadEvents.addAll(loadEvents(sQLiteDatabase, transportContext.withPriority(priority), loadBatchSize));
+            }
+        }
+        return join(loadEvents, loadMetadata(sQLiteDatabase, loadEvents));
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.persistence.EventStore
+    public Iterable loadActiveContexts() {
+        return (Iterable) inTransaction(new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda0
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                List lambda$loadActiveContexts$10;
+                lambda$loadActiveContexts$10 = SQLiteEventStore.lambda$loadActiveContexts$10((SQLiteDatabase) obj);
+                return lambda$loadActiveContexts$10;
+            }
+        });
+    }
+
+    public static /* synthetic */ List lambda$loadActiveContexts$10(SQLiteDatabase sQLiteDatabase) {
+        return (List) tryWithCursor(sQLiteDatabase.rawQuery("SELECT distinct t._id, t.backend_name, t.priority, t.extras FROM transport_contexts AS t, events AS e WHERE e.context_id = t._id", new String[0]), new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda8
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                List lambda$loadActiveContexts$9;
+                lambda$loadActiveContexts$9 = SQLiteEventStore.lambda$loadActiveContexts$9((Cursor) obj);
+                return lambda$loadActiveContexts$9;
+            }
+        });
+    }
+
+    public static /* synthetic */ List lambda$loadActiveContexts$9(Cursor cursor) {
+        ArrayList arrayList = new ArrayList();
+        while (cursor.moveToNext()) {
+            arrayList.add(TransportContext.builder().setBackendName(cursor.getString(1)).setPriority(PriorityMapping.valueOf(cursor.getInt(2))).setExtras(maybeBase64Decode(cursor.getString(3))).build());
+        }
+        return arrayList;
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.persistence.EventStore
+    public int cleanUp() {
+        final long time = this.wallClock.getTime() - this.config.getEventCleanUpAge();
+        return ((Integer) inTransaction(new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda7
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                Integer lambda$cleanUp$12;
+                lambda$cleanUp$12 = SQLiteEventStore.this.lambda$cleanUp$12(time, (SQLiteDatabase) obj);
+                return lambda$cleanUp$12;
+            }
+        })).intValue();
+    }
+
+    public final /* synthetic */ Integer lambda$cleanUp$12(long j, SQLiteDatabase sQLiteDatabase) {
+        String[] strArr = {String.valueOf(j)};
+        tryWithCursor(sQLiteDatabase.rawQuery("SELECT COUNT(*), transport_name FROM events WHERE timestamp_ms < ? GROUP BY transport_name", strArr), new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda15
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                Object lambda$cleanUp$11;
+                lambda$cleanUp$11 = SQLiteEventStore.this.lambda$cleanUp$11((Cursor) obj);
+                return lambda$cleanUp$11;
+            }
+        });
+        return Integer.valueOf(sQLiteDatabase.delete("events", "timestamp_ms < ?", strArr));
+    }
+
+    public final /* synthetic */ Object lambda$cleanUp$11(Cursor cursor) {
+        while (cursor.moveToNext()) {
+            recordLogEventDropped(cursor.getInt(0), LogEventDropped.Reason.MESSAGE_TOO_OLD, cursor.getString(1));
+        }
+        return null;
+    }
+
+    @Override // java.io.Closeable, java.lang.AutoCloseable
+    public void close() {
+        this.schemaManager.close();
+    }
+
+    public static byte[] maybeBase64Decode(String str) {
+        if (str == null) {
+            return null;
+        }
+        return Base64.decode(str, 0);
+    }
+
+    public final List loadEvents(SQLiteDatabase sQLiteDatabase, final TransportContext transportContext, int i) {
+        final ArrayList arrayList = new ArrayList();
+        Long transportContextId = getTransportContextId(sQLiteDatabase, transportContext);
+        if (transportContextId == null) {
+            return arrayList;
+        }
+        tryWithCursor(sQLiteDatabase.query("events", new String[]{"_id", "transport_name", "timestamp_ms", "uptime_ms", "payload_encoding", "payload", "code", "inline"}, "context_id = ?", new String[]{transportContextId.toString()}, null, null, null, String.valueOf(i)), new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda21
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                Object lambda$loadEvents$14;
+                lambda$loadEvents$14 = SQLiteEventStore.this.lambda$loadEvents$14(arrayList, transportContext, (Cursor) obj);
+                return lambda$loadEvents$14;
+            }
+        });
+        return arrayList;
+    }
+
+    public final /* synthetic */ Object lambda$loadEvents$14(List list, TransportContext transportContext, Cursor cursor) {
+        while (cursor.moveToNext()) {
+            long j = cursor.getLong(0);
+            boolean z = cursor.getInt(7) != 0;
+            EventInternal.Builder uptimeMillis = EventInternal.builder().setTransportName(cursor.getString(1)).setEventMillis(cursor.getLong(2)).setUptimeMillis(cursor.getLong(3));
+            if (z) {
+                uptimeMillis.setEncodedPayload(new EncodedPayload(toEncoding(cursor.getString(4)), cursor.getBlob(5)));
+            } else {
+                uptimeMillis.setEncodedPayload(new EncodedPayload(toEncoding(cursor.getString(4)), readPayload(j)));
+            }
+            if (!cursor.isNull(6)) {
+                uptimeMillis.setCode(Integer.valueOf(cursor.getInt(6)));
+            }
+            list.add(PersistedEvent.create(j, transportContext, uptimeMillis.build()));
+        }
+        return null;
+    }
+
+    public final byte[] readPayload(long j) {
+        return (byte[]) tryWithCursor(getDb().query("event_payloads", new String[]{"bytes"}, "event_id = ?", new String[]{String.valueOf(j)}, null, null, "sequence_num"), new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda23
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                byte[] lambda$readPayload$15;
+                lambda$readPayload$15 = SQLiteEventStore.lambda$readPayload$15((Cursor) obj);
+                return lambda$readPayload$15;
+            }
+        });
+    }
+
+    public static /* synthetic */ byte[] lambda$readPayload$15(Cursor cursor) {
+        ArrayList arrayList = new ArrayList();
+        int i = 0;
+        while (cursor.moveToNext()) {
+            byte[] blob = cursor.getBlob(0);
+            arrayList.add(blob);
+            i += blob.length;
+        }
+        byte[] bArr = new byte[i];
+        int i2 = 0;
+        for (int i3 = 0; i3 < arrayList.size(); i3++) {
+            byte[] bArr2 = (byte[]) arrayList.get(i3);
+            System.arraycopy(bArr2, 0, bArr, i2, bArr2.length);
+            i2 += bArr2.length;
+        }
+        return bArr;
+    }
+
+    public static Encoding toEncoding(String str) {
+        return str == null ? PROTOBUF_ENCODING : Encoding.of(str);
+    }
+
+    public final Map loadMetadata(SQLiteDatabase sQLiteDatabase, List list) {
+        final HashMap hashMap = new HashMap();
+        StringBuilder sb = new StringBuilder("event_id IN (");
+        for (int i = 0; i < list.size(); i++) {
+            sb.append(((PersistedEvent) list.get(i)).getId());
+            if (i < list.size() - 1) {
+                sb.append(',');
+            }
+        }
+        sb.append(')');
+        tryWithCursor(sQLiteDatabase.query("event_metadata", new String[]{"event_id", "name", "value"}, sb.toString(), null, null, null, null), new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda17
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                Object lambda$loadMetadata$16;
+                lambda$loadMetadata$16 = SQLiteEventStore.lambda$loadMetadata$16(hashMap, (Cursor) obj);
+                return lambda$loadMetadata$16;
+            }
+        });
+        return hashMap;
+    }
+
+    public static /* synthetic */ Object lambda$loadMetadata$16(Map map, Cursor cursor) {
+        while (true) {
+            if (!cursor.moveToNext()) {
+                return null;
+            }
+            long j = cursor.getLong(0);
+            Set set = (Set) map.get(Long.valueOf(j));
+            if (set == null) {
+                set = new HashSet();
+                map.put(Long.valueOf(j), set);
+            }
+            set.add(new Metadata(cursor.getString(1), cursor.getString(2)));
+        }
+    }
+
+    public final List join(List list, Map map) {
+        ListIterator listIterator = list.listIterator();
+        while (listIterator.hasNext()) {
+            PersistedEvent persistedEvent = (PersistedEvent) listIterator.next();
+            if (map.containsKey(Long.valueOf(persistedEvent.getId()))) {
+                EventInternal.Builder builder = persistedEvent.getEvent().toBuilder();
+                for (Metadata metadata : (Set) map.get(Long.valueOf(persistedEvent.getId()))) {
+                    builder.addMetadata(metadata.key, metadata.value);
+                }
+                listIterator.set(PersistedEvent.create(persistedEvent.getId(), persistedEvent.getTransportContext(), builder.build()));
+            }
+        }
+        return list;
+    }
+
+    public final Object retryIfDbLocked(Producer producer, Function function) {
+        long time = this.monotonicClock.getTime();
+        while (true) {
+            try {
+                return producer.produce();
+            } catch (SQLiteDatabaseLockedException e) {
+                if (this.monotonicClock.getTime() >= this.config.getCriticalSectionEnterTimeoutMs() + time) {
+                    return function.apply(e);
+                }
+                SystemClock.sleep(50L);
+            }
+        }
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.persistence.ClientHealthMetricsStore
+    public void recordLogEventDropped(final long j, final LogEventDropped.Reason reason, final String str) {
+        inTransaction(new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda10
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                Object lambda$recordLogEventDropped$18;
+                lambda$recordLogEventDropped$18 = SQLiteEventStore.lambda$recordLogEventDropped$18(str, reason, j, (SQLiteDatabase) obj);
+                return lambda$recordLogEventDropped$18;
+            }
+        });
+    }
+
+    public static /* synthetic */ Object lambda$recordLogEventDropped$18(String str, LogEventDropped.Reason reason, long j, SQLiteDatabase sQLiteDatabase) {
+        if (!((Boolean) tryWithCursor(sQLiteDatabase.rawQuery("SELECT 1 FROM log_event_dropped WHERE log_source = ? AND reason = ?", new String[]{str, Integer.toString(reason.getNumber())}), new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda19
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                Boolean lambda$recordLogEventDropped$17;
+                lambda$recordLogEventDropped$17 = SQLiteEventStore.lambda$recordLogEventDropped$17((Cursor) obj);
+                return lambda$recordLogEventDropped$17;
+            }
+        })).booleanValue()) {
+            ContentValues contentValues = new ContentValues();
+            contentValues.put("log_source", str);
+            contentValues.put("reason", Integer.valueOf(reason.getNumber()));
+            contentValues.put("events_dropped_count", Long.valueOf(j));
+            sQLiteDatabase.insert("log_event_dropped", null, contentValues);
+        } else {
+            sQLiteDatabase.execSQL("UPDATE log_event_dropped SET events_dropped_count = events_dropped_count + " + j + " WHERE log_source = ? AND reason = ?", new String[]{str, Integer.toString(reason.getNumber())});
+        }
+        return null;
+    }
+
+    public static /* synthetic */ Boolean lambda$recordLogEventDropped$17(Cursor cursor) {
+        return Boolean.valueOf(cursor.getCount() > 0);
+    }
+
+    public final LogEventDropped.Reason convertToReason(int i) {
+        LogEventDropped.Reason reason = LogEventDropped.Reason.REASON_UNKNOWN;
+        if (i == reason.getNumber()) {
+            return reason;
+        }
+        LogEventDropped.Reason reason2 = LogEventDropped.Reason.MESSAGE_TOO_OLD;
+        if (i == reason2.getNumber()) {
+            return reason2;
+        }
+        LogEventDropped.Reason reason3 = LogEventDropped.Reason.CACHE_FULL;
+        if (i == reason3.getNumber()) {
+            return reason3;
+        }
+        LogEventDropped.Reason reason4 = LogEventDropped.Reason.PAYLOAD_TOO_BIG;
+        if (i == reason4.getNumber()) {
+            return reason4;
+        }
+        LogEventDropped.Reason reason5 = LogEventDropped.Reason.MAX_RETRIES_REACHED;
+        if (i == reason5.getNumber()) {
+            return reason5;
+        }
+        LogEventDropped.Reason reason6 = LogEventDropped.Reason.INVALID_PAYLOD;
+        if (i == reason6.getNumber()) {
+            return reason6;
+        }
+        LogEventDropped.Reason reason7 = LogEventDropped.Reason.SERVER_ERROR;
+        if (i == reason7.getNumber()) {
+            return reason7;
+        }
+        Logging.d("SQLiteEventStore", "%n is not valid. No matched LogEventDropped-Reason found. Treated it as REASON_UNKNOWN", Integer.valueOf(i));
+        return reason;
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.persistence.ClientHealthMetricsStore
+    public ClientMetrics loadClientMetrics() {
+        final ClientMetrics.Builder newBuilder = ClientMetrics.newBuilder();
+        final HashMap hashMap = new HashMap();
+        final String str = "SELECT log_source, reason, events_dropped_count FROM log_event_dropped";
+        return (ClientMetrics) inTransaction(new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda18
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                ClientMetrics lambda$loadClientMetrics$20;
+                lambda$loadClientMetrics$20 = SQLiteEventStore.this.lambda$loadClientMetrics$20(str, hashMap, newBuilder, (SQLiteDatabase) obj);
+                return lambda$loadClientMetrics$20;
+            }
+        });
+    }
+
+    public final /* synthetic */ ClientMetrics lambda$loadClientMetrics$20(String str, final Map map, final ClientMetrics.Builder builder, SQLiteDatabase sQLiteDatabase) {
+        return (ClientMetrics) tryWithCursor(sQLiteDatabase.rawQuery(str, new String[0]), new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda24
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                ClientMetrics lambda$loadClientMetrics$19;
+                lambda$loadClientMetrics$19 = SQLiteEventStore.this.lambda$loadClientMetrics$19(map, builder, (Cursor) obj);
+                return lambda$loadClientMetrics$19;
+            }
+        });
+    }
+
+    public final /* synthetic */ ClientMetrics lambda$loadClientMetrics$19(Map map, ClientMetrics.Builder builder, Cursor cursor) {
+        while (cursor.moveToNext()) {
+            String string = cursor.getString(0);
+            LogEventDropped.Reason convertToReason = convertToReason(cursor.getInt(1));
+            long j = cursor.getLong(2);
+            if (!map.containsKey(string)) {
+                map.put(string, new ArrayList());
+            }
+            ((List) map.get(string)).add(LogEventDropped.newBuilder().setReason(convertToReason).setEventsDroppedCount(j).build());
+        }
+        populateLogSourcesMetrics(builder, map);
+        builder.setWindow(getTimeWindow());
+        builder.setGlobalMetrics(getGlobalMetrics());
+        builder.setAppNamespace((String) this.packageName.get());
+        return builder.build();
+    }
+
+    public final void populateLogSourcesMetrics(ClientMetrics.Builder builder, Map map) {
+        for (Map.Entry entry : map.entrySet()) {
+            builder.addLogSourceMetrics(LogSourceMetrics.newBuilder().setLogSource((String) entry.getKey()).setLogEventDroppedList((List) entry.getValue()).build());
+        }
+    }
+
+    public final TimeWindow getTimeWindow() {
+        final long time = this.wallClock.getTime();
+        return (TimeWindow) inTransaction(new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda25
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                TimeWindow lambda$getTimeWindow$22;
+                lambda$getTimeWindow$22 = SQLiteEventStore.lambda$getTimeWindow$22(time, (SQLiteDatabase) obj);
+                return lambda$getTimeWindow$22;
+            }
+        });
+    }
+
+    public static /* synthetic */ TimeWindow lambda$getTimeWindow$22(final long j, SQLiteDatabase sQLiteDatabase) {
+        return (TimeWindow) tryWithCursor(sQLiteDatabase.rawQuery("SELECT last_metrics_upload_ms FROM global_log_event_state LIMIT 1", new String[0]), new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda26
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                TimeWindow lambda$getTimeWindow$21;
+                lambda$getTimeWindow$21 = SQLiteEventStore.lambda$getTimeWindow$21(j, (Cursor) obj);
+                return lambda$getTimeWindow$21;
+            }
+        });
+    }
+
+    public static /* synthetic */ TimeWindow lambda$getTimeWindow$21(long j, Cursor cursor) {
+        cursor.moveToNext();
+        return TimeWindow.newBuilder().setStartMs(cursor.getLong(0)).setEndMs(j).build();
+    }
+
+    public final GlobalMetrics getGlobalMetrics() {
+        return GlobalMetrics.newBuilder().setStorageMetrics(StorageMetrics.newBuilder().setCurrentCacheSizeBytes(getByteSize()).setMaxCacheSizeBytes(EventStoreConfig.DEFAULT.getMaxStorageSizeInBytes()).build()).build();
+    }
+
+    @Override // com.google.android.datatransport.runtime.scheduling.persistence.ClientHealthMetricsStore
+    public void resetClientMetrics() {
+        inTransaction(new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda12
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                Object lambda$resetClientMetrics$23;
+                lambda$resetClientMetrics$23 = SQLiteEventStore.this.lambda$resetClientMetrics$23((SQLiteDatabase) obj);
+                return lambda$resetClientMetrics$23;
+            }
+        });
+    }
+
+    public final /* synthetic */ Object lambda$resetClientMetrics$23(SQLiteDatabase sQLiteDatabase) {
+        sQLiteDatabase.compileStatement("DELETE FROM log_event_dropped").execute();
+        sQLiteDatabase.compileStatement("UPDATE global_log_event_state SET last_metrics_upload_ms=" + this.wallClock.getTime()).execute();
+        return null;
+    }
+
+    public final void ensureBeginTransaction(final SQLiteDatabase sQLiteDatabase) {
+        retryIfDbLocked(new Producer() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda4
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Producer
+            public final Object produce() {
+                Object lambda$ensureBeginTransaction$24;
+                lambda$ensureBeginTransaction$24 = SQLiteEventStore.lambda$ensureBeginTransaction$24(sQLiteDatabase);
+                return lambda$ensureBeginTransaction$24;
+            }
+        }, new Function() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore$$ExternalSyntheticLambda5
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore.Function
+            public final Object apply(Object obj) {
+                Object lambda$ensureBeginTransaction$25;
+                lambda$ensureBeginTransaction$25 = SQLiteEventStore.lambda$ensureBeginTransaction$25((Throwable) obj);
+                return lambda$ensureBeginTransaction$25;
+            }
+        });
+    }
+
+    public static /* synthetic */ Object lambda$ensureBeginTransaction$24(SQLiteDatabase sQLiteDatabase) {
+        sQLiteDatabase.beginTransaction();
+        return null;
+    }
+
+    public static /* synthetic */ Object lambda$ensureBeginTransaction$25(Throwable th) {
+        throw new SynchronizationException("Timed out while trying to acquire the lock.", th);
+    }
+
+    @Override // com.google.android.datatransport.runtime.synchronization.SynchronizationGuard
+    public Object runCriticalSection(SynchronizationGuard.CriticalSection criticalSection) {
+        SQLiteDatabase db = getDb();
+        ensureBeginTransaction(db);
+        try {
+            Object execute = criticalSection.execute();
+            db.setTransactionSuccessful();
+            return execute;
+        } finally {
+            db.endTransaction();
+        }
+    }
+
+    public Object inTransaction(Function function) {
+        SQLiteDatabase db = getDb();
+        db.beginTransaction();
+        try {
+            Object apply = function.apply(db);
+            db.setTransactionSuccessful();
+            return apply;
+        } finally {
+            db.endTransaction();
+        }
+    }
+
+    public static class Metadata {
+        public final String key;
+        public final String value;
+
+        public Metadata(String str, String str2) {
+            this.key = str;
+            this.value = str2;
+        }
+    }
+
+    public final boolean isStorageAtLimit() {
+        return getPageCount() * getPageSize() >= this.config.getMaxStorageSizeInBytes();
+    }
+
+    public long getByteSize() {
+        return getPageCount() * getPageSize();
+    }
+
+    public final long getPageSize() {
+        return getDb().compileStatement("PRAGMA page_size").simpleQueryForLong();
+    }
+
+    public final long getPageCount() {
+        return getDb().compileStatement("PRAGMA page_count").simpleQueryForLong();
+    }
+
+    public static Object tryWithCursor(Cursor cursor, Function function) {
+        try {
+            return function.apply(cursor);
+        } finally {
+            cursor.close();
+        }
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/persistence/SQLiteEventStore_Factory.java

@@ -0,0 +1,35 @@
+package com.google.android.datatransport.runtime.scheduling.persistence;
+
+import com.google.android.datatransport.runtime.dagger.internal.Factory;
+import com.google.android.datatransport.runtime.time.Clock;
+import javax.inject.Provider;
+
+/* loaded from: classes2.dex */
+public final class SQLiteEventStore_Factory implements Factory {
+    public final Provider clockProvider;
+    public final Provider configProvider;
+    public final Provider packageNameProvider;
+    public final Provider schemaManagerProvider;
+    public final Provider wallClockProvider;
+
+    public SQLiteEventStore_Factory(Provider provider, Provider provider2, Provider provider3, Provider provider4, Provider provider5) {
+        this.wallClockProvider = provider;
+        this.clockProvider = provider2;
+        this.configProvider = provider3;
+        this.schemaManagerProvider = provider4;
+        this.packageNameProvider = provider5;
+    }
+
+    @Override // javax.inject.Provider
+    public SQLiteEventStore get() {
+        return newInstance((Clock) this.wallClockProvider.get(), (Clock) this.clockProvider.get(), this.configProvider.get(), this.schemaManagerProvider.get(), this.packageNameProvider);
+    }
+
+    public static SQLiteEventStore_Factory create(Provider provider, Provider provider2, Provider provider3, Provider provider4, Provider provider5) {
+        return new SQLiteEventStore_Factory(provider, provider2, provider3, provider4, provider5);
+    }
+
+    public static SQLiteEventStore newInstance(Clock clock, Clock clock2, Object obj, Object obj2, Provider provider) {
+        return new SQLiteEventStore(clock, clock2, (EventStoreConfig) obj, (SchemaManager) obj2, provider);
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/persistence/SchemaManager.java

@@ -0,0 +1,156 @@
+package com.google.android.datatransport.runtime.scheduling.persistence;
+
+import android.content.Context;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import java.util.Arrays;
+import java.util.List;
+
+/* loaded from: classes2.dex */
+public final class SchemaManager extends SQLiteOpenHelper {
+    public static final List INCREMENTAL_MIGRATIONS;
+    public static final Migration MIGRATE_TO_V1;
+    public static final Migration MIGRATE_TO_V2;
+    public static final Migration MIGRATE_TO_V3;
+    public static final Migration MIGRATE_TO_V4;
+    public static final Migration MIGRATION_TO_V5;
+    public boolean configured;
+    public final int schemaVersion;
+    public static final String CREATE_INITIAL_GLOBAL_LOG_EVENT_STATE_VALUE_SQL = "INSERT INTO global_log_event_state VALUES (" + System.currentTimeMillis() + ")";
+    public static int SCHEMA_VERSION = 5;
+
+    public interface Migration {
+        void upgrade(SQLiteDatabase sQLiteDatabase);
+    }
+
+    static {
+        Migration migration = new Migration() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SchemaManager$$ExternalSyntheticLambda0
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SchemaManager.Migration
+            public final void upgrade(SQLiteDatabase sQLiteDatabase) {
+                SchemaManager.lambda$static$0(sQLiteDatabase);
+            }
+        };
+        MIGRATE_TO_V1 = migration;
+        Migration migration2 = new Migration() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SchemaManager$$ExternalSyntheticLambda1
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SchemaManager.Migration
+            public final void upgrade(SQLiteDatabase sQLiteDatabase) {
+                SchemaManager.lambda$static$1(sQLiteDatabase);
+            }
+        };
+        MIGRATE_TO_V2 = migration2;
+        Migration migration3 = new Migration() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SchemaManager$$ExternalSyntheticLambda2
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SchemaManager.Migration
+            public final void upgrade(SQLiteDatabase sQLiteDatabase) {
+                sQLiteDatabase.execSQL("ALTER TABLE events ADD COLUMN payload_encoding TEXT");
+            }
+        };
+        MIGRATE_TO_V3 = migration3;
+        Migration migration4 = new Migration() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SchemaManager$$ExternalSyntheticLambda3
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SchemaManager.Migration
+            public final void upgrade(SQLiteDatabase sQLiteDatabase) {
+                SchemaManager.lambda$static$3(sQLiteDatabase);
+            }
+        };
+        MIGRATE_TO_V4 = migration4;
+        Migration migration5 = new Migration() { // from class: com.google.android.datatransport.runtime.scheduling.persistence.SchemaManager$$ExternalSyntheticLambda4
+            @Override // com.google.android.datatransport.runtime.scheduling.persistence.SchemaManager.Migration
+            public final void upgrade(SQLiteDatabase sQLiteDatabase) {
+                SchemaManager.lambda$static$4(sQLiteDatabase);
+            }
+        };
+        MIGRATION_TO_V5 = migration5;
+        INCREMENTAL_MIGRATIONS = Arrays.asList(migration, migration2, migration3, migration4, migration5);
+    }
+
+    public static /* synthetic */ void lambda$static$0(SQLiteDatabase sQLiteDatabase) {
+        sQLiteDatabase.execSQL("CREATE TABLE events (_id INTEGER PRIMARY KEY, context_id INTEGER NOT NULL, transport_name TEXT NOT NULL, timestamp_ms INTEGER NOT NULL, uptime_ms INTEGER NOT NULL, payload BLOB NOT NULL, code INTEGER, num_attempts INTEGER NOT NULL,FOREIGN KEY (context_id) REFERENCES transport_contexts(_id) ON DELETE CASCADE)");
+        sQLiteDatabase.execSQL("CREATE TABLE event_metadata (_id INTEGER PRIMARY KEY, event_id INTEGER NOT NULL, name TEXT NOT NULL, value TEXT NOT NULL,FOREIGN KEY (event_id) REFERENCES events(_id) ON DELETE CASCADE)");
+        sQLiteDatabase.execSQL("CREATE TABLE transport_contexts (_id INTEGER PRIMARY KEY, backend_name TEXT NOT NULL, priority INTEGER NOT NULL, next_request_ms INTEGER NOT NULL)");
+        sQLiteDatabase.execSQL("CREATE INDEX events_backend_id on events(context_id)");
+        sQLiteDatabase.execSQL("CREATE UNIQUE INDEX contexts_backend_priority on transport_contexts(backend_name, priority)");
+    }
+
+    public static /* synthetic */ void lambda$static$1(SQLiteDatabase sQLiteDatabase) {
+        sQLiteDatabase.execSQL("ALTER TABLE transport_contexts ADD COLUMN extras BLOB");
+        sQLiteDatabase.execSQL("CREATE UNIQUE INDEX contexts_backend_priority_extras on transport_contexts(backend_name, priority, extras)");
+        sQLiteDatabase.execSQL("DROP INDEX contexts_backend_priority");
+    }
+
+    public static /* synthetic */ void lambda$static$3(SQLiteDatabase sQLiteDatabase) {
+        sQLiteDatabase.execSQL("ALTER TABLE events ADD COLUMN inline BOOLEAN NOT NULL DEFAULT 1");
+        sQLiteDatabase.execSQL("DROP TABLE IF EXISTS event_payloads");
+        sQLiteDatabase.execSQL("CREATE TABLE event_payloads (sequence_num INTEGER NOT NULL, event_id INTEGER NOT NULL, bytes BLOB NOT NULL,FOREIGN KEY (event_id) REFERENCES events(_id) ON DELETE CASCADE,PRIMARY KEY (sequence_num, event_id))");
+    }
+
+    public static /* synthetic */ void lambda$static$4(SQLiteDatabase sQLiteDatabase) {
+        sQLiteDatabase.execSQL("DROP TABLE IF EXISTS log_event_dropped");
+        sQLiteDatabase.execSQL("DROP TABLE IF EXISTS global_log_event_state");
+        sQLiteDatabase.execSQL("CREATE TABLE log_event_dropped (log_source VARCHAR(45) NOT NULL,reason INTEGER NOT NULL,events_dropped_count BIGINT NOT NULL,PRIMARY KEY(log_source, reason))");
+        sQLiteDatabase.execSQL("CREATE TABLE global_log_event_state (last_metrics_upload_ms BIGINT PRIMARY KEY)");
+        sQLiteDatabase.execSQL(CREATE_INITIAL_GLOBAL_LOG_EVENT_STATE_VALUE_SQL);
+    }
+
+    public SchemaManager(Context context, String str, int i) {
+        super(context, str, (SQLiteDatabase.CursorFactory) null, i);
+        this.configured = false;
+        this.schemaVersion = i;
+    }
+
+    @Override // android.database.sqlite.SQLiteOpenHelper
+    public void onConfigure(SQLiteDatabase sQLiteDatabase) {
+        this.configured = true;
+        sQLiteDatabase.rawQuery("PRAGMA busy_timeout=0;", new String[0]).close();
+        sQLiteDatabase.setForeignKeyConstraintsEnabled(true);
+    }
+
+    public final void ensureConfigured(SQLiteDatabase sQLiteDatabase) {
+        if (this.configured) {
+            return;
+        }
+        onConfigure(sQLiteDatabase);
+    }
+
+    @Override // android.database.sqlite.SQLiteOpenHelper
+    public void onCreate(SQLiteDatabase sQLiteDatabase) {
+        onCreate(sQLiteDatabase, this.schemaVersion);
+    }
+
+    public final void onCreate(SQLiteDatabase sQLiteDatabase, int i) {
+        ensureConfigured(sQLiteDatabase);
+        upgrade(sQLiteDatabase, 0, i);
+    }
+
+    @Override // android.database.sqlite.SQLiteOpenHelper
+    public void onUpgrade(SQLiteDatabase sQLiteDatabase, int i, int i2) {
+        ensureConfigured(sQLiteDatabase);
+        upgrade(sQLiteDatabase, i, i2);
+    }
+
+    @Override // android.database.sqlite.SQLiteOpenHelper
+    public void onDowngrade(SQLiteDatabase sQLiteDatabase, int i, int i2) {
+        sQLiteDatabase.execSQL("DROP TABLE events");
+        sQLiteDatabase.execSQL("DROP TABLE event_metadata");
+        sQLiteDatabase.execSQL("DROP TABLE transport_contexts");
+        sQLiteDatabase.execSQL("DROP TABLE IF EXISTS event_payloads");
+        sQLiteDatabase.execSQL("DROP TABLE IF EXISTS log_event_dropped");
+        sQLiteDatabase.execSQL("DROP TABLE IF EXISTS global_log_event_state");
+        onCreate(sQLiteDatabase, i2);
+    }
+
+    @Override // android.database.sqlite.SQLiteOpenHelper
+    public void onOpen(SQLiteDatabase sQLiteDatabase) {
+        ensureConfigured(sQLiteDatabase);
+    }
+
+    public final void upgrade(SQLiteDatabase sQLiteDatabase, int i, int i2) {
+        List list = INCREMENTAL_MIGRATIONS;
+        if (i2 <= list.size()) {
+            while (i < i2) {
+                ((Migration) INCREMENTAL_MIGRATIONS.get(i)).upgrade(sQLiteDatabase);
+                i++;
+            }
+            return;
+        }
+        throw new IllegalArgumentException("Migration from " + i + " to " + i2 + " was requested, but cannot be performed. Only " + list.size() + " migrations are provided");
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/scheduling/persistence/SchemaManager_Factory.java

@@ -0,0 +1,31 @@
+package com.google.android.datatransport.runtime.scheduling.persistence;
+
+import android.content.Context;
+import com.google.android.datatransport.runtime.dagger.internal.Factory;
+import javax.inject.Provider;
+
+/* loaded from: classes2.dex */
+public final class SchemaManager_Factory implements Factory {
+    public final Provider contextProvider;
+    public final Provider dbNameProvider;
+    public final Provider schemaVersionProvider;
+
+    public SchemaManager_Factory(Provider provider, Provider provider2, Provider provider3) {
+        this.contextProvider = provider;
+        this.dbNameProvider = provider2;
+        this.schemaVersionProvider = provider3;
+    }
+
+    @Override // javax.inject.Provider
+    public SchemaManager get() {
+        return newInstance((Context) this.contextProvider.get(), (String) this.dbNameProvider.get(), ((Integer) this.schemaVersionProvider.get()).intValue());
+    }
+
+    public static SchemaManager_Factory create(Provider provider, Provider provider2, Provider provider3) {
+        return new SchemaManager_Factory(provider, provider2, provider3);
+    }
+
+    public static SchemaManager newInstance(Context context, String str, int i) {
+        return new SchemaManager(context, str, i);
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/synchronization/SynchronizationException.java

@@ -0,0 +1,8 @@
+package com.google.android.datatransport.runtime.synchronization;
+
+/* loaded from: classes2.dex */
+public class SynchronizationException extends RuntimeException {
+    public SynchronizationException(String str, Throwable th) {
+        super(str, th);
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/synchronization/SynchronizationGuard.java

@@ -0,0 +1,11 @@
+package com.google.android.datatransport.runtime.synchronization;
+
+/* loaded from: classes2.dex */
+public interface SynchronizationGuard {
+
+    public interface CriticalSection {
+        Object execute();
+    }
+
+    Object runCriticalSection(CriticalSection criticalSection);
+}

decompiled/sources/com/google/android/datatransport/runtime/time/Clock.java

@@ -0,0 +1,6 @@
+package com.google.android.datatransport.runtime.time;
+
+/* loaded from: classes2.dex */
+public interface Clock {
+    long getTime();
+}

decompiled/sources/com/google/android/datatransport/runtime/time/TimeModule.java

@@ -0,0 +1,12 @@
+package com.google.android.datatransport.runtime.time;
+
+/* loaded from: classes2.dex */
+public abstract class TimeModule {
+    public static Clock eventClock() {
+        return new WallTimeClock();
+    }
+
+    public static Clock uptimeClock() {
+        return new UptimeClock();
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/time/TimeModule_EventClockFactory.java

@@ -0,0 +1,25 @@
+package com.google.android.datatransport.runtime.time;
+
+import com.google.android.datatransport.runtime.dagger.internal.Factory;
+import com.google.android.datatransport.runtime.dagger.internal.Preconditions;
+
+/* loaded from: classes2.dex */
+public final class TimeModule_EventClockFactory implements Factory {
+
+    public static final class InstanceHolder {
+        public static final TimeModule_EventClockFactory INSTANCE = new TimeModule_EventClockFactory();
+    }
+
+    @Override // javax.inject.Provider
+    public Clock get() {
+        return eventClock();
+    }
+
+    public static TimeModule_EventClockFactory create() {
+        return InstanceHolder.INSTANCE;
+    }
+
+    public static Clock eventClock() {
+        return (Clock) Preconditions.checkNotNull(TimeModule.eventClock(), "Cannot return null from a non-@Nullable @Provides method");
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/time/TimeModule_UptimeClockFactory.java

@@ -0,0 +1,25 @@
+package com.google.android.datatransport.runtime.time;
+
+import com.google.android.datatransport.runtime.dagger.internal.Factory;
+import com.google.android.datatransport.runtime.dagger.internal.Preconditions;
+
+/* loaded from: classes2.dex */
+public final class TimeModule_UptimeClockFactory implements Factory {
+
+    public static final class InstanceHolder {
+        public static final TimeModule_UptimeClockFactory INSTANCE = new TimeModule_UptimeClockFactory();
+    }
+
+    @Override // javax.inject.Provider
+    public Clock get() {
+        return uptimeClock();
+    }
+
+    public static TimeModule_UptimeClockFactory create() {
+        return InstanceHolder.INSTANCE;
+    }
+
+    public static Clock uptimeClock() {
+        return (Clock) Preconditions.checkNotNull(TimeModule.uptimeClock(), "Cannot return null from a non-@Nullable @Provides method");
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/time/UptimeClock.java

@@ -0,0 +1,11 @@
+package com.google.android.datatransport.runtime.time;
+
+import android.os.SystemClock;
+
+/* loaded from: classes2.dex */
+public class UptimeClock implements Clock {
+    @Override // com.google.android.datatransport.runtime.time.Clock
+    public long getTime() {
+        return SystemClock.elapsedRealtime();
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/time/WallTimeClock.java

@@ -0,0 +1,9 @@
+package com.google.android.datatransport.runtime.time;
+
+/* loaded from: classes2.dex */
+public class WallTimeClock implements Clock {
+    @Override // com.google.android.datatransport.runtime.time.Clock
+    public long getTime() {
+        return System.currentTimeMillis();
+    }
+}

decompiled/sources/com/google/android/datatransport/runtime/util/PriorityMapping.java

@@ -0,0 +1,38 @@
+package com.google.android.datatransport.runtime.util;
+
+import android.util.SparseArray;
+import com.google.android.datatransport.Priority;
+import java.util.HashMap;
+
+/* loaded from: classes2.dex */
+public abstract class PriorityMapping {
+    public static HashMap PRIORITY_INT_MAP;
+    public static SparseArray PRIORITY_MAP = new SparseArray();
+
+    static {
+        HashMap hashMap = new HashMap();
+        PRIORITY_INT_MAP = hashMap;
+        hashMap.put(Priority.DEFAULT, 0);
+        PRIORITY_INT_MAP.put(Priority.VERY_LOW, 1);
+        PRIORITY_INT_MAP.put(Priority.HIGHEST, 2);
+        for (Priority priority : PRIORITY_INT_MAP.keySet()) {
+            PRIORITY_MAP.append(((Integer) PRIORITY_INT_MAP.get(priority)).intValue(), priority);
+        }
+    }
+
+    public static Priority valueOf(int i) {
+        Priority priority = (Priority) PRIORITY_MAP.get(i);
+        if (priority != null) {
+            return priority;
+        }
+        throw new IllegalArgumentException("Unknown Priority for value " + i);
+    }
+
+    public static int toInt(Priority priority) {
+        Integer num = (Integer) PRIORITY_INT_MAP.get(priority);
+        if (num == null) {
+            throw new IllegalStateException("PriorityMapping is missing known Priority value " + priority);
+        }
+        return num.intValue();
+    }
+}