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/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);
+    }
+}