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/gms/common/data/AbstractDataBuffer.java

@@ -0,0 +1,75 @@
+package com.google.android.gms.common.data;
+
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import java.util.Iterator;
+
+/* loaded from: classes2.dex */
+public abstract class AbstractDataBuffer<T> implements DataBuffer<T> {
+
+    @Nullable
+    @KeepForSdk
+    protected final DataHolder mDataHolder;
+
+    @KeepForSdk
+    public AbstractDataBuffer(@Nullable DataHolder dataHolder) {
+        this.mDataHolder = dataHolder;
+    }
+
+    @Override // com.google.android.gms.common.data.DataBuffer, java.io.Closeable, java.lang.AutoCloseable
+    public final void close() {
+        release();
+    }
+
+    @Override // com.google.android.gms.common.data.DataBuffer
+    @NonNull
+    public abstract T get(int i);
+
+    @Override // com.google.android.gms.common.data.DataBuffer
+    public int getCount() {
+        DataHolder dataHolder = this.mDataHolder;
+        if (dataHolder == null) {
+            return 0;
+        }
+        return dataHolder.getCount();
+    }
+
+    @Override // com.google.android.gms.common.data.DataBuffer
+    @Nullable
+    public final Bundle getMetadata() {
+        DataHolder dataHolder = this.mDataHolder;
+        if (dataHolder == null) {
+            return null;
+        }
+        return dataHolder.getMetadata();
+    }
+
+    @Override // com.google.android.gms.common.data.DataBuffer
+    @Deprecated
+    public boolean isClosed() {
+        DataHolder dataHolder = this.mDataHolder;
+        return dataHolder == null || dataHolder.isClosed();
+    }
+
+    @Override // com.google.android.gms.common.data.DataBuffer, java.lang.Iterable
+    @NonNull
+    public Iterator<T> iterator() {
+        return new DataBufferIterator(this);
+    }
+
+    @Override // com.google.android.gms.common.data.DataBuffer, com.google.android.gms.common.api.Releasable
+    public void release() {
+        DataHolder dataHolder = this.mDataHolder;
+        if (dataHolder != null) {
+            dataHolder.close();
+        }
+    }
+
+    @Override // com.google.android.gms.common.data.DataBuffer
+    @NonNull
+    public Iterator<T> singleRefIterator() {
+        return new SingleRefDataBufferIterator(this);
+    }
+}

decompiled/sources/com/google/android/gms/common/data/BitmapTeleporter.java

@@ -0,0 +1,173 @@
+package com.google.android.gms.common.data;
+
+import android.graphics.Bitmap;
+import android.os.Parcel;
+import android.os.ParcelFileDescriptor;
+import android.os.Parcelable;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.internal.ReflectedParcelable;
+import com.google.android.gms.common.internal.ShowFirstParty;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+import com.google.android.gms.drive.DriveFile;
+import java.io.BufferedOutputStream;
+import java.io.Closeable;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+@ShowFirstParty
+@KeepForSdk
+@SafeParcelable.Class(creator = "BitmapTeleporterCreator")
+/* loaded from: classes2.dex */
+public class BitmapTeleporter extends AbstractSafeParcelable implements ReflectedParcelable {
+
+    @NonNull
+    @KeepForSdk
+    public static final Parcelable.Creator<BitmapTeleporter> CREATOR = new zaa();
+
+    @SafeParcelable.VersionField(id = 1)
+    final int zaa;
+
+    @Nullable
+    @SafeParcelable.Field(id = 2)
+    ParcelFileDescriptor zab;
+
+    @SafeParcelable.Field(id = 3)
+    final int zac;
+
+    @Nullable
+    private Bitmap zad;
+    private boolean zae;
+    private File zaf;
+
+    @SafeParcelable.Constructor
+    public BitmapTeleporter(@SafeParcelable.Param(id = 1) int i, @SafeParcelable.Param(id = 2) ParcelFileDescriptor parcelFileDescriptor, @SafeParcelable.Param(id = 3) int i2) {
+        this.zaa = i;
+        this.zab = parcelFileDescriptor;
+        this.zac = i2;
+        this.zad = null;
+        this.zae = false;
+    }
+
+    private static final void zaa(Closeable closeable) {
+        try {
+            closeable.close();
+        } catch (IOException e) {
+            Log.w("BitmapTeleporter", "Could not close stream", e);
+        }
+    }
+
+    @Nullable
+    @KeepForSdk
+    public Bitmap get() {
+        if (!this.zae) {
+            DataInputStream dataInputStream = new DataInputStream(new ParcelFileDescriptor.AutoCloseInputStream((ParcelFileDescriptor) Preconditions.checkNotNull(this.zab)));
+            try {
+                try {
+                    byte[] bArr = new byte[dataInputStream.readInt()];
+                    int readInt = dataInputStream.readInt();
+                    int readInt2 = dataInputStream.readInt();
+                    Bitmap.Config valueOf = Bitmap.Config.valueOf(dataInputStream.readUTF());
+                    dataInputStream.read(bArr);
+                    zaa(dataInputStream);
+                    ByteBuffer wrap = ByteBuffer.wrap(bArr);
+                    Bitmap createBitmap = Bitmap.createBitmap(readInt, readInt2, valueOf);
+                    createBitmap.copyPixelsFromBuffer(wrap);
+                    this.zad = createBitmap;
+                    this.zae = true;
+                } catch (IOException e) {
+                    throw new IllegalStateException("Could not read from parcel file descriptor", e);
+                }
+            } catch (Throwable th) {
+                zaa(dataInputStream);
+                throw th;
+            }
+        }
+        return this.zad;
+    }
+
+    @KeepForSdk
+    public void release() {
+        if (this.zae) {
+            return;
+        }
+        try {
+            ((ParcelFileDescriptor) Preconditions.checkNotNull(this.zab)).close();
+        } catch (IOException e) {
+            Log.w("BitmapTeleporter", "Could not close PFD", e);
+        }
+    }
+
+    @KeepForSdk
+    public void setTempDir(@NonNull File file) {
+        if (file == null) {
+            throw new NullPointerException("Cannot set null temp directory");
+        }
+        this.zaf = file;
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(@NonNull Parcel parcel, int i) {
+        if (this.zab == null) {
+            Bitmap bitmap = (Bitmap) Preconditions.checkNotNull(this.zad);
+            ByteBuffer allocate = ByteBuffer.allocate(bitmap.getRowBytes() * bitmap.getHeight());
+            bitmap.copyPixelsToBuffer(allocate);
+            byte[] array = allocate.array();
+            File file = this.zaf;
+            if (file == null) {
+                throw new IllegalStateException("setTempDir() must be called before writing this object to a parcel");
+            }
+            try {
+                File createTempFile = File.createTempFile("teleporter", ".tmp", file);
+                try {
+                    FileOutputStream fileOutputStream = new FileOutputStream(createTempFile);
+                    this.zab = ParcelFileDescriptor.open(createTempFile, DriveFile.MODE_READ_ONLY);
+                    createTempFile.delete();
+                    DataOutputStream dataOutputStream = new DataOutputStream(new BufferedOutputStream(fileOutputStream));
+                    try {
+                        try {
+                            dataOutputStream.writeInt(array.length);
+                            dataOutputStream.writeInt(bitmap.getWidth());
+                            dataOutputStream.writeInt(bitmap.getHeight());
+                            dataOutputStream.writeUTF(bitmap.getConfig().toString());
+                            dataOutputStream.write(array);
+                        } catch (IOException e) {
+                            throw new IllegalStateException("Could not write into unlinked file", e);
+                        }
+                    } finally {
+                        zaa(dataOutputStream);
+                    }
+                } catch (FileNotFoundException unused) {
+                    throw new IllegalStateException("Temporary file is somehow already deleted");
+                }
+            } catch (IOException e2) {
+                throw new IllegalStateException("Could not create temporary file", e2);
+            }
+        }
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeInt(parcel, 1, this.zaa);
+        SafeParcelWriter.writeParcelable(parcel, 2, this.zab, i | 1, false);
+        SafeParcelWriter.writeInt(parcel, 3, this.zac);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+        this.zab = null;
+    }
+
+    @KeepForSdk
+    public BitmapTeleporter(@NonNull Bitmap bitmap) {
+        this.zaa = 1;
+        this.zab = null;
+        this.zac = 0;
+        this.zad = bitmap;
+        this.zae = true;
+    }
+}

decompiled/sources/com/google/android/gms/common/data/DataBuffer.java

@@ -0,0 +1,35 @@
+package com.google.android.gms.common.data;
+
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.Releasable;
+import java.io.Closeable;
+import java.util.Iterator;
+
+/* loaded from: classes2.dex */
+public interface DataBuffer<T> extends Iterable<T>, Releasable, Closeable {
+    void close();
+
+    @NonNull
+    T get(int i);
+
+    int getCount();
+
+    @Nullable
+    @KeepForSdk
+    Bundle getMetadata();
+
+    @Deprecated
+    boolean isClosed();
+
+    @Override // java.lang.Iterable
+    @NonNull
+    Iterator<T> iterator();
+
+    void release();
+
+    @NonNull
+    Iterator<T> singleRefIterator();
+}

decompiled/sources/com/google/android/gms/common/data/DataBufferIterator.java

@@ -0,0 +1,42 @@
+package com.google.android.gms.common.data;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Preconditions;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class DataBufferIterator<T> implements Iterator<T> {
+
+    @NonNull
+    protected final DataBuffer zaa;
+    protected int zab = -1;
+
+    public DataBufferIterator(@NonNull DataBuffer dataBuffer) {
+        this.zaa = (DataBuffer) Preconditions.checkNotNull(dataBuffer);
+    }
+
+    @Override // java.util.Iterator
+    public final boolean hasNext() {
+        return this.zab < this.zaa.getCount() + (-1);
+    }
+
+    @Override // java.util.Iterator
+    @NonNull
+    public Object next() {
+        if (hasNext()) {
+            DataBuffer dataBuffer = this.zaa;
+            int i = this.zab + 1;
+            this.zab = i;
+            return dataBuffer.get(i);
+        }
+        throw new NoSuchElementException("Cannot advance the iterator beyond " + this.zab);
+    }
+
+    @Override // java.util.Iterator
+    public final void remove() {
+        throw new UnsupportedOperationException("Cannot remove elements from a DataBufferIterator");
+    }
+}

decompiled/sources/com/google/android/gms/common/data/DataBufferObserver.java

@@ -0,0 +1,23 @@
+package com.google.android.gms.common.data;
+
+import androidx.annotation.NonNull;
+
+/* loaded from: classes2.dex */
+public interface DataBufferObserver {
+
+    public interface Observable {
+        void addObserver(@NonNull DataBufferObserver dataBufferObserver);
+
+        void removeObserver(@NonNull DataBufferObserver dataBufferObserver);
+    }
+
+    void onDataChanged();
+
+    void onDataRangeChanged(int i, int i2);
+
+    void onDataRangeInserted(int i, int i2);
+
+    void onDataRangeMoved(int i, int i2, int i3);
+
+    void onDataRangeRemoved(int i, int i2);
+}

decompiled/sources/com/google/android/gms/common/data/DataBufferObserverSet.java

@@ -0,0 +1,69 @@
+package com.google.android.gms.common.data;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.data.DataBufferObserver;
+import java.util.HashSet;
+import java.util.Iterator;
+
+/* loaded from: classes2.dex */
+public final class DataBufferObserverSet implements DataBufferObserver, DataBufferObserver.Observable {
+    private final HashSet zaa = new HashSet();
+
+    @Override // com.google.android.gms.common.data.DataBufferObserver.Observable
+    public void addObserver(@NonNull DataBufferObserver dataBufferObserver) {
+        this.zaa.add(dataBufferObserver);
+    }
+
+    public void clear() {
+        this.zaa.clear();
+    }
+
+    public boolean hasObservers() {
+        return !this.zaa.isEmpty();
+    }
+
+    @Override // com.google.android.gms.common.data.DataBufferObserver
+    public void onDataChanged() {
+        Iterator it = this.zaa.iterator();
+        while (it.hasNext()) {
+            ((DataBufferObserver) it.next()).onDataChanged();
+        }
+    }
+
+    @Override // com.google.android.gms.common.data.DataBufferObserver
+    public void onDataRangeChanged(int i, int i2) {
+        Iterator it = this.zaa.iterator();
+        while (it.hasNext()) {
+            ((DataBufferObserver) it.next()).onDataRangeChanged(i, i2);
+        }
+    }
+
+    @Override // com.google.android.gms.common.data.DataBufferObserver
+    public void onDataRangeInserted(int i, int i2) {
+        Iterator it = this.zaa.iterator();
+        while (it.hasNext()) {
+            ((DataBufferObserver) it.next()).onDataRangeInserted(i, i2);
+        }
+    }
+
+    @Override // com.google.android.gms.common.data.DataBufferObserver
+    public void onDataRangeMoved(int i, int i2, int i3) {
+        Iterator it = this.zaa.iterator();
+        while (it.hasNext()) {
+            ((DataBufferObserver) it.next()).onDataRangeMoved(i, i2, i3);
+        }
+    }
+
+    @Override // com.google.android.gms.common.data.DataBufferObserver
+    public void onDataRangeRemoved(int i, int i2) {
+        Iterator it = this.zaa.iterator();
+        while (it.hasNext()) {
+            ((DataBufferObserver) it.next()).onDataRangeRemoved(i, i2);
+        }
+    }
+
+    @Override // com.google.android.gms.common.data.DataBufferObserver.Observable
+    public void removeObserver(@NonNull DataBufferObserver dataBufferObserver) {
+        this.zaa.remove(dataBufferObserver);
+    }
+}

decompiled/sources/com/google/android/gms/common/data/DataBufferRef.java

@@ -0,0 +1,126 @@
+package com.google.android.gms.common.data;
+
+import android.database.CharArrayBuffer;
+import android.net.Uri;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Objects;
+import com.google.android.gms.common.internal.Preconditions;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public abstract class DataBufferRef {
+
+    @NonNull
+    @KeepForSdk
+    protected final DataHolder mDataHolder;
+
+    @KeepForSdk
+    protected int mDataRow;
+    private int zaa;
+
+    @KeepForSdk
+    public DataBufferRef(@NonNull DataHolder dataHolder, int i) {
+        this.mDataHolder = (DataHolder) Preconditions.checkNotNull(dataHolder);
+        zaa(i);
+    }
+
+    @KeepForSdk
+    public void copyToBuffer(@NonNull String str, @NonNull CharArrayBuffer charArrayBuffer) {
+        this.mDataHolder.zac(str, this.mDataRow, this.zaa, charArrayBuffer);
+    }
+
+    @KeepForSdk
+    public boolean equals(@Nullable Object obj) {
+        if (obj instanceof DataBufferRef) {
+            DataBufferRef dataBufferRef = (DataBufferRef) obj;
+            if (Objects.equal(Integer.valueOf(dataBufferRef.mDataRow), Integer.valueOf(this.mDataRow)) && Objects.equal(Integer.valueOf(dataBufferRef.zaa), Integer.valueOf(this.zaa)) && dataBufferRef.mDataHolder == this.mDataHolder) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @KeepForSdk
+    public boolean getBoolean(@NonNull String str) {
+        return this.mDataHolder.getBoolean(str, this.mDataRow, this.zaa);
+    }
+
+    @NonNull
+    @KeepForSdk
+    public byte[] getByteArray(@NonNull String str) {
+        return this.mDataHolder.getByteArray(str, this.mDataRow, this.zaa);
+    }
+
+    @KeepForSdk
+    public int getDataRow() {
+        return this.mDataRow;
+    }
+
+    @KeepForSdk
+    public double getDouble(@NonNull String str) {
+        return this.mDataHolder.zaa(str, this.mDataRow, this.zaa);
+    }
+
+    @KeepForSdk
+    public float getFloat(@NonNull String str) {
+        return this.mDataHolder.zab(str, this.mDataRow, this.zaa);
+    }
+
+    @KeepForSdk
+    public int getInteger(@NonNull String str) {
+        return this.mDataHolder.getInteger(str, this.mDataRow, this.zaa);
+    }
+
+    @KeepForSdk
+    public long getLong(@NonNull String str) {
+        return this.mDataHolder.getLong(str, this.mDataRow, this.zaa);
+    }
+
+    @NonNull
+    @KeepForSdk
+    public String getString(@NonNull String str) {
+        return this.mDataHolder.getString(str, this.mDataRow, this.zaa);
+    }
+
+    @KeepForSdk
+    public boolean hasColumn(@NonNull String str) {
+        return this.mDataHolder.hasColumn(str);
+    }
+
+    @KeepForSdk
+    public boolean hasNull(@NonNull String str) {
+        return this.mDataHolder.hasNull(str, this.mDataRow, this.zaa);
+    }
+
+    @KeepForSdk
+    public int hashCode() {
+        return Objects.hashCode(Integer.valueOf(this.mDataRow), Integer.valueOf(this.zaa), this.mDataHolder);
+    }
+
+    @KeepForSdk
+    public boolean isDataValid() {
+        return !this.mDataHolder.isClosed();
+    }
+
+    @Nullable
+    @KeepForSdk
+    public Uri parseUri(@NonNull String str) {
+        String string = this.mDataHolder.getString(str, this.mDataRow, this.zaa);
+        if (string == null) {
+            return null;
+        }
+        return Uri.parse(string);
+    }
+
+    public final void zaa(int i) {
+        boolean z = false;
+        if (i >= 0 && i < this.mDataHolder.getCount()) {
+            z = true;
+        }
+        Preconditions.checkState(z);
+        this.mDataRow = i;
+        this.zaa = this.mDataHolder.getWindowIndex(i);
+    }
+}

decompiled/sources/com/google/android/gms/common/data/DataBufferSafeParcelable.java

@@ -0,0 +1,53 @@
+package com.google.android.gms.common.data;
+
+import android.content.ContentValues;
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.data.DataHolder;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class DataBufferSafeParcelable<T extends SafeParcelable> extends AbstractDataBuffer<T> {
+    private static final String[] zaa = {"data"};
+    private final Parcelable.Creator zab;
+
+    @KeepForSdk
+    public DataBufferSafeParcelable(@NonNull DataHolder dataHolder, @NonNull Parcelable.Creator<T> creator) {
+        super(dataHolder);
+        this.zab = creator;
+    }
+
+    @KeepForSdk
+    public static <T extends SafeParcelable> void addValue(@NonNull DataHolder.Builder builder, @NonNull T t) {
+        Parcel obtain = Parcel.obtain();
+        t.writeToParcel(obtain, 0);
+        ContentValues contentValues = new ContentValues();
+        contentValues.put("data", obtain.marshall());
+        builder.withRow(contentValues);
+        obtain.recycle();
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static DataHolder.Builder buildDataHolder() {
+        return DataHolder.builder(zaa);
+    }
+
+    @Override // com.google.android.gms.common.data.AbstractDataBuffer, com.google.android.gms.common.data.DataBuffer
+    @NonNull
+    @KeepForSdk
+    public T get(int i) {
+        DataHolder dataHolder = (DataHolder) Preconditions.checkNotNull(this.mDataHolder);
+        byte[] byteArray = dataHolder.getByteArray("data", i, dataHolder.getWindowIndex(i));
+        Parcel obtain = Parcel.obtain();
+        obtain.unmarshall(byteArray, 0, byteArray.length);
+        obtain.setDataPosition(0);
+        T t = (T) this.zab.createFromParcel(obtain);
+        obtain.recycle();
+        return t;
+    }
+}

decompiled/sources/com/google/android/gms/common/data/DataBufferUtils.java

@@ -0,0 +1,51 @@
+package com.google.android.gms.common.data;
+
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.ironsource.un;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+/* loaded from: classes2.dex */
+public final class DataBufferUtils {
+
+    @NonNull
+    @KeepForSdk
+    public static final String KEY_NEXT_PAGE_TOKEN = "next_page_token";
+
+    @NonNull
+    @KeepForSdk
+    public static final String KEY_PREV_PAGE_TOKEN = "prev_page_token";
+
+    private DataBufferUtils() {
+    }
+
+    @NonNull
+    public static <T, E extends Freezable<T>> ArrayList<T> freezeAndClose(@NonNull DataBuffer<E> dataBuffer) {
+        un.a aVar = (ArrayList<T>) new ArrayList(dataBuffer.getCount());
+        try {
+            Iterator<E> it = dataBuffer.iterator();
+            while (it.hasNext()) {
+                aVar.add(it.next().freeze());
+            }
+            return aVar;
+        } finally {
+            dataBuffer.close();
+        }
+    }
+
+    public static boolean hasData(@NonNull DataBuffer<?> dataBuffer) {
+        return dataBuffer != null && dataBuffer.getCount() > 0;
+    }
+
+    public static boolean hasNextPage(@NonNull DataBuffer<?> dataBuffer) {
+        Bundle metadata = dataBuffer.getMetadata();
+        return (metadata == null || metadata.getString(KEY_NEXT_PAGE_TOKEN) == null) ? false : true;
+    }
+
+    public static boolean hasPrevPage(@NonNull DataBuffer<?> dataBuffer) {
+        Bundle metadata = dataBuffer.getMetadata();
+        return (metadata == null || metadata.getString(KEY_PREV_PAGE_TOKEN) == null) ? false : true;
+    }
+}

decompiled/sources/com/google/android/gms/common/data/DataHolder.java

@@ -0,0 +1,437 @@
+package com.google.android.gms.common.data;
+
+import android.content.ContentValues;
+import android.database.CharArrayBuffer;
+import android.database.CursorIndexOutOfBoundsException;
+import android.database.CursorWindow;
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.annotation.KeepName;
+import com.google.android.gms.common.internal.Asserts;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+import java.io.Closeable;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+@KeepForSdk
+@KeepName
+@SafeParcelable.Class(creator = "DataHolderCreator", validate = true)
+/* loaded from: classes2.dex */
+public final class DataHolder extends AbstractSafeParcelable implements Closeable {
+
+    @NonNull
+    @KeepForSdk
+    public static final Parcelable.Creator<DataHolder> CREATOR = new zaf();
+    private static final Builder zaf = new zab(new String[0], null);
+
+    @SafeParcelable.VersionField(id = 1000)
+    final int zaa;
+    Bundle zab;
+    int[] zac;
+    int zad;
+    boolean zae;
+
+    @SafeParcelable.Field(getter = "getColumns", id = 1)
+    private final String[] zag;
+
+    @SafeParcelable.Field(getter = "getWindows", id = 2)
+    private final CursorWindow[] zah;
+
+    @SafeParcelable.Field(getter = "getStatusCode", id = 3)
+    private final int zai;
+
+    @Nullable
+    @SafeParcelable.Field(getter = "getMetadata", id = 4)
+    private final Bundle zaj;
+    private boolean zak;
+
+    @KeepForSdk
+    public static class Builder {
+        private final String[] zaa;
+        private final ArrayList zab = new ArrayList();
+        private final HashMap zac = new HashMap();
+
+        public /* synthetic */ Builder(String[] strArr, String str, zac zacVar) {
+            this.zaa = (String[]) Preconditions.checkNotNull(strArr);
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @NonNull
+        @KeepForSdk
+        public DataHolder build(int i) {
+            return new DataHolder(this, i);
+        }
+
+        @NonNull
+        @KeepForSdk
+        public Builder withRow(@NonNull ContentValues contentValues) {
+            Asserts.checkNotNull(contentValues);
+            HashMap hashMap = new HashMap(contentValues.size());
+            for (Map.Entry<String, Object> entry : contentValues.valueSet()) {
+                hashMap.put(entry.getKey(), entry.getValue());
+            }
+            return zaa(hashMap);
+        }
+
+        @NonNull
+        public Builder zaa(@NonNull HashMap hashMap) {
+            Asserts.checkNotNull(hashMap);
+            this.zab.add(hashMap);
+            return this;
+        }
+
+        @NonNull
+        @KeepForSdk
+        public DataHolder build(int i, @NonNull Bundle bundle) {
+            return new DataHolder(this, i, bundle);
+        }
+    }
+
+    @SafeParcelable.Constructor
+    public DataHolder(@SafeParcelable.Param(id = 1000) int i, @SafeParcelable.Param(id = 1) String[] strArr, @SafeParcelable.Param(id = 2) CursorWindow[] cursorWindowArr, @SafeParcelable.Param(id = 3) int i2, @Nullable @SafeParcelable.Param(id = 4) Bundle bundle) {
+        this.zae = false;
+        this.zak = true;
+        this.zaa = i;
+        this.zag = strArr;
+        this.zah = cursorWindowArr;
+        this.zai = i2;
+        this.zaj = bundle;
+    }
+
+    @KeepForSdk
+    public DataHolder(@NonNull String[] strArr, @NonNull CursorWindow[] cursorWindowArr, int i, @Nullable Bundle bundle) {
+        this.zae = false;
+        this.zak = true;
+        this.zaa = 1;
+        this.zag = (String[]) Preconditions.checkNotNull(strArr);
+        this.zah = (CursorWindow[]) Preconditions.checkNotNull(cursorWindowArr);
+        this.zai = i;
+        this.zaj = bundle;
+        zad();
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @NonNull
+    @KeepForSdk
+    public static Builder builder(@NonNull String[] strArr) {
+        return new Builder(strArr, null, 0 == true ? 1 : 0);
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static DataHolder empty(int i) {
+        return new DataHolder(zaf, i, (Bundle) null);
+    }
+
+    private final void zae(String str, int i) {
+        Bundle bundle = this.zab;
+        if (bundle == null || !bundle.containsKey(str)) {
+            throw new IllegalArgumentException("No such column: ".concat(String.valueOf(str)));
+        }
+        if (isClosed()) {
+            throw new IllegalArgumentException("Buffer is closed.");
+        }
+        if (i < 0 || i >= this.zad) {
+            throw new CursorIndexOutOfBoundsException(i, this.zad);
+        }
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:61:0x012f, code lost:
+    
+        if (r5 != false) goto L67;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:62:0x0131, code lost:
+    
+        r5 = new java.lang.StringBuilder();
+        r5.append("Couldn't populate window data for row ");
+        r5.append(r4);
+        r5.append(" - allocating new window.");
+        r2.freeLastRow();
+        r2 = new android.database.CursorWindow(false);
+        r2.setStartPosition(r4);
+        r2.setNumColumns(r12.zaa.length);
+        r3.add(r2);
+        r4 = r4 - 1;
+        r5 = true;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:64:0x015c, code lost:
+    
+        r4 = r4 + 1;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:67:0x0166, code lost:
+    
+        throw new com.google.android.gms.common.data.zad("Could not add the value to a new CursorWindow. The size of value may be larger than what a CursorWindow can handle.");
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private static android.database.CursorWindow[] zaf(com.google.android.gms.common.data.DataHolder.Builder r12, int r13) {
+        /*
+            Method dump skipped, instructions count: 391
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.android.gms.common.data.DataHolder.zaf(com.google.android.gms.common.data.DataHolder$Builder, int):android.database.CursorWindow[]");
+    }
+
+    @Override // java.io.Closeable, java.lang.AutoCloseable
+    @KeepForSdk
+    public void close() {
+        synchronized (this) {
+            try {
+                if (!this.zae) {
+                    this.zae = true;
+                    int i = 0;
+                    while (true) {
+                        CursorWindow[] cursorWindowArr = this.zah;
+                        if (i >= cursorWindowArr.length) {
+                            break;
+                        }
+                        cursorWindowArr[i].close();
+                        i++;
+                    }
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public final void finalize() throws Throwable {
+        try {
+            if (this.zak && this.zah.length > 0 && !isClosed()) {
+                close();
+                Log.e("DataBuffer", "Internal data leak within a DataBuffer object detected!  Be sure to explicitly call release() on all DataBuffer extending objects when you are done with them. (internal object: " + toString() + ")");
+            }
+        } finally {
+            super.finalize();
+        }
+    }
+
+    @KeepForSdk
+    public boolean getBoolean(@NonNull String str, int i, int i2) {
+        zae(str, i);
+        return Long.valueOf(this.zah[i2].getLong(i, this.zab.getInt(str))).longValue() == 1;
+    }
+
+    @NonNull
+    @KeepForSdk
+    public byte[] getByteArray(@NonNull String str, int i, int i2) {
+        zae(str, i);
+        return this.zah[i2].getBlob(i, this.zab.getInt(str));
+    }
+
+    @KeepForSdk
+    public int getCount() {
+        return this.zad;
+    }
+
+    @KeepForSdk
+    public int getInteger(@NonNull String str, int i, int i2) {
+        zae(str, i);
+        return this.zah[i2].getInt(i, this.zab.getInt(str));
+    }
+
+    @KeepForSdk
+    public long getLong(@NonNull String str, int i, int i2) {
+        zae(str, i);
+        return this.zah[i2].getLong(i, this.zab.getInt(str));
+    }
+
+    @Nullable
+    @KeepForSdk
+    public Bundle getMetadata() {
+        return this.zaj;
+    }
+
+    @KeepForSdk
+    public int getStatusCode() {
+        return this.zai;
+    }
+
+    @NonNull
+    @KeepForSdk
+    public String getString(@NonNull String str, int i, int i2) {
+        zae(str, i);
+        return this.zah[i2].getString(i, this.zab.getInt(str));
+    }
+
+    @KeepForSdk
+    public int getWindowIndex(int i) {
+        int length;
+        int i2 = 0;
+        Preconditions.checkState(i >= 0 && i < this.zad);
+        while (true) {
+            int[] iArr = this.zac;
+            length = iArr.length;
+            if (i2 >= length) {
+                break;
+            }
+            if (i < iArr[i2]) {
+                i2--;
+                break;
+            }
+            i2++;
+        }
+        return i2 == length ? i2 - 1 : i2;
+    }
+
+    @KeepForSdk
+    public boolean hasColumn(@NonNull String str) {
+        return this.zab.containsKey(str);
+    }
+
+    @KeepForSdk
+    public boolean hasNull(@NonNull String str, int i, int i2) {
+        zae(str, i);
+        return this.zah[i2].isNull(i, this.zab.getInt(str));
+    }
+
+    @KeepForSdk
+    public boolean isClosed() {
+        boolean z;
+        synchronized (this) {
+            z = this.zae;
+        }
+        return z;
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(@NonNull Parcel parcel, int i) {
+        String[] strArr = this.zag;
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeStringArray(parcel, 1, strArr, false);
+        SafeParcelWriter.writeTypedArray(parcel, 2, this.zah, i, false);
+        SafeParcelWriter.writeInt(parcel, 3, getStatusCode());
+        SafeParcelWriter.writeBundle(parcel, 4, getMetadata(), false);
+        SafeParcelWriter.writeInt(parcel, 1000, this.zaa);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+        if ((i & 1) != 0) {
+            close();
+        }
+    }
+
+    public final double zaa(@NonNull String str, int i, int i2) {
+        zae(str, i);
+        return this.zah[i2].getDouble(i, this.zab.getInt(str));
+    }
+
+    public final float zab(@NonNull String str, int i, int i2) {
+        zae(str, i);
+        return this.zah[i2].getFloat(i, this.zab.getInt(str));
+    }
+
+    public final void zac(@NonNull String str, int i, int i2, @NonNull CharArrayBuffer charArrayBuffer) {
+        zae(str, i);
+        this.zah[i2].copyStringToBuffer(i, this.zab.getInt(str), charArrayBuffer);
+    }
+
+    public final void zad() {
+        this.zab = new Bundle();
+        int i = 0;
+        int i2 = 0;
+        while (true) {
+            String[] strArr = this.zag;
+            if (i2 >= strArr.length) {
+                break;
+            }
+            this.zab.putInt(strArr[i2], i2);
+            i2++;
+        }
+        this.zac = new int[this.zah.length];
+        int i3 = 0;
+        while (true) {
+            CursorWindow[] cursorWindowArr = this.zah;
+            if (i >= cursorWindowArr.length) {
+                this.zad = i3;
+                return;
+            }
+            this.zac[i] = i3;
+            i3 += this.zah[i].getNumRows() - (i3 - cursorWindowArr[i].getStartPosition());
+            i++;
+        }
+    }
+
+    /* JADX WARN: Finally extract failed */
+    /* JADX WARN: Illegal instructions before constructor call */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public DataHolder(@androidx.annotation.NonNull android.database.Cursor r8, int r9, @androidx.annotation.Nullable android.os.Bundle r10) {
+        /*
+            r7 = this;
+            com.google.android.gms.common.sqlite.CursorWrapper r0 = new com.google.android.gms.common.sqlite.CursorWrapper
+            r0.<init>(r8)
+            java.lang.String[] r8 = r0.getColumnNames()
+            java.util.ArrayList r1 = new java.util.ArrayList
+            r1.<init>()
+            int r2 = r0.getCount()     // Catch: java.lang.Throwable -> L2e
+            android.database.CursorWindow r3 = r0.getWindow()     // Catch: java.lang.Throwable -> L2e
+            r4 = 0
+            r5 = 0
+            if (r3 == 0) goto L30
+            int r6 = r3.getStartPosition()     // Catch: java.lang.Throwable -> L2e
+            if (r6 != 0) goto L30
+            r3.acquireReference()     // Catch: java.lang.Throwable -> L2e
+            r0.setWindow(r4)     // Catch: java.lang.Throwable -> L2e
+            r1.add(r3)     // Catch: java.lang.Throwable -> L2e
+            int r3 = r3.getNumRows()     // Catch: java.lang.Throwable -> L2e
+            goto L31
+        L2e:
+            r8 = move-exception
+            goto L78
+        L30:
+            r3 = r5
+        L31:
+            if (r3 >= r2) goto L65
+            boolean r6 = r0.moveToPosition(r3)     // Catch: java.lang.Throwable -> L2e
+            if (r6 == 0) goto L65
+            android.database.CursorWindow r6 = r0.getWindow()     // Catch: java.lang.Throwable -> L2e
+            if (r6 == 0) goto L46
+            r6.acquireReference()     // Catch: java.lang.Throwable -> L2e
+            r0.setWindow(r4)     // Catch: java.lang.Throwable -> L2e
+            goto L51
+        L46:
+            android.database.CursorWindow r6 = new android.database.CursorWindow     // Catch: java.lang.Throwable -> L2e
+            r6.<init>(r5)     // Catch: java.lang.Throwable -> L2e
+            r6.setStartPosition(r3)     // Catch: java.lang.Throwable -> L2e
+            r0.fillWindow(r3, r6)     // Catch: java.lang.Throwable -> L2e
+        L51:
+            int r3 = r6.getNumRows()     // Catch: java.lang.Throwable -> L2e
+            if (r3 != 0) goto L58
+            goto L65
+        L58:
+            r1.add(r6)     // Catch: java.lang.Throwable -> L2e
+            int r3 = r6.getStartPosition()     // Catch: java.lang.Throwable -> L2e
+            int r6 = r6.getNumRows()     // Catch: java.lang.Throwable -> L2e
+            int r3 = r3 + r6
+            goto L31
+        L65:
+            r0.close()
+            int r0 = r1.size()
+            android.database.CursorWindow[] r0 = new android.database.CursorWindow[r0]
+            java.lang.Object[] r0 = r1.toArray(r0)
+            android.database.CursorWindow[] r0 = (android.database.CursorWindow[]) r0
+            r7.<init>(r8, r0, r9, r10)
+            return
+        L78:
+            r0.close()
+            throw r8
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.android.gms.common.data.DataHolder.<init>(android.database.Cursor, int, android.os.Bundle):void");
+    }
+
+    private DataHolder(Builder builder, int i, @Nullable Bundle bundle) {
+        this(builder.zaa, zaf(builder, -1), i, (Bundle) null);
+    }
+}

decompiled/sources/com/google/android/gms/common/data/EntityBuffer.java

@@ -0,0 +1,113 @@
+package com.google.android.gms.common.data;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.errorprone.annotations.ResultIgnorabilityUnspecified;
+import java.util.ArrayList;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public abstract class EntityBuffer<T> extends AbstractDataBuffer<T> {
+    private boolean zaa;
+    private ArrayList zab;
+
+    @KeepForSdk
+    public EntityBuffer(@NonNull DataHolder dataHolder) {
+        super(dataHolder);
+        this.zaa = false;
+    }
+
+    private final void zab() {
+        synchronized (this) {
+            try {
+                if (!this.zaa) {
+                    int count = ((DataHolder) Preconditions.checkNotNull(this.mDataHolder)).getCount();
+                    ArrayList arrayList = new ArrayList();
+                    this.zab = arrayList;
+                    if (count > 0) {
+                        arrayList.add(0);
+                        String primaryDataMarkerColumn = getPrimaryDataMarkerColumn();
+                        String string = this.mDataHolder.getString(primaryDataMarkerColumn, 0, this.mDataHolder.getWindowIndex(0));
+                        for (int i = 1; i < count; i++) {
+                            int windowIndex = this.mDataHolder.getWindowIndex(i);
+                            String string2 = this.mDataHolder.getString(primaryDataMarkerColumn, i, windowIndex);
+                            if (string2 == null) {
+                                throw new NullPointerException("Missing value for markerColumn: " + primaryDataMarkerColumn + ", at row: " + i + ", for window: " + windowIndex);
+                            }
+                            if (!string2.equals(string)) {
+                                this.zab.add(Integer.valueOf(i));
+                                string = string2;
+                            }
+                        }
+                    }
+                    this.zaa = true;
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // com.google.android.gms.common.data.AbstractDataBuffer, com.google.android.gms.common.data.DataBuffer
+    @NonNull
+    @ResultIgnorabilityUnspecified
+    @KeepForSdk
+    public final T get(int i) {
+        int intValue;
+        int intValue2;
+        zab();
+        int zaa = zaa(i);
+        int i2 = 0;
+        if (i >= 0 && i != this.zab.size()) {
+            if (i == this.zab.size() - 1) {
+                intValue = ((DataHolder) Preconditions.checkNotNull(this.mDataHolder)).getCount();
+                intValue2 = ((Integer) this.zab.get(i)).intValue();
+            } else {
+                intValue = ((Integer) this.zab.get(i + 1)).intValue();
+                intValue2 = ((Integer) this.zab.get(i)).intValue();
+            }
+            int i3 = intValue - intValue2;
+            if (i3 == 1) {
+                int zaa2 = zaa(i);
+                int windowIndex = ((DataHolder) Preconditions.checkNotNull(this.mDataHolder)).getWindowIndex(zaa2);
+                String childDataMarkerColumn = getChildDataMarkerColumn();
+                if (childDataMarkerColumn == null || this.mDataHolder.getString(childDataMarkerColumn, zaa2, windowIndex) != null) {
+                    i2 = 1;
+                }
+            } else {
+                i2 = i3;
+            }
+        }
+        return getEntry(zaa, i2);
+    }
+
+    @Nullable
+    @KeepForSdk
+    public String getChildDataMarkerColumn() {
+        return null;
+    }
+
+    @Override // com.google.android.gms.common.data.AbstractDataBuffer, com.google.android.gms.common.data.DataBuffer
+    @KeepForSdk
+    public int getCount() {
+        zab();
+        return this.zab.size();
+    }
+
+    @NonNull
+    @KeepForSdk
+    public abstract T getEntry(int i, int i2);
+
+    @NonNull
+    @KeepForSdk
+    public abstract String getPrimaryDataMarkerColumn();
+
+    public final int zaa(int i) {
+        if (i >= 0 && i < this.zab.size()) {
+            return ((Integer) this.zab.get(i)).intValue();
+        }
+        throw new IllegalArgumentException("Position " + i + " is out of bounds for this buffer");
+    }
+}

decompiled/sources/com/google/android/gms/common/data/Freezable.java

@@ -0,0 +1,11 @@
+package com.google.android.gms.common.data;
+
+import androidx.annotation.NonNull;
+
+/* loaded from: classes2.dex */
+public interface Freezable<T> {
+    @NonNull
+    T freeze();
+
+    boolean isDataValid();
+}

decompiled/sources/com/google/android/gms/common/data/FreezableUtils.java

@@ -0,0 +1,38 @@
+package com.google.android.gms.common.data;
+
+import androidx.annotation.NonNull;
+import com.ironsource.un;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+/* loaded from: classes2.dex */
+public final class FreezableUtils {
+    @NonNull
+    public static <T, E extends Freezable<T>> ArrayList<T> freeze(@NonNull ArrayList<E> arrayList) {
+        un.a aVar = (ArrayList<T>) new ArrayList(arrayList.size());
+        int size = arrayList.size();
+        for (int i = 0; i < size; i++) {
+            aVar.add(arrayList.get(i).freeze());
+        }
+        return aVar;
+    }
+
+    @NonNull
+    public static <T, E extends Freezable<T>> ArrayList<T> freezeIterable(@NonNull Iterable<E> iterable) {
+        un.a aVar = (ArrayList<T>) new ArrayList();
+        Iterator<E> it = iterable.iterator();
+        while (it.hasNext()) {
+            aVar.add(it.next().freeze());
+        }
+        return aVar;
+    }
+
+    @NonNull
+    public static <T, E extends Freezable<T>> ArrayList<T> freeze(@NonNull E[] eArr) {
+        un.a aVar = (ArrayList<T>) new ArrayList(eArr.length);
+        for (E e : eArr) {
+            aVar.add(e.freeze());
+        }
+        return aVar;
+    }
+}

decompiled/sources/com/google/android/gms/common/data/SingleRefDataBufferIterator.java

@@ -0,0 +1,36 @@
+package com.google.android.gms.common.data;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Preconditions;
+import java.util.NoSuchElementException;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class SingleRefDataBufferIterator<T> extends DataBufferIterator<T> {
+    private Object zac;
+
+    public SingleRefDataBufferIterator(@NonNull DataBuffer dataBuffer) {
+        super(dataBuffer);
+    }
+
+    @Override // com.google.android.gms.common.data.DataBufferIterator, java.util.Iterator
+    @NonNull
+    public final Object next() {
+        if (!hasNext()) {
+            throw new NoSuchElementException("Cannot advance the iterator beyond " + this.zab);
+        }
+        int i = this.zab + 1;
+        this.zab = i;
+        if (i == 0) {
+            Object checkNotNull = Preconditions.checkNotNull(this.zaa.get(0));
+            this.zac = checkNotNull;
+            if (!(checkNotNull instanceof DataBufferRef)) {
+                throw new IllegalStateException("DataBuffer reference of type " + String.valueOf(checkNotNull.getClass()) + " is not movable");
+            }
+        } else {
+            ((DataBufferRef) Preconditions.checkNotNull(this.zac)).zaa(this.zab);
+        }
+        return this.zac;
+    }
+}

decompiled/sources/com/google/android/gms/common/data/zaa.java

@@ -0,0 +1,37 @@
+package com.google.android.gms.common.data;
+
+import android.os.Parcel;
+import android.os.ParcelFileDescriptor;
+import android.os.Parcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+
+/* loaded from: classes2.dex */
+public final class zaa implements Parcelable.Creator {
+    @Override // android.os.Parcelable.Creator
+    public final /* bridge */ /* synthetic */ Object createFromParcel(Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        int i = 0;
+        ParcelFileDescriptor parcelFileDescriptor = null;
+        int i2 = 0;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            int fieldId = SafeParcelReader.getFieldId(readHeader);
+            if (fieldId == 1) {
+                i = SafeParcelReader.readInt(parcel, readHeader);
+            } else if (fieldId == 2) {
+                parcelFileDescriptor = (ParcelFileDescriptor) SafeParcelReader.createParcelable(parcel, readHeader, ParcelFileDescriptor.CREATOR);
+            } else if (fieldId != 3) {
+                SafeParcelReader.skipUnknownField(parcel, readHeader);
+            } else {
+                i2 = SafeParcelReader.readInt(parcel, readHeader);
+            }
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new BitmapTeleporter(i, parcelFileDescriptor, i2);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ Object[] newArray(int i) {
+        return new BitmapTeleporter[i];
+    }
+}

decompiled/sources/com/google/android/gms/common/data/zab.java

@@ -0,0 +1,22 @@
+package com.google.android.gms.common.data;
+
+import android.content.ContentValues;
+import com.google.android.gms.common.data.DataHolder;
+import java.util.HashMap;
+
+/* loaded from: classes2.dex */
+final class zab extends DataHolder.Builder {
+    public zab(String[] strArr, String str) {
+        super(strArr, null, null);
+    }
+
+    @Override // com.google.android.gms.common.data.DataHolder.Builder
+    public final DataHolder.Builder withRow(ContentValues contentValues) {
+        throw new UnsupportedOperationException("Cannot add data to empty builder");
+    }
+
+    @Override // com.google.android.gms.common.data.DataHolder.Builder
+    public final DataHolder.Builder zaa(HashMap hashMap) {
+        throw new UnsupportedOperationException("Cannot add data to empty builder");
+    }
+}

decompiled/sources/com/google/android/gms/common/data/zad.java

@@ -0,0 +1,8 @@
+package com.google.android.gms.common.data;
+
+/* loaded from: classes2.dex */
+public final class zad extends RuntimeException {
+    public zad(String str) {
+        super("Could not add the value to a new CursorWindow. The size of value may be larger than what a CursorWindow can handle.");
+    }
+}

decompiled/sources/com/google/android/gms/common/data/zaf.java

@@ -0,0 +1,46 @@
+package com.google.android.gms.common.data;
+
+import android.database.CursorWindow;
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+
+/* loaded from: classes2.dex */
+public final class zaf implements Parcelable.Creator {
+    @Override // android.os.Parcelable.Creator
+    public final /* bridge */ /* synthetic */ Object createFromParcel(Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        String[] strArr = null;
+        CursorWindow[] cursorWindowArr = null;
+        Bundle bundle = null;
+        int i = 0;
+        int i2 = 0;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            int fieldId = SafeParcelReader.getFieldId(readHeader);
+            if (fieldId == 1) {
+                strArr = SafeParcelReader.createStringArray(parcel, readHeader);
+            } else if (fieldId == 2) {
+                cursorWindowArr = (CursorWindow[]) SafeParcelReader.createTypedArray(parcel, readHeader, CursorWindow.CREATOR);
+            } else if (fieldId == 3) {
+                i2 = SafeParcelReader.readInt(parcel, readHeader);
+            } else if (fieldId == 4) {
+                bundle = SafeParcelReader.createBundle(parcel, readHeader);
+            } else if (fieldId != 1000) {
+                SafeParcelReader.skipUnknownField(parcel, readHeader);
+            } else {
+                i = SafeParcelReader.readInt(parcel, readHeader);
+            }
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        DataHolder dataHolder = new DataHolder(i, strArr, cursorWindowArr, i2, bundle);
+        dataHolder.zad();
+        return dataHolder;
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ Object[] newArray(int i) {
+        return new DataHolder[i];
+    }
+}