Initial commit

sources/io/fabric/sdk/android/services/events/DisabledEventsStrategy.java

@@ -0,0 +1,21 @@
+package io.fabric.sdk.android.services.events;
+
+/* loaded from: classes2.dex */
+public class DisabledEventsStrategy<T> implements EventsStrategy<T> {
+    @Override // io.fabric.sdk.android.services.events.EventsManager
+    public void a(T t) {
+    }
+
+    @Override // io.fabric.sdk.android.services.events.EventsManager
+    public void b() {
+    }
+
+    @Override // io.fabric.sdk.android.services.events.FileRollOverManager
+    public boolean c() {
+        return false;
+    }
+
+    @Override // io.fabric.sdk.android.services.events.FileRollOverManager
+    public void d() {
+    }
+}

sources/io/fabric/sdk/android/services/events/EnabledEventsStrategy.java

@@ -0,0 +1,117 @@
+package io.fabric.sdk.android.services.events;
+
+import android.content.Context;
+import io.fabric.sdk.android.services.common.CommonUtils;
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import java.util.Locale;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public abstract class EnabledEventsStrategy<T> implements EventsStrategy<T> {
+    protected final Context a;
+    protected final EventsFilesManager<T> b;
+    final ScheduledExecutorService c;
+    volatile int e = -1;
+    final AtomicReference<ScheduledFuture<?>> d = new AtomicReference<>();
+
+    public EnabledEventsStrategy(Context context, ScheduledExecutorService scheduledExecutorService, EventsFilesManager<T> eventsFilesManager) {
+        this.a = context;
+        this.c = scheduledExecutorService;
+        this.b = eventsFilesManager;
+    }
+
+    @Override // io.fabric.sdk.android.services.events.EventsManager
+    public void a(T t) {
+        CommonUtils.b(this.a, t.toString());
+        try {
+            this.b.a((EventsFilesManager<T>) t);
+        } catch (IOException e) {
+            CommonUtils.a(this.a, "Failed to write event.", e);
+        }
+        e();
+    }
+
+    @Override // io.fabric.sdk.android.services.events.EventsManager
+    public void b() {
+        f();
+    }
+
+    @Override // io.fabric.sdk.android.services.events.FileRollOverManager
+    public boolean c() {
+        try {
+            return this.b.f();
+        } catch (IOException e) {
+            CommonUtils.a(this.a, "Failed to roll file over.", e);
+            return false;
+        }
+    }
+
+    @Override // io.fabric.sdk.android.services.events.FileRollOverManager
+    public void d() {
+        if (this.d.get() != null) {
+            CommonUtils.b(this.a, "Cancelling time-based rollover because no events are currently being generated.");
+            this.d.get().cancel(false);
+            this.d.set(null);
+        }
+    }
+
+    public void e() {
+        if (this.e != -1) {
+            a(this.e, this.e);
+        }
+    }
+
+    void f() {
+        FilesSender a = a();
+        if (a == null) {
+            CommonUtils.b(this.a, "skipping files send because we don't yet know the target endpoint");
+            return;
+        }
+        CommonUtils.b(this.a, "Sending all files");
+        List<File> c = this.b.c();
+        int i = 0;
+        while (c.size() > 0) {
+            try {
+                CommonUtils.b(this.a, String.format(Locale.US, "attempt to send batch of %d files", Integer.valueOf(c.size())));
+                boolean a2 = a.a(c);
+                if (a2) {
+                    i += c.size();
+                    this.b.a(c);
+                }
+                if (!a2) {
+                    break;
+                } else {
+                    c = this.b.c();
+                }
+            } catch (Exception e) {
+                CommonUtils.a(this.a, "Failed to send batch of analytics files to server: " + e.getMessage(), e);
+            }
+        }
+        if (i == 0) {
+            this.b.a();
+        }
+    }
+
+    protected void a(int i) {
+        this.e = i;
+        a(0L, this.e);
+    }
+
+    void a(long j, long j2) {
+        if (this.d.get() == null) {
+            TimeBasedFileRollOverRunnable timeBasedFileRollOverRunnable = new TimeBasedFileRollOverRunnable(this.a, this);
+            CommonUtils.b(this.a, "Scheduling time based file roll over every " + j2 + " seconds");
+            try {
+                this.d.set(this.c.scheduleAtFixedRate(timeBasedFileRollOverRunnable, j, j2, TimeUnit.SECONDS));
+            } catch (RejectedExecutionException e) {
+                CommonUtils.a(this.a, "Failed to schedule time based file roll over", e);
+            }
+        }
+    }
+}

sources/io/fabric/sdk/android/services/events/EventTransform.java

@@ -0,0 +1,8 @@
+package io.fabric.sdk.android.services.events;
+
+import java.io.IOException;
+
+/* loaded from: classes2.dex */
+public interface EventTransform<T> {
+    byte[] a(T t) throws IOException;
+}

sources/io/fabric/sdk/android/services/events/EventsFilesManager.java

@@ -0,0 +1,149 @@
+package io.fabric.sdk.android.services.events;
+
+import android.content.Context;
+import io.fabric.sdk.android.services.common.CommonUtils;
+import io.fabric.sdk.android.services.common.CurrentTimeProvider;
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import java.util.TreeSet;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+/* loaded from: classes2.dex */
+public abstract class EventsFilesManager<T> {
+    protected final Context a;
+    protected final EventTransform<T> b;
+    protected final CurrentTimeProvider c;
+    protected final EventsStorage d;
+    private final int e;
+    protected final List<EventsStorageListener> f = new CopyOnWriteArrayList();
+
+    static class FileWithTimestamp {
+        final File a;
+        final long b;
+
+        public FileWithTimestamp(File file, long j) {
+            this.a = file;
+            this.b = j;
+        }
+    }
+
+    public EventsFilesManager(Context context, EventTransform<T> eventTransform, CurrentTimeProvider currentTimeProvider, EventsStorage eventsStorage, int i) throws IOException {
+        this.a = context.getApplicationContext();
+        this.b = eventTransform;
+        this.d = eventsStorage;
+        this.c = currentTimeProvider;
+        this.c.a();
+        this.e = i;
+    }
+
+    private void b(String str) {
+        Iterator<EventsStorageListener> it = this.f.iterator();
+        while (it.hasNext()) {
+            try {
+                it.next().a(str);
+            } catch (Exception e) {
+                CommonUtils.a(this.a, "One of the roll over listeners threw an exception", e);
+            }
+        }
+    }
+
+    public void a(T t) throws IOException {
+        byte[] a = this.b.a(t);
+        a(a.length);
+        this.d.a(a);
+    }
+
+    protected abstract String b();
+
+    public List<File> c() {
+        return this.d.a(1);
+    }
+
+    protected int d() {
+        return 8000;
+    }
+
+    protected int e() {
+        return this.e;
+    }
+
+    public boolean f() throws IOException {
+        String str;
+        boolean z = true;
+        if (this.d.b()) {
+            str = null;
+            z = false;
+        } else {
+            str = b();
+            this.d.a(str);
+            CommonUtils.a(this.a, 4, "Fabric", String.format(Locale.US, "generated new file %s", str));
+            this.c.a();
+        }
+        b(str);
+        return z;
+    }
+
+    public void a(EventsStorageListener eventsStorageListener) {
+        if (eventsStorageListener != null) {
+            this.f.add(eventsStorageListener);
+        }
+    }
+
+    private void a(int i) throws IOException {
+        if (this.d.a(i, d())) {
+            return;
+        }
+        CommonUtils.a(this.a, 4, "Fabric", String.format(Locale.US, "session analytics events file is %d bytes, new event is %d bytes, this is over flush limit of %d, rolling it over", Integer.valueOf(this.d.a()), Integer.valueOf(i), Integer.valueOf(d())));
+        f();
+    }
+
+    public void a(List<File> list) {
+        this.d.a(list);
+    }
+
+    public void a() {
+        List<File> c = this.d.c();
+        int e = e();
+        if (c.size() <= e) {
+            return;
+        }
+        int size = c.size() - e;
+        CommonUtils.b(this.a, String.format(Locale.US, "Found %d files in  roll over directory, this is greater than %d, deleting %d oldest files", Integer.valueOf(c.size()), Integer.valueOf(e), Integer.valueOf(size)));
+        TreeSet treeSet = new TreeSet(new Comparator<FileWithTimestamp>(this) { // from class: io.fabric.sdk.android.services.events.EventsFilesManager.1
+            @Override // java.util.Comparator
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public int compare(FileWithTimestamp fileWithTimestamp, FileWithTimestamp fileWithTimestamp2) {
+                return (int) (fileWithTimestamp.b - fileWithTimestamp2.b);
+            }
+        });
+        for (File file : c) {
+            treeSet.add(new FileWithTimestamp(file, a(file.getName())));
+        }
+        ArrayList arrayList = new ArrayList();
+        Iterator it = treeSet.iterator();
+        while (it.hasNext()) {
+            arrayList.add(((FileWithTimestamp) it.next()).a);
+            if (arrayList.size() == size) {
+                break;
+            }
+        }
+        this.d.a(arrayList);
+    }
+
+    public long a(String str) {
+        String[] split = str.split("_");
+        if (split.length != 3) {
+            return 0L;
+        }
+        try {
+            return Long.valueOf(split[2]).longValue();
+        } catch (NumberFormatException unused) {
+            return 0L;
+        }
+    }
+}

sources/io/fabric/sdk/android/services/events/EventsHandler.java

@@ -0,0 +1,58 @@
+package io.fabric.sdk.android.services.events;
+
+import android.content.Context;
+import io.fabric.sdk.android.services.common.CommonUtils;
+import java.util.concurrent.ScheduledExecutorService;
+
+/* loaded from: classes2.dex */
+public abstract class EventsHandler<T> implements EventsStorageListener {
+    protected final Context a;
+    protected final ScheduledExecutorService b;
+    protected EventsStrategy<T> c;
+
+    public EventsHandler(Context context, EventsStrategy<T> eventsStrategy, EventsFilesManager eventsFilesManager, ScheduledExecutorService scheduledExecutorService) {
+        this.a = context.getApplicationContext();
+        this.b = scheduledExecutorService;
+        this.c = eventsStrategy;
+        eventsFilesManager.a((EventsStorageListener) this);
+    }
+
+    public void a(final T t, final boolean z) {
+        a(new Runnable() { // from class: io.fabric.sdk.android.services.events.EventsHandler.1
+            /* JADX WARN: Multi-variable type inference failed */
+            @Override // java.lang.Runnable
+            public void run() {
+                try {
+                    EventsHandler.this.c.a(t);
+                    if (z) {
+                        EventsHandler.this.c.c();
+                    }
+                } catch (Exception e) {
+                    CommonUtils.a(EventsHandler.this.a, "Failed to record event.", e);
+                }
+            }
+        });
+    }
+
+    @Override // io.fabric.sdk.android.services.events.EventsStorageListener
+    public void a(String str) {
+        a(new Runnable() { // from class: io.fabric.sdk.android.services.events.EventsHandler.3
+            @Override // java.lang.Runnable
+            public void run() {
+                try {
+                    EventsHandler.this.c.b();
+                } catch (Exception e) {
+                    CommonUtils.a(EventsHandler.this.a, "Failed to send events files.", e);
+                }
+            }
+        });
+    }
+
+    protected void a(Runnable runnable) {
+        try {
+            this.b.submit(runnable);
+        } catch (Exception e) {
+            CommonUtils.a(this.a, "Failed to submit events task", e);
+        }
+    }
+}

sources/io/fabric/sdk/android/services/events/EventsManager.java

@@ -0,0 +1,8 @@
+package io.fabric.sdk.android.services.events;
+
+/* loaded from: classes2.dex */
+public interface EventsManager<T> {
+    void a(T t);
+
+    void b();
+}

sources/io/fabric/sdk/android/services/events/EventsStorage.java

@@ -0,0 +1,24 @@
+package io.fabric.sdk.android.services.events;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+
+/* loaded from: classes2.dex */
+public interface EventsStorage {
+    int a();
+
+    List<File> a(int i);
+
+    void a(String str) throws IOException;
+
+    void a(List<File> list);
+
+    void a(byte[] bArr) throws IOException;
+
+    boolean a(int i, int i2);
+
+    boolean b();
+
+    List<File> c();
+}

sources/io/fabric/sdk/android/services/events/EventsStorageListener.java

@@ -0,0 +1,6 @@
+package io.fabric.sdk.android.services.events;
+
+/* loaded from: classes2.dex */
+public interface EventsStorageListener {
+    void a(String str);
+}

sources/io/fabric/sdk/android/services/events/EventsStrategy.java

@@ -0,0 +1,6 @@
+package io.fabric.sdk.android.services.events;
+
+/* loaded from: classes2.dex */
+public interface EventsStrategy<T> extends FileRollOverManager, EventsManager<T> {
+    FilesSender a();
+}

sources/io/fabric/sdk/android/services/events/FileRollOverManager.java

@@ -0,0 +1,10 @@
+package io.fabric.sdk.android.services.events;
+
+import java.io.IOException;
+
+/* loaded from: classes2.dex */
+public interface FileRollOverManager {
+    boolean c() throws IOException;
+
+    void d();
+}

sources/io/fabric/sdk/android/services/events/FilesSender.java

@@ -0,0 +1,9 @@
+package io.fabric.sdk.android.services.events;
+
+import java.io.File;
+import java.util.List;
+
+/* loaded from: classes2.dex */
+public interface FilesSender {
+    boolean a(List<File> list);
+}

sources/io/fabric/sdk/android/services/events/QueueFileEventStorage.java

@@ -0,0 +1,122 @@
+package io.fabric.sdk.android.services.events;
+
+import android.content.Context;
+import com.ijm.dataencryption.de.DataDecryptTool;
+import io.fabric.sdk.android.services.common.CommonUtils;
+import io.fabric.sdk.android.services.common.QueueFile;
+import java.io.Closeable;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/* loaded from: classes2.dex */
+public class QueueFileEventStorage implements EventsStorage {
+    private final Context a;
+    private final File b;
+    private final String c;
+    private final File d;
+    private QueueFile e;
+    private File f;
+
+    public QueueFileEventStorage(Context context, File file, String str, String str2) throws IOException {
+        this.a = context;
+        this.b = file;
+        this.c = str2;
+        this.d = new File(this.b, str);
+        this.e = new QueueFile(this.d);
+        d();
+    }
+
+    private void d() {
+        this.f = new File(this.b, this.c);
+        if (this.f.exists()) {
+            return;
+        }
+        this.f.mkdirs();
+    }
+
+    @Override // io.fabric.sdk.android.services.events.EventsStorage
+    public void a(byte[] bArr) throws IOException {
+        this.e.a(bArr);
+    }
+
+    @Override // io.fabric.sdk.android.services.events.EventsStorage
+    public boolean b() {
+        return this.e.a();
+    }
+
+    @Override // io.fabric.sdk.android.services.events.EventsStorage
+    public List<File> c() {
+        return Arrays.asList(this.f.listFiles());
+    }
+
+    @Override // io.fabric.sdk.android.services.events.EventsStorage
+    public int a() {
+        return this.e.b();
+    }
+
+    @Override // io.fabric.sdk.android.services.events.EventsStorage
+    public void a(String str) throws IOException {
+        this.e.close();
+        a(this.d, new File(this.f, str));
+        this.e = new QueueFile(this.d);
+    }
+
+    private void a(File file, File file2) throws IOException {
+        FileInputStream fileInputStream;
+        OutputStream outputStream = null;
+        try {
+            fileInputStream = new FileInputStream(file);
+            try {
+                outputStream = a(file2);
+                CommonUtils.a(fileInputStream, outputStream, new byte[DataDecryptTool.DECRYPT_SP_FILE]);
+                CommonUtils.a((Closeable) fileInputStream, "Failed to close file input stream");
+                CommonUtils.a(outputStream, "Failed to close output stream");
+                file.delete();
+            } catch (Throwable th) {
+                th = th;
+                CommonUtils.a((Closeable) fileInputStream, "Failed to close file input stream");
+                CommonUtils.a(outputStream, "Failed to close output stream");
+                file.delete();
+                throw th;
+            }
+        } catch (Throwable th2) {
+            th = th2;
+            fileInputStream = null;
+        }
+    }
+
+    public OutputStream a(File file) throws IOException {
+        return new FileOutputStream(file);
+    }
+
+    @Override // io.fabric.sdk.android.services.events.EventsStorage
+    public List<File> a(int i) {
+        ArrayList arrayList = new ArrayList();
+        for (File file : this.f.listFiles()) {
+            arrayList.add(file);
+            if (arrayList.size() >= i) {
+                break;
+            }
+        }
+        return arrayList;
+    }
+
+    @Override // io.fabric.sdk.android.services.events.EventsStorage
+    public void a(List<File> list) {
+        for (File file : list) {
+            CommonUtils.b(this.a, String.format("deleting sent analytics file %s", file.getName()));
+            file.delete();
+        }
+    }
+
+    @Override // io.fabric.sdk.android.services.events.EventsStorage
+    public boolean a(int i, int i2) {
+        return this.e.a(i, i2);
+    }
+}

sources/io/fabric/sdk/android/services/events/TimeBasedFileRollOverRunnable.java

@@ -0,0 +1,28 @@
+package io.fabric.sdk.android.services.events;
+
+import android.content.Context;
+import io.fabric.sdk.android.services.common.CommonUtils;
+
+/* loaded from: classes2.dex */
+public class TimeBasedFileRollOverRunnable implements Runnable {
+    private final Context a;
+    private final FileRollOverManager b;
+
+    public TimeBasedFileRollOverRunnable(Context context, FileRollOverManager fileRollOverManager) {
+        this.a = context;
+        this.b = fileRollOverManager;
+    }
+
+    @Override // java.lang.Runnable
+    public void run() {
+        try {
+            CommonUtils.b(this.a, "Performing time based file roll over.");
+            if (this.b.c()) {
+                return;
+            }
+            this.b.d();
+        } catch (Exception e) {
+            CommonUtils.a(this.a, "Failed to roll over file", e);
+        }
+    }
+}