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/identitycredentials/CallingAppInfo.java

@@ -0,0 +1,34 @@
+package com.google.android.gms.identitycredentials;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import java.util.List;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes2.dex */
+public final class CallingAppInfo {
+    private final String origin;
+    private final List<byte[]> packageCertificates;
+    private final String packageName;
+
+    public CallingAppInfo(@NonNull String packageName, @NonNull List<byte[]> packageCertificates, String str) {
+        Intrinsics.checkNotNullParameter(packageName, "packageName");
+        Intrinsics.checkNotNullParameter(packageCertificates, "packageCertificates");
+        this.packageName = packageName;
+        this.packageCertificates = packageCertificates;
+        this.origin = str;
+    }
+
+    @Nullable
+    public final String getOrigin() {
+        return this.origin;
+    }
+
+    public final List<byte[]> getPackageCertificates() {
+        return this.packageCertificates;
+    }
+
+    public final String getPackageName() {
+        return this.packageName;
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/ClearRegistryRequest.java

@@ -0,0 +1,35 @@
+package com.google.android.gms.identitycredentials;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+@SafeParcelable.Class(creator = "ClearRegistryRequestCreator")
+/* loaded from: classes2.dex */
+public final class ClearRegistryRequest extends AbstractSafeParcelable {
+    public static final Companion Companion = new Companion(null);
+    public static final Parcelable.Creator<ClearRegistryRequest> CREATOR = new ClearRegistryRequestCreator();
+
+    public static final class Companion {
+        private Companion() {
+        }
+
+        public /* synthetic */ Companion(@NonNull DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+    }
+
+    @SafeParcelable.Constructor
+    public ClearRegistryRequest() {
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(@NonNull Parcel dest, int i) {
+        Intrinsics.checkNotNullParameter(dest, "dest");
+        ClearRegistryRequestCreator.writeToParcel(this, dest, i);
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/ClearRegistryRequestCreator.java

@@ -0,0 +1,35 @@
+package com.google.android.gms.identitycredentials;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+
+/* loaded from: classes2.dex */
+public final class ClearRegistryRequestCreator implements Parcelable.Creator<ClearRegistryRequest> {
+    public static void writeToParcel(ClearRegistryRequest clearRegistryRequest, Parcel parcel, int i) {
+        SafeParcelWriter.finishObjectHeader(parcel, SafeParcelWriter.beginObjectHeader(parcel));
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // android.os.Parcelable.Creator
+    @NonNull
+    public ClearRegistryRequest createFromParcel(@NonNull Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            SafeParcelReader.getFieldId(readHeader);
+            SafeParcelReader.skipUnknownField(parcel, readHeader);
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new ClearRegistryRequest();
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // android.os.Parcelable.Creator
+    @NonNull
+    public ClearRegistryRequest[] newArray(int i) {
+        return new ClearRegistryRequest[i];
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/ClearRegistryResponse.java

@@ -0,0 +1,43 @@
+package com.google.android.gms.identitycredentials;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+@SafeParcelable.Class(creator = "ClearRegistryResponseCreator")
+/* loaded from: classes2.dex */
+public final class ClearRegistryResponse extends AbstractSafeParcelable {
+
+    @SafeParcelable.Field(getter = "isDeleted", id = 1)
+    private final boolean isDeleted;
+    public static final Companion Companion = new Companion(null);
+    public static final Parcelable.Creator<ClearRegistryResponse> CREATOR = new ClearRegistryResponseCreator();
+
+    public static final class Companion {
+        private Companion() {
+        }
+
+        public /* synthetic */ Companion(@NonNull DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+    }
+
+    @SafeParcelable.Constructor
+    public ClearRegistryResponse(@SafeParcelable.Param(id = 1) boolean z) {
+        this.isDeleted = z;
+    }
+
+    public final boolean isDeleted() {
+        return this.isDeleted;
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(@NonNull Parcel dest, int i) {
+        Intrinsics.checkNotNullParameter(dest, "dest");
+        ClearRegistryResponseCreator.writeToParcel(this, dest, i);
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/ClearRegistryResponseCreator.java

@@ -0,0 +1,41 @@
+package com.google.android.gms.identitycredentials;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+
+/* loaded from: classes2.dex */
+public final class ClearRegistryResponseCreator implements Parcelable.Creator<ClearRegistryResponse> {
+    public static void writeToParcel(ClearRegistryResponse clearRegistryResponse, Parcel parcel, int i) {
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeBoolean(parcel, 1, clearRegistryResponse.isDeleted());
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // android.os.Parcelable.Creator
+    @NonNull
+    public ClearRegistryResponse createFromParcel(@NonNull Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        boolean z = false;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            if (SafeParcelReader.getFieldId(readHeader) != 1) {
+                SafeParcelReader.skipUnknownField(parcel, readHeader);
+            } else {
+                z = SafeParcelReader.readBoolean(parcel, readHeader);
+            }
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new ClearRegistryResponse(z);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // android.os.Parcelable.Creator
+    @NonNull
+    public ClearRegistryResponse[] newArray(int i) {
+        return new ClearRegistryResponse[i];
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/Credential.java

@@ -0,0 +1,54 @@
+package com.google.android.gms.identitycredentials;
+
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+@SafeParcelable.Class(creator = "CredentialCreator")
+/* loaded from: classes2.dex */
+public final class Credential extends AbstractSafeParcelable {
+
+    @SafeParcelable.Field(getter = "getData", id = 2)
+    private final Bundle data;
+
+    @SafeParcelable.Field(getter = "getType", id = 1)
+    private final String type;
+    public static final Companion Companion = new Companion(null);
+    public static final Parcelable.Creator<Credential> CREATOR = new CredentialCreator();
+
+    public static final class Companion {
+        private Companion() {
+        }
+
+        public /* synthetic */ Companion(@NonNull DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+    }
+
+    @SafeParcelable.Constructor
+    public Credential(@NonNull @SafeParcelable.Param(id = 1) String type, @NonNull @SafeParcelable.Param(id = 2) Bundle data) {
+        Intrinsics.checkNotNullParameter(type, "type");
+        Intrinsics.checkNotNullParameter(data, "data");
+        this.type = type;
+        this.data = data;
+    }
+
+    public final Bundle getData() {
+        return this.data;
+    }
+
+    public final String getType() {
+        return this.type;
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(@NonNull Parcel dest, int i) {
+        Intrinsics.checkNotNullParameter(dest, "dest");
+        CredentialCreator.writeToParcel(this, dest, i);
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/CredentialCreator.java

@@ -0,0 +1,47 @@
+package com.google.android.gms.identitycredentials;
+
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+
+/* loaded from: classes2.dex */
+public final class CredentialCreator implements Parcelable.Creator<Credential> {
+    public static void writeToParcel(Credential credential, Parcel parcel, int i) {
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeString(parcel, 1, credential.getType(), false);
+        SafeParcelWriter.writeBundle(parcel, 2, credential.getData(), false);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // android.os.Parcelable.Creator
+    @NonNull
+    public Credential createFromParcel(@NonNull Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        String str = null;
+        Bundle bundle = null;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            int fieldId = SafeParcelReader.getFieldId(readHeader);
+            if (fieldId == 1) {
+                str = SafeParcelReader.createString(parcel, readHeader);
+            } else if (fieldId != 2) {
+                SafeParcelReader.skipUnknownField(parcel, readHeader);
+            } else {
+                bundle = SafeParcelReader.createBundle(parcel, readHeader);
+            }
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new Credential(str, bundle);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // android.os.Parcelable.Creator
+    @NonNull
+    public Credential[] newArray(int i) {
+        return new Credential[i];
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/CredentialOption.java

@@ -0,0 +1,97 @@
+package com.google.android.gms.identitycredentials;
+
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.StringsKt__StringsJVMKt;
+
+@SafeParcelable.Class(creator = "CredentialOptionCreator")
+/* loaded from: classes2.dex */
+public final class CredentialOption extends AbstractSafeParcelable {
+
+    @SafeParcelable.Field(getter = "getCandidateQueryData", id = 3)
+    private final Bundle candidateQueryData;
+
+    @SafeParcelable.Field(getter = "getCredentialRetrievalData", id = 2)
+    private final Bundle credentialRetrievalData;
+
+    @SafeParcelable.Field(defaultValue = "", getter = "getProtocolType", id = 6)
+    private final String protocolType;
+
+    @SafeParcelable.Field(getter = "getRequestMatcher", id = 4)
+    private final String requestMatcher;
+
+    @SafeParcelable.Field(defaultValue = "", getter = "getRequestType", id = 5)
+    private final String requestType;
+
+    @SafeParcelable.Field(defaultValue = "", getter = "getType", id = 1)
+    private final String type;
+    public static final Companion Companion = new Companion(null);
+    public static final Parcelable.Creator<CredentialOption> CREATOR = new CredentialOptionCreator();
+
+    public static final class Companion {
+        private Companion() {
+        }
+
+        public /* synthetic */ Companion(@NonNull DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+    }
+
+    @SafeParcelable.Constructor
+    public CredentialOption(@NonNull @SafeParcelable.Param(id = 1) String type, @NonNull @SafeParcelable.Param(id = 2) Bundle credentialRetrievalData, @NonNull @SafeParcelable.Param(id = 3) Bundle candidateQueryData, @NonNull @SafeParcelable.Param(id = 4) String requestMatcher, @NonNull @SafeParcelable.Param(id = 5) String requestType, @NonNull @SafeParcelable.Param(id = 6) String protocolType) {
+        Intrinsics.checkNotNullParameter(type, "type");
+        Intrinsics.checkNotNullParameter(credentialRetrievalData, "credentialRetrievalData");
+        Intrinsics.checkNotNullParameter(candidateQueryData, "candidateQueryData");
+        Intrinsics.checkNotNullParameter(requestMatcher, "requestMatcher");
+        Intrinsics.checkNotNullParameter(requestType, "requestType");
+        Intrinsics.checkNotNullParameter(protocolType, "protocolType");
+        this.type = type;
+        this.credentialRetrievalData = credentialRetrievalData;
+        this.candidateQueryData = candidateQueryData;
+        this.requestMatcher = requestMatcher;
+        this.requestType = requestType;
+        this.protocolType = protocolType;
+        boolean z = (StringsKt__StringsJVMKt.isBlank(requestType) || StringsKt__StringsJVMKt.isBlank(protocolType)) ? false : true;
+        boolean z2 = !StringsKt__StringsJVMKt.isBlank(type) && requestType.length() == 0 && protocolType.length() == 0;
+        if (z || z2) {
+            return;
+        }
+        throw new IllegalArgumentException("Either type: " + type + ", or requestType: " + requestType + " and protocolType: " + protocolType + " must be specified, but at least one contains an invalid blank value.");
+    }
+
+    public final Bundle getCandidateQueryData() {
+        return this.candidateQueryData;
+    }
+
+    public final Bundle getCredentialRetrievalData() {
+        return this.credentialRetrievalData;
+    }
+
+    public final String getProtocolType() {
+        return this.protocolType;
+    }
+
+    public final String getRequestMatcher() {
+        return this.requestMatcher;
+    }
+
+    public final String getRequestType() {
+        return this.requestType;
+    }
+
+    public final String getType() {
+        return this.type;
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(@NonNull Parcel dest, int i) {
+        Intrinsics.checkNotNullParameter(dest, "dest");
+        CredentialOptionCreator.writeToParcel(this, dest, i);
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/CredentialOptionCreator.java

@@ -0,0 +1,70 @@
+package com.google.android.gms.identitycredentials;
+
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+
+/* loaded from: classes2.dex */
+public final class CredentialOptionCreator implements Parcelable.Creator<CredentialOption> {
+    public static void writeToParcel(CredentialOption credentialOption, Parcel parcel, int i) {
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeString(parcel, 1, credentialOption.getType(), false);
+        SafeParcelWriter.writeBundle(parcel, 2, credentialOption.getCredentialRetrievalData(), false);
+        SafeParcelWriter.writeBundle(parcel, 3, credentialOption.getCandidateQueryData(), false);
+        SafeParcelWriter.writeString(parcel, 4, credentialOption.getRequestMatcher(), false);
+        SafeParcelWriter.writeString(parcel, 5, credentialOption.getRequestType(), false);
+        SafeParcelWriter.writeString(parcel, 6, credentialOption.getProtocolType(), false);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // android.os.Parcelable.Creator
+    @NonNull
+    public CredentialOption createFromParcel(@NonNull Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        String str = "";
+        String str2 = str;
+        String str3 = str2;
+        Bundle bundle = null;
+        Bundle bundle2 = null;
+        String str4 = null;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            switch (SafeParcelReader.getFieldId(readHeader)) {
+                case 1:
+                    str = SafeParcelReader.createString(parcel, readHeader);
+                    break;
+                case 2:
+                    bundle = SafeParcelReader.createBundle(parcel, readHeader);
+                    break;
+                case 3:
+                    bundle2 = SafeParcelReader.createBundle(parcel, readHeader);
+                    break;
+                case 4:
+                    str4 = SafeParcelReader.createString(parcel, readHeader);
+                    break;
+                case 5:
+                    str2 = SafeParcelReader.createString(parcel, readHeader);
+                    break;
+                case 6:
+                    str3 = SafeParcelReader.createString(parcel, readHeader);
+                    break;
+                default:
+                    SafeParcelReader.skipUnknownField(parcel, readHeader);
+                    break;
+            }
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new CredentialOption(str, bundle, bundle2, str4, str2, str3);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // android.os.Parcelable.Creator
+    @NonNull
+    public CredentialOption[] newArray(int i) {
+        return new CredentialOption[i];
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/GetCredentialException.java

@@ -0,0 +1,34 @@
+package com.google.android.gms.identitycredentials;
+
+import androidx.annotation.NonNull;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes2.dex */
+public final class GetCredentialException extends Exception {
+    public static final Companion Companion = new Companion(null);
+    public static final String ERROR_TYPE_NO_CREDENTIAL = "android.credentials.GetCredentialException.TYPE_NO_CREDENTIAL";
+    public static final String ERROR_TYPE_UNKNOWN = "android.credentials.GetCredentialException.TYPE_UNKNOWN";
+    public static final String ERROR_TYPE_USER_CANCELED = "android.credentials.GetCredentialException.TYPE_USER_CANCELED";
+    private final String type;
+
+    public static final class Companion {
+        private Companion() {
+        }
+
+        public /* synthetic */ Companion(@NonNull DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public GetCredentialException(@NonNull String type, String str) {
+        super(str);
+        Intrinsics.checkNotNullParameter(type, "type");
+        this.type = type;
+    }
+
+    public final String getType() {
+        return this.type;
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/GetCredentialRequest.java

@@ -0,0 +1,76 @@
+package com.google.android.gms.identitycredentials;
+
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.os.ResultReceiver;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.internal.ReflectedParcelable;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+import java.util.List;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+@SafeParcelable.Class(creator = "GetCredentialRequestCreator")
+/* loaded from: classes2.dex */
+public final class GetCredentialRequest extends AbstractSafeParcelable implements ReflectedParcelable {
+
+    @SafeParcelable.Field(getter = "getCredentialOptions", id = 1)
+    private final List<CredentialOption> credentialOptions;
+
+    @SafeParcelable.Field(getter = "getData", id = 2)
+    private final Bundle data;
+
+    @SafeParcelable.Field(getter = "getOrigin", id = 3)
+    private final String origin;
+
+    @SafeParcelable.Field(getter = "getResultReceiver", id = 4)
+    private final ResultReceiver resultReceiver;
+    public static final Companion Companion = new Companion(null);
+    public static final Parcelable.Creator<GetCredentialRequest> CREATOR = new GetCredentialRequestCreator();
+
+    public static final class Companion {
+        private Companion() {
+        }
+
+        public /* synthetic */ Companion(@NonNull DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+    }
+
+    @SafeParcelable.Constructor
+    public GetCredentialRequest(@NonNull @SafeParcelable.Param(id = 1) List<CredentialOption> credentialOptions, @NonNull @SafeParcelable.Param(id = 2) Bundle data, @SafeParcelable.Param(id = 3) String str, @NonNull @SafeParcelable.Param(id = 4) ResultReceiver resultReceiver) {
+        Intrinsics.checkNotNullParameter(credentialOptions, "credentialOptions");
+        Intrinsics.checkNotNullParameter(data, "data");
+        Intrinsics.checkNotNullParameter(resultReceiver, "resultReceiver");
+        this.credentialOptions = credentialOptions;
+        this.data = data;
+        this.origin = str;
+        this.resultReceiver = resultReceiver;
+    }
+
+    public final List<CredentialOption> getCredentialOptions() {
+        return this.credentialOptions;
+    }
+
+    public final Bundle getData() {
+        return this.data;
+    }
+
+    @Nullable
+    public final String getOrigin() {
+        return this.origin;
+    }
+
+    public final ResultReceiver getResultReceiver() {
+        return this.resultReceiver;
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(@NonNull Parcel dest, int i) {
+        Intrinsics.checkNotNullParameter(dest, "dest");
+        GetCredentialRequestCreator.writeToParcel(this, dest, i);
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/GetCredentialRequestCreator.java

@@ -0,0 +1,57 @@
+package com.google.android.gms.identitycredentials;
+
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.os.ResultReceiver;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+import java.util.ArrayList;
+
+/* loaded from: classes2.dex */
+public final class GetCredentialRequestCreator implements Parcelable.Creator<GetCredentialRequest> {
+    public static void writeToParcel(GetCredentialRequest getCredentialRequest, Parcel parcel, int i) {
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeTypedList(parcel, 1, getCredentialRequest.getCredentialOptions(), false);
+        SafeParcelWriter.writeBundle(parcel, 2, getCredentialRequest.getData(), false);
+        SafeParcelWriter.writeString(parcel, 3, getCredentialRequest.getOrigin(), false);
+        SafeParcelWriter.writeParcelable(parcel, 4, getCredentialRequest.getResultReceiver(), i, false);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // android.os.Parcelable.Creator
+    @NonNull
+    public GetCredentialRequest createFromParcel(@NonNull Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        ArrayList arrayList = null;
+        Bundle bundle = null;
+        String str = null;
+        ResultReceiver resultReceiver = null;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            int fieldId = SafeParcelReader.getFieldId(readHeader);
+            if (fieldId == 1) {
+                arrayList = SafeParcelReader.createTypedList(parcel, readHeader, CredentialOption.CREATOR);
+            } else if (fieldId == 2) {
+                bundle = SafeParcelReader.createBundle(parcel, readHeader);
+            } else if (fieldId == 3) {
+                str = SafeParcelReader.createString(parcel, readHeader);
+            } else if (fieldId != 4) {
+                SafeParcelReader.skipUnknownField(parcel, readHeader);
+            } else {
+                resultReceiver = (ResultReceiver) SafeParcelReader.createParcelable(parcel, readHeader, ResultReceiver.CREATOR);
+            }
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new GetCredentialRequest(arrayList, bundle, str, resultReceiver);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // android.os.Parcelable.Creator
+    @NonNull
+    public GetCredentialRequest[] newArray(int i) {
+        return new GetCredentialRequest[i];
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/GetCredentialResponse.java

@@ -0,0 +1,44 @@
+package com.google.android.gms.identitycredentials;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+@SafeParcelable.Class(creator = "GetCredentialResponseCreator")
+/* loaded from: classes2.dex */
+public final class GetCredentialResponse extends AbstractSafeParcelable {
+
+    @SafeParcelable.Field(getter = "getCredential", id = 1)
+    private final Credential credential;
+    public static final Companion Companion = new Companion(null);
+    public static final Parcelable.Creator<GetCredentialResponse> CREATOR = new GetCredentialResponseCreator();
+
+    public static final class Companion {
+        private Companion() {
+        }
+
+        public /* synthetic */ Companion(@NonNull DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+    }
+
+    @SafeParcelable.Constructor
+    public GetCredentialResponse(@NonNull @SafeParcelable.Param(id = 1) Credential credential) {
+        Intrinsics.checkNotNullParameter(credential, "credential");
+        this.credential = credential;
+    }
+
+    public final Credential getCredential() {
+        return this.credential;
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(@NonNull Parcel dest, int i) {
+        Intrinsics.checkNotNullParameter(dest, "dest");
+        GetCredentialResponseCreator.writeToParcel(this, dest, i);
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/GetCredentialResponseCreator.java

@@ -0,0 +1,41 @@
+package com.google.android.gms.identitycredentials;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+
+/* loaded from: classes2.dex */
+public final class GetCredentialResponseCreator implements Parcelable.Creator<GetCredentialResponse> {
+    public static void writeToParcel(GetCredentialResponse getCredentialResponse, Parcel parcel, int i) {
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeParcelable(parcel, 1, getCredentialResponse.getCredential(), i, false);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // android.os.Parcelable.Creator
+    @NonNull
+    public GetCredentialResponse createFromParcel(@NonNull Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        Credential credential = null;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            if (SafeParcelReader.getFieldId(readHeader) != 1) {
+                SafeParcelReader.skipUnknownField(parcel, readHeader);
+            } else {
+                credential = (Credential) SafeParcelReader.createParcelable(parcel, readHeader, Credential.CREATOR);
+            }
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new GetCredentialResponse(credential);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // android.os.Parcelable.Creator
+    @NonNull
+    public GetCredentialResponse[] newArray(int i) {
+        return new GetCredentialResponse[i];
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/IdentityCredentialClient.java

@@ -0,0 +1,13 @@
+package com.google.android.gms.identitycredentials;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.tasks.Task;
+
+/* loaded from: classes2.dex */
+public interface IdentityCredentialClient {
+    Task<ClearRegistryResponse> clearRegistry(@NonNull ClearRegistryRequest clearRegistryRequest);
+
+    Task<PendingGetCredentialHandle> getCredential(@NonNull GetCredentialRequest getCredentialRequest);
+
+    Task<RegistrationResponse> registerCredentials(@NonNull RegistrationRequest registrationRequest);
+}

decompiled/sources/com/google/android/gms/identitycredentials/IdentityCredentialManager.java

@@ -0,0 +1,43 @@
+package com.google.android.gms.identitycredentials;
+
+import android.app.Activity;
+import android.content.Context;
+import androidx.annotation.NonNull;
+import com.google.android.gms.identitycredentials.internal.InternalIdentityCredentialClient;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes2.dex */
+public final class IdentityCredentialManager {
+    public static final Companion Companion = new Companion(null);
+
+    public static final class Companion {
+        private Companion() {
+        }
+
+        public /* synthetic */ Companion(@NonNull DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public final IdentityCredentialClient getClient(@NonNull Activity activity) {
+            Intrinsics.checkNotNullParameter(activity, "activity");
+            return new InternalIdentityCredentialClient(activity);
+        }
+
+        public final IdentityCredentialClient getClient(@NonNull Context context) {
+            Intrinsics.checkNotNullParameter(context, "context");
+            return new InternalIdentityCredentialClient(context);
+        }
+    }
+
+    private IdentityCredentialManager() {
+    }
+
+    public static final IdentityCredentialClient getClient(@NonNull Activity activity) {
+        return Companion.getClient(activity);
+    }
+
+    public static final IdentityCredentialClient getClient(@NonNull Context context) {
+        return Companion.getClient(context);
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/IntentHelper.java

@@ -0,0 +1,107 @@
+package com.google.android.gms.identitycredentials;
+
+import android.content.Intent;
+import android.os.Build;
+import android.os.Bundle;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import java.util.ArrayList;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes2.dex */
+public final class IntentHelper {
+    public static final String ACTION_GET_CREDENTIAL = "androidx.identitycredentials.action.GET_CREDENTIALS";
+    public static final String EXTRA_CREDENTIAL_ID = "androidx.identitycredentials.extra.CREDENTIAL_ID";
+    public static final IntentHelper INSTANCE = new IntentHelper();
+
+    private IntentHelper() {
+    }
+
+    @Nullable
+    public static final CallingAppInfo extractCallingAppInfo(@NonNull Intent intent) {
+        Intrinsics.checkNotNullParameter(intent, "intent");
+        intent.setExtrasClassLoader(null);
+        String stringExtra = intent.getStringExtra("androidx.identitycredentials.extra.CALLING_PACKAGE_NAME");
+        if (stringExtra == null) {
+            return null;
+        }
+        String stringExtra2 = intent.getStringExtra("androidx.identitycredentials.extra.ORIGIN");
+        int intExtra = intent.getIntExtra("androidx.identitycredentials.extra.SIGNATURE_COUNT", 0);
+        ArrayList arrayList = new ArrayList();
+        for (int i = 0; i < intExtra; i++) {
+            byte[] byteArrayExtra = intent.getByteArrayExtra("androidx.identitycredentials.extra.SIGNATURE_" + i);
+            if (byteArrayExtra == null) {
+                Log.w("IntentHelper", "cannot find expected signature at count " + i);
+                return null;
+            }
+            arrayList.add(byteArrayExtra);
+        }
+        return new CallingAppInfo(stringExtra, arrayList, stringExtra2);
+    }
+
+    @Nullable
+    public static final GetCredentialRequest extractGetCredentialRequest(@NonNull Intent intent) {
+        Intrinsics.checkNotNullParameter(intent, "intent");
+        intent.setExtrasClassLoader(GetCredentialRequest.class.getClassLoader());
+        return (GetCredentialRequest) intent.getParcelableExtra("androidx.identitycredentials.extra.GET_CREDENTIAL_REQUEST");
+    }
+
+    public static final GetCredentialResponse extractGetCredentialResponse(int i, @NonNull Bundle resultData) throws GetCredentialException {
+        Intent intent;
+        Object parcelable;
+        Intrinsics.checkNotNullParameter(resultData, "resultData");
+        if (i != -1) {
+            if (i == 0) {
+                CharSequence charSequence = resultData.getCharSequence("androidx.identitycredentials.BUNDLE_KEY_EXCEPTION_TYPE");
+                String obj = charSequence != null ? charSequence.toString() : "android.credentials.GetCredentialException.TYPE_USER_CANCELED";
+                CharSequence charSequence2 = resultData.getCharSequence("androidx.identitycredentials.BUNDLE_KEY_EXCEPTION_MESSAGE");
+                throw new GetCredentialException(obj, charSequence2 != null ? charSequence2.toString() : null);
+            }
+            throw INSTANCE.newUnknownException("Activity result has unexpected resultCode: " + i);
+        }
+        if (Build.VERSION.SDK_INT >= 33) {
+            parcelable = resultData.getParcelable("androidx.identitycredentials.BUNDLE_KEY_PROVIDER_DATA", Intent.class);
+            intent = (Intent) parcelable;
+        } else {
+            intent = (Intent) resultData.getParcelable("androidx.identitycredentials.BUNDLE_KEY_PROVIDER_DATA");
+        }
+        if (intent == null) {
+            throw INSTANCE.newUnknownException("Provider result is empty");
+        }
+        if (intent.hasExtra("androidx.identitycredentials.EXTRA_CREDENTIAL_TYPE")) {
+            String stringExtra = intent.getStringExtra("androidx.identitycredentials.EXTRA_CREDENTIAL_TYPE");
+            Bundle bundleExtra = intent.getBundleExtra("androidx.identitycredentials.EXTRA_CREDENTIAL_DATA");
+            if (stringExtra == null || bundleExtra == null) {
+                throw INSTANCE.newUnknownException("Credential result is empty");
+            }
+            return new GetCredentialResponse(new Credential(stringExtra, bundleExtra));
+        }
+        if (!intent.hasExtra("androidx.identitycredentials.EXTRA_EXCEPTION_TYPE")) {
+            throw INSTANCE.newUnknownException("Unknown provider error");
+        }
+        String stringExtra2 = intent.getStringExtra("androidx.identitycredentials.EXTRA_EXCEPTION_TYPE");
+        if (stringExtra2 == null) {
+            throw INSTANCE.newUnknownException("Unknown provider error");
+        }
+        throw new GetCredentialException(stringExtra2, intent.getStringExtra("androidx.identitycredentials.EXTRA_EXCEPTION_MESSAGE"));
+    }
+
+    private final GetCredentialException newUnknownException(String str) {
+        return new GetCredentialException("android.credentials.GetCredentialException.TYPE_UNKNOWN", str);
+    }
+
+    public static final void setGetCredentialException(@NonNull Intent intent, @NonNull String errorType, String str) {
+        Intrinsics.checkNotNullParameter(intent, "intent");
+        Intrinsics.checkNotNullParameter(errorType, "errorType");
+        intent.putExtra("androidx.identitycredentials.EXTRA_EXCEPTION_TYPE", errorType);
+        intent.putExtra("androidx.identitycredentials.EXTRA_EXCEPTION_MESSAGE", str);
+    }
+
+    public static final void setGetCredentialResponse(@NonNull Intent intent, @NonNull GetCredentialResponse response) {
+        Intrinsics.checkNotNullParameter(intent, "intent");
+        Intrinsics.checkNotNullParameter(response, "response");
+        intent.putExtra("androidx.identitycredentials.EXTRA_CREDENTIAL_TYPE", response.getCredential().getType());
+        intent.putExtra("androidx.identitycredentials.EXTRA_CREDENTIAL_DATA", response.getCredential().getData());
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/PendingGetCredentialHandle.java

@@ -0,0 +1,45 @@
+package com.google.android.gms.identitycredentials;
+
+import android.app.PendingIntent;
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+@SafeParcelable.Class(creator = "PendingGetCredentialHandleCreator")
+/* loaded from: classes2.dex */
+public final class PendingGetCredentialHandle extends AbstractSafeParcelable {
+
+    @SafeParcelable.Field(getter = "getPendingIntent", id = 1)
+    private final PendingIntent pendingIntent;
+    public static final Companion Companion = new Companion(null);
+    public static final Parcelable.Creator<PendingGetCredentialHandle> CREATOR = new PendingGetCredentialHandleCreator();
+
+    public static final class Companion {
+        private Companion() {
+        }
+
+        public /* synthetic */ Companion(@NonNull DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+    }
+
+    @SafeParcelable.Constructor
+    public PendingGetCredentialHandle(@NonNull @SafeParcelable.Param(id = 1) PendingIntent pendingIntent) {
+        Intrinsics.checkNotNullParameter(pendingIntent, "pendingIntent");
+        this.pendingIntent = pendingIntent;
+    }
+
+    public final PendingIntent getPendingIntent() {
+        return this.pendingIntent;
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(@NonNull Parcel dest, int i) {
+        Intrinsics.checkNotNullParameter(dest, "dest");
+        PendingGetCredentialHandleCreator.writeToParcel(this, dest, i);
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/PendingGetCredentialHandleCreator.java

@@ -0,0 +1,42 @@
+package com.google.android.gms.identitycredentials;
+
+import android.app.PendingIntent;
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+
+/* loaded from: classes2.dex */
+public final class PendingGetCredentialHandleCreator implements Parcelable.Creator<PendingGetCredentialHandle> {
+    public static void writeToParcel(PendingGetCredentialHandle pendingGetCredentialHandle, Parcel parcel, int i) {
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeParcelable(parcel, 1, pendingGetCredentialHandle.getPendingIntent(), i, false);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // android.os.Parcelable.Creator
+    @NonNull
+    public PendingGetCredentialHandle createFromParcel(@NonNull Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        PendingIntent pendingIntent = null;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            if (SafeParcelReader.getFieldId(readHeader) != 1) {
+                SafeParcelReader.skipUnknownField(parcel, readHeader);
+            } else {
+                pendingIntent = (PendingIntent) SafeParcelReader.createParcelable(parcel, readHeader, PendingIntent.CREATOR);
+            }
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new PendingGetCredentialHandle(pendingIntent);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // android.os.Parcelable.Creator
+    @NonNull
+    public PendingGetCredentialHandle[] newArray(int i) {
+        return new PendingGetCredentialHandle[i];
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/PendingImportCredentialsHandle.java

@@ -0,0 +1,47 @@
+package com.google.android.gms.identitycredentials;
+
+import android.app.PendingIntent;
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+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.SafeParcelable;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+@ShowFirstParty
+@SafeParcelable.Class(creator = "PendingImportCredentialsHandleCreator")
+/* loaded from: classes2.dex */
+public final class PendingImportCredentialsHandle extends AbstractSafeParcelable {
+
+    @SafeParcelable.Field(getter = "getPendingIntent", id = 1)
+    private final PendingIntent pendingIntent;
+    public static final Companion Companion = new Companion(null);
+    public static final Parcelable.Creator<PendingImportCredentialsHandle> CREATOR = new PendingImportCredentialsHandleCreator();
+
+    public static final class Companion {
+        private Companion() {
+        }
+
+        public /* synthetic */ Companion(@NonNull DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+    }
+
+    @SafeParcelable.Constructor
+    public PendingImportCredentialsHandle(@NonNull @SafeParcelable.Param(id = 1) PendingIntent pendingIntent) {
+        Intrinsics.checkNotNullParameter(pendingIntent, "pendingIntent");
+        this.pendingIntent = pendingIntent;
+    }
+
+    public final PendingIntent getPendingIntent() {
+        return this.pendingIntent;
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(@NonNull Parcel dest, int i) {
+        Intrinsics.checkNotNullParameter(dest, "dest");
+        PendingImportCredentialsHandleCreator.writeToParcel(this, dest, i);
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/PendingImportCredentialsHandleCreator.java

@@ -0,0 +1,42 @@
+package com.google.android.gms.identitycredentials;
+
+import android.app.PendingIntent;
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+
+/* loaded from: classes2.dex */
+public final class PendingImportCredentialsHandleCreator implements Parcelable.Creator<PendingImportCredentialsHandle> {
+    public static void writeToParcel(PendingImportCredentialsHandle pendingImportCredentialsHandle, Parcel parcel, int i) {
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeParcelable(parcel, 1, pendingImportCredentialsHandle.getPendingIntent(), i, false);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // android.os.Parcelable.Creator
+    @NonNull
+    public PendingImportCredentialsHandle createFromParcel(@NonNull Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        PendingIntent pendingIntent = null;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            if (SafeParcelReader.getFieldId(readHeader) != 1) {
+                SafeParcelReader.skipUnknownField(parcel, readHeader);
+            } else {
+                pendingIntent = (PendingIntent) SafeParcelReader.createParcelable(parcel, readHeader, PendingIntent.CREATOR);
+            }
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new PendingImportCredentialsHandle(pendingIntent);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // android.os.Parcelable.Creator
+    @NonNull
+    public PendingImportCredentialsHandle[] newArray(int i) {
+        return new PendingImportCredentialsHandle[i];
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/R.java

@@ -0,0 +1,7 @@
+package com.google.android.gms.identitycredentials;
+
+/* loaded from: classes2.dex */
+public final class R {
+    private R() {
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/RegisterExportResponse.java

@@ -0,0 +1,37 @@
+package com.google.android.gms.identitycredentials;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+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.SafeParcelable;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+@ShowFirstParty
+@SafeParcelable.Class(creator = "RegisterExportResponseCreator")
+/* loaded from: classes2.dex */
+public final class RegisterExportResponse extends AbstractSafeParcelable {
+    public static final Companion Companion = new Companion(null);
+    public static final Parcelable.Creator<RegisterExportResponse> CREATOR = new RegisterExportResponseCreator();
+
+    public static final class Companion {
+        private Companion() {
+        }
+
+        public /* synthetic */ Companion(@NonNull DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+    }
+
+    @SafeParcelable.Constructor
+    public RegisterExportResponse() {
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(@NonNull Parcel dest, int i) {
+        Intrinsics.checkNotNullParameter(dest, "dest");
+        RegisterExportResponseCreator.writeToParcel(this, dest, i);
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/RegisterExportResponseCreator.java

@@ -0,0 +1,35 @@
+package com.google.android.gms.identitycredentials;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+
+/* loaded from: classes2.dex */
+public final class RegisterExportResponseCreator implements Parcelable.Creator<RegisterExportResponse> {
+    public static void writeToParcel(RegisterExportResponse registerExportResponse, Parcel parcel, int i) {
+        SafeParcelWriter.finishObjectHeader(parcel, SafeParcelWriter.beginObjectHeader(parcel));
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // android.os.Parcelable.Creator
+    @NonNull
+    public RegisterExportResponse createFromParcel(@NonNull Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            SafeParcelReader.getFieldId(readHeader);
+            SafeParcelReader.skipUnknownField(parcel, readHeader);
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new RegisterExportResponse();
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // android.os.Parcelable.Creator
+    @NonNull
+    public RegisterExportResponse[] newArray(int i) {
+        return new RegisterExportResponse[i];
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/RegistrationRequest.java

@@ -0,0 +1,106 @@
+package com.google.android.gms.identitycredentials;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlin.text.StringsKt__StringsJVMKt;
+
+@SafeParcelable.Class(creator = "RegistrationRequestCreator")
+@SourceDebugExtension({"SMAP\nRegistrationRequest.kt\nKotlin\n*S Kotlin\n*F\n+ 1 RegistrationRequest.kt\ncom/google/android/gms/identitycredentials/RegistrationRequest\n+ 2 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n*L\n1#1,66:1\n1734#2,3:67\n*S KotlinDebug\n*F\n+ 1 RegistrationRequest.kt\ncom/google/android/gms/identitycredentials/RegistrationRequest\n*L\n47#1:67,3\n*E\n"})
+/* loaded from: classes2.dex */
+public final class RegistrationRequest extends AbstractSafeParcelable {
+    public static final String TAG = "RegistrationRequest";
+
+    @SafeParcelable.Field(getter = "getCredentials", id = 1)
+    private final byte[] credentials;
+
+    @SafeParcelable.Field(getter = "getMatcher", id = 2)
+    private final byte[] matcher;
+
+    @SafeParcelable.Field(defaultValueUnchecked = "java.util.Collections.emptyList()", getter = "getProtocolTypes", id = 5)
+    private final List<String> protocolTypes;
+
+    @SafeParcelable.Field(defaultValue = "", getter = "getRequestType", id = 4)
+    private final String requestType;
+
+    @SafeParcelable.Field(defaultValue = "", getter = "getType", id = 3)
+    private final String type;
+    public static final Companion Companion = new Companion(null);
+    public static final Parcelable.Creator<RegistrationRequest> CREATOR = new RegistrationRequestCreator();
+
+    public static final class Companion {
+        private Companion() {
+        }
+
+        public /* synthetic */ Companion(@NonNull DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+    }
+
+    @SafeParcelable.Constructor
+    public RegistrationRequest(@NonNull @SafeParcelable.Param(id = 1) byte[] credentials, @NonNull @SafeParcelable.Param(id = 2) byte[] matcher, @NonNull @SafeParcelable.Param(id = 3) String type, @NonNull @SafeParcelable.Param(id = 4) String requestType, @NonNull @SafeParcelable.Param(id = 5) List<String> protocolTypes) {
+        boolean z;
+        Intrinsics.checkNotNullParameter(credentials, "credentials");
+        Intrinsics.checkNotNullParameter(matcher, "matcher");
+        Intrinsics.checkNotNullParameter(type, "type");
+        Intrinsics.checkNotNullParameter(requestType, "requestType");
+        Intrinsics.checkNotNullParameter(protocolTypes, "protocolTypes");
+        this.credentials = credentials;
+        this.matcher = matcher;
+        this.type = type;
+        this.requestType = requestType;
+        this.protocolTypes = protocolTypes;
+        if (!StringsKt__StringsJVMKt.isBlank(requestType) && !protocolTypes.isEmpty()) {
+            List<String> list = protocolTypes;
+            if (!(list instanceof Collection) || !list.isEmpty()) {
+                Iterator<T> it = list.iterator();
+                while (it.hasNext()) {
+                    if (!StringsKt__StringsJVMKt.isBlank((String) it.next())) {
+                        z = true;
+                        break;
+                    }
+                }
+            }
+        }
+        z = false;
+        boolean z2 = !StringsKt__StringsJVMKt.isBlank(this.type) && this.requestType.length() == 0 && this.protocolTypes.isEmpty();
+        if (z || z2) {
+            return;
+        }
+        throw new IllegalArgumentException("Either type: " + this.type + ", or requestType: " + this.requestType + " and protocolTypes: " + this.protocolTypes + " must be specified, but all were blank, or for protocolTypes, empty or full of blank elements.");
+    }
+
+    public final byte[] getCredentials() {
+        return this.credentials;
+    }
+
+    public final byte[] getMatcher() {
+        return this.matcher;
+    }
+
+    public final List<String> getProtocolTypes() {
+        return this.protocolTypes;
+    }
+
+    public final String getRequestType() {
+        return this.requestType;
+    }
+
+    public final String getType() {
+        return this.type;
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(@NonNull Parcel dest, int i) {
+        Intrinsics.checkNotNullParameter(dest, "dest");
+        RegistrationRequestCreator.writeToParcel(this, dest, i);
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/RegistrationRequestCreator.java

@@ -0,0 +1,60 @@
+package com.google.android.gms.identitycredentials;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes2.dex */
+public final class RegistrationRequestCreator implements Parcelable.Creator<RegistrationRequest> {
+    public static void writeToParcel(RegistrationRequest registrationRequest, Parcel parcel, int i) {
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeByteArray(parcel, 1, registrationRequest.getCredentials(), false);
+        SafeParcelWriter.writeByteArray(parcel, 2, registrationRequest.getMatcher(), false);
+        SafeParcelWriter.writeString(parcel, 3, registrationRequest.getType(), false);
+        SafeParcelWriter.writeString(parcel, 4, registrationRequest.getRequestType(), false);
+        SafeParcelWriter.writeStringList(parcel, 5, registrationRequest.getProtocolTypes(), false);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // android.os.Parcelable.Creator
+    @NonNull
+    public RegistrationRequest createFromParcel(@NonNull Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        List emptyList = Collections.emptyList();
+        String str = "";
+        String str2 = str;
+        byte[] bArr = null;
+        byte[] bArr2 = null;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            int fieldId = SafeParcelReader.getFieldId(readHeader);
+            if (fieldId == 1) {
+                bArr = SafeParcelReader.createByteArray(parcel, readHeader);
+            } else if (fieldId == 2) {
+                bArr2 = SafeParcelReader.createByteArray(parcel, readHeader);
+            } else if (fieldId == 3) {
+                str = SafeParcelReader.createString(parcel, readHeader);
+            } else if (fieldId == 4) {
+                str2 = SafeParcelReader.createString(parcel, readHeader);
+            } else if (fieldId != 5) {
+                SafeParcelReader.skipUnknownField(parcel, readHeader);
+            } else {
+                emptyList = SafeParcelReader.createStringList(parcel, readHeader);
+            }
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new RegistrationRequest(bArr, bArr2, str, str2, emptyList);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // android.os.Parcelable.Creator
+    @NonNull
+    public RegistrationRequest[] newArray(int i) {
+        return new RegistrationRequest[i];
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/RegistrationResponse.java

@@ -0,0 +1,35 @@
+package com.google.android.gms.identitycredentials;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+@SafeParcelable.Class(creator = "RegistrationResponseCreator")
+/* loaded from: classes2.dex */
+public final class RegistrationResponse extends AbstractSafeParcelable {
+    public static final Companion Companion = new Companion(null);
+    public static final Parcelable.Creator<RegistrationResponse> CREATOR = new RegistrationResponseCreator();
+
+    public static final class Companion {
+        private Companion() {
+        }
+
+        public /* synthetic */ Companion(@NonNull DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+    }
+
+    @SafeParcelable.Constructor
+    public RegistrationResponse() {
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(@NonNull Parcel dest, int i) {
+        Intrinsics.checkNotNullParameter(dest, "dest");
+        RegistrationResponseCreator.writeToParcel(this, dest, i);
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/RegistrationResponseCreator.java

@@ -0,0 +1,35 @@
+package com.google.android.gms.identitycredentials;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+
+/* loaded from: classes2.dex */
+public final class RegistrationResponseCreator implements Parcelable.Creator<RegistrationResponse> {
+    public static void writeToParcel(RegistrationResponse registrationResponse, Parcel parcel, int i) {
+        SafeParcelWriter.finishObjectHeader(parcel, SafeParcelWriter.beginObjectHeader(parcel));
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // android.os.Parcelable.Creator
+    @NonNull
+    public RegistrationResponse createFromParcel(@NonNull Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            SafeParcelReader.getFieldId(readHeader);
+            SafeParcelReader.skipUnknownField(parcel, readHeader);
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new RegistrationResponse();
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // android.os.Parcelable.Creator
+    @NonNull
+    public RegistrationResponse[] newArray(int i) {
+        return new RegistrationResponse[i];
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/internal/IIdentityCredentialCallbacks.java

@@ -0,0 +1,69 @@
+package com.google.android.gms.identitycredentials.internal;
+
+import android.os.IInterface;
+import android.os.Parcel;
+import android.os.RemoteException;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.api.Status;
+import com.google.android.gms.identitycredentials.ClearRegistryResponse;
+import com.google.android.gms.identitycredentials.PendingGetCredentialHandle;
+import com.google.android.gms.identitycredentials.PendingImportCredentialsHandle;
+import com.google.android.gms.identitycredentials.RegisterExportResponse;
+import com.google.android.gms.identitycredentials.RegistrationResponse;
+import com.google.android.gms.internal.identity_credentials.zzb;
+import com.google.android.gms.internal.identity_credentials.zzc;
+
+/* loaded from: classes2.dex */
+public interface IIdentityCredentialCallbacks extends IInterface {
+
+    public static abstract class Stub extends zzb implements IIdentityCredentialCallbacks {
+        public Stub() {
+            super("com.google.android.gms.identitycredentials.internal.IIdentityCredentialCallbacks");
+        }
+
+        @Override // com.google.android.gms.internal.identity_credentials.zzb
+        public boolean dispatchTransaction(int i, @NonNull Parcel parcel, @NonNull Parcel parcel2, int i2) throws RemoteException {
+            if (i == 1) {
+                Status status = (Status) zzc.zza(parcel, Status.CREATOR);
+                PendingGetCredentialHandle pendingGetCredentialHandle = (PendingGetCredentialHandle) zzc.zza(parcel, PendingGetCredentialHandle.CREATOR);
+                enforceNoDataAvail(parcel);
+                onGetCredential(status, pendingGetCredentialHandle);
+            } else if (i == 2) {
+                Status status2 = (Status) zzc.zza(parcel, Status.CREATOR);
+                RegistrationResponse registrationResponse = (RegistrationResponse) zzc.zza(parcel, RegistrationResponse.CREATOR);
+                enforceNoDataAvail(parcel);
+                onRegisterCredentials(status2, registrationResponse);
+            } else if (i == 3) {
+                Status status3 = (Status) zzc.zza(parcel, Status.CREATOR);
+                ClearRegistryResponse clearRegistryResponse = (ClearRegistryResponse) zzc.zza(parcel, ClearRegistryResponse.CREATOR);
+                enforceNoDataAvail(parcel);
+                onClearRegistry(status3, clearRegistryResponse);
+            } else if (i == 4) {
+                Status status4 = (Status) zzc.zza(parcel, Status.CREATOR);
+                PendingImportCredentialsHandle pendingImportCredentialsHandle = (PendingImportCredentialsHandle) zzc.zza(parcel, PendingImportCredentialsHandle.CREATOR);
+                enforceNoDataAvail(parcel);
+                onImportCredentials(status4, pendingImportCredentialsHandle);
+            } else {
+                if (i != 5) {
+                    return false;
+                }
+                Status status5 = (Status) zzc.zza(parcel, Status.CREATOR);
+                RegisterExportResponse registerExportResponse = (RegisterExportResponse) zzc.zza(parcel, RegisterExportResponse.CREATOR);
+                enforceNoDataAvail(parcel);
+                onRegisterExport(status5, registerExportResponse);
+            }
+            return true;
+        }
+    }
+
+    void onClearRegistry(@NonNull Status status, @Nullable ClearRegistryResponse clearRegistryResponse) throws RemoteException;
+
+    void onGetCredential(@NonNull Status status, @Nullable PendingGetCredentialHandle pendingGetCredentialHandle) throws RemoteException;
+
+    void onImportCredentials(@NonNull Status status, @Nullable PendingImportCredentialsHandle pendingImportCredentialsHandle) throws RemoteException;
+
+    void onRegisterCredentials(@NonNull Status status, @Nullable RegistrationResponse registrationResponse) throws RemoteException;
+
+    void onRegisterExport(@NonNull Status status, @Nullable RegisterExportResponse registerExportResponse) throws RemoteException;
+}

decompiled/sources/com/google/android/gms/identitycredentials/internal/IIdentityCredentialService.java

@@ -0,0 +1,65 @@
+package com.google.android.gms.identitycredentials.internal;
+
+import android.os.IBinder;
+import android.os.IInterface;
+import android.os.Parcel;
+import android.os.RemoteException;
+import androidx.annotation.NonNull;
+import com.google.android.gms.identitycredentials.ClearRegistryRequest;
+import com.google.android.gms.identitycredentials.GetCredentialRequest;
+import com.google.android.gms.identitycredentials.RegistrationRequest;
+import com.google.android.gms.internal.identity_credentials.zza;
+import com.google.android.gms.internal.identity_credentials.zzb;
+import com.google.android.gms.internal.identity_credentials.zzc;
+
+/* loaded from: classes2.dex */
+public interface IIdentityCredentialService extends IInterface {
+
+    public static abstract class Stub extends zzb implements IIdentityCredentialService {
+
+        public static class Proxy extends zza implements IIdentityCredentialService {
+            public Proxy(IBinder iBinder) {
+                super(iBinder, "com.google.android.gms.identitycredentials.internal.IIdentityCredentialService");
+            }
+
+            @Override // com.google.android.gms.identitycredentials.internal.IIdentityCredentialService
+            public void clearRegistry(@NonNull IIdentityCredentialCallbacks iIdentityCredentialCallbacks, @NonNull ClearRegistryRequest clearRegistryRequest) throws RemoteException {
+                Parcel obtainAndWriteInterfaceToken = obtainAndWriteInterfaceToken();
+                zzc.zzc(obtainAndWriteInterfaceToken, iIdentityCredentialCallbacks);
+                zzc.zzb(obtainAndWriteInterfaceToken, clearRegistryRequest);
+                transactAndReadExceptionReturnVoid(3, obtainAndWriteInterfaceToken);
+            }
+
+            @Override // com.google.android.gms.identitycredentials.internal.IIdentityCredentialService
+            public void getCredential(@NonNull IIdentityCredentialCallbacks iIdentityCredentialCallbacks, @NonNull GetCredentialRequest getCredentialRequest) throws RemoteException {
+                Parcel obtainAndWriteInterfaceToken = obtainAndWriteInterfaceToken();
+                zzc.zzc(obtainAndWriteInterfaceToken, iIdentityCredentialCallbacks);
+                zzc.zzb(obtainAndWriteInterfaceToken, getCredentialRequest);
+                transactAndReadExceptionReturnVoid(1, obtainAndWriteInterfaceToken);
+            }
+
+            @Override // com.google.android.gms.identitycredentials.internal.IIdentityCredentialService
+            public void registerCredentials(@NonNull IIdentityCredentialCallbacks iIdentityCredentialCallbacks, @NonNull RegistrationRequest registrationRequest) throws RemoteException {
+                Parcel obtainAndWriteInterfaceToken = obtainAndWriteInterfaceToken();
+                zzc.zzc(obtainAndWriteInterfaceToken, iIdentityCredentialCallbacks);
+                zzc.zzb(obtainAndWriteInterfaceToken, registrationRequest);
+                transactAndReadExceptionReturnVoid(2, obtainAndWriteInterfaceToken);
+            }
+        }
+
+        @NonNull
+        public static IIdentityCredentialService asInterface(@NonNull IBinder iBinder) {
+            if (iBinder == null) {
+                return null;
+            }
+            IInterface queryLocalInterface = iBinder.queryLocalInterface("com.google.android.gms.identitycredentials.internal.IIdentityCredentialService");
+            return queryLocalInterface instanceof IIdentityCredentialService ? (IIdentityCredentialService) queryLocalInterface : new Proxy(iBinder);
+        }
+    }
+
+    void clearRegistry(@NonNull IIdentityCredentialCallbacks iIdentityCredentialCallbacks, @NonNull ClearRegistryRequest clearRegistryRequest) throws RemoteException;
+
+    void getCredential(@NonNull IIdentityCredentialCallbacks iIdentityCredentialCallbacks, @NonNull GetCredentialRequest getCredentialRequest) throws RemoteException;
+
+    void registerCredentials(@NonNull IIdentityCredentialCallbacks iIdentityCredentialCallbacks, @NonNull RegistrationRequest registrationRequest) throws RemoteException;
+}

decompiled/sources/com/google/android/gms/identitycredentials/internal/IdentityCredentialBaseCallbacks.java

@@ -0,0 +1,44 @@
+package com.google.android.gms.identitycredentials.internal;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.api.Status;
+import com.google.android.gms.identitycredentials.ClearRegistryResponse;
+import com.google.android.gms.identitycredentials.PendingGetCredentialHandle;
+import com.google.android.gms.identitycredentials.PendingImportCredentialsHandle;
+import com.google.android.gms.identitycredentials.RegisterExportResponse;
+import com.google.android.gms.identitycredentials.RegistrationResponse;
+import com.google.android.gms.identitycredentials.internal.IIdentityCredentialCallbacks;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes2.dex */
+public abstract class IdentityCredentialBaseCallbacks extends IIdentityCredentialCallbacks.Stub {
+    @Override // com.google.android.gms.identitycredentials.internal.IIdentityCredentialCallbacks
+    public void onClearRegistry(@NonNull Status status, ClearRegistryResponse clearRegistryResponse) {
+        Intrinsics.checkNotNullParameter(status, "status");
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // com.google.android.gms.identitycredentials.internal.IIdentityCredentialCallbacks
+    public void onGetCredential(@NonNull Status status, PendingGetCredentialHandle pendingGetCredentialHandle) {
+        Intrinsics.checkNotNullParameter(status, "status");
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // com.google.android.gms.identitycredentials.internal.IIdentityCredentialCallbacks
+    public void onImportCredentials(@NonNull Status status, PendingImportCredentialsHandle pendingImportCredentialsHandle) {
+        Intrinsics.checkNotNullParameter(status, "status");
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // com.google.android.gms.identitycredentials.internal.IIdentityCredentialCallbacks
+    public void onRegisterCredentials(@NonNull Status status, RegistrationResponse registrationResponse) {
+        Intrinsics.checkNotNullParameter(status, "status");
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // com.google.android.gms.identitycredentials.internal.IIdentityCredentialCallbacks
+    public void onRegisterExport(@NonNull Status status, RegisterExportResponse registerExportResponse) {
+        Intrinsics.checkNotNullParameter(status, "status");
+        throw new UnsupportedOperationException();
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/internal/IdentityCredentialClientImpl.java

@@ -0,0 +1,79 @@
+package com.google.android.gms.identitycredentials.internal;
+
+import android.content.Context;
+import android.os.IBinder;
+import android.os.Looper;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.Feature;
+import com.google.android.gms.common.api.internal.ConnectionCallbacks;
+import com.google.android.gms.common.api.internal.OnConnectionFailedListener;
+import com.google.android.gms.common.internal.ClientSettings;
+import com.google.android.gms.common.internal.GmsClient;
+import com.google.android.gms.identitycredentials.internal.IIdentityCredentialService;
+import com.google.android.gms.internal.identity_credentials.zze;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes2.dex */
+public final class IdentityCredentialClientImpl extends GmsClient<IIdentityCredentialService> {
+    public static final Companion Companion = new Companion(null);
+
+    public static final class Companion {
+        private Companion() {
+        }
+
+        public /* synthetic */ Companion(@NonNull DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public IdentityCredentialClientImpl(@NonNull Context context, @NonNull Looper looper, @NonNull ClientSettings clientSettings, @NonNull ConnectionCallbacks connectionCallbacks, @NonNull OnConnectionFailedListener connectionFailedListener) {
+        super(context, looper, 352, clientSettings, connectionCallbacks, connectionFailedListener);
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(looper, "looper");
+        Intrinsics.checkNotNullParameter(clientSettings, "clientSettings");
+        Intrinsics.checkNotNullParameter(connectionCallbacks, "connectionCallbacks");
+        Intrinsics.checkNotNullParameter(connectionFailedListener, "connectionFailedListener");
+    }
+
+    @Override // com.google.android.gms.common.internal.BaseGmsClient
+    public Feature[] getApiFeatures() {
+        Feature[] ALL_FEATURES = zze.zzd;
+        Intrinsics.checkNotNullExpressionValue(ALL_FEATURES, "ALL_FEATURES");
+        return ALL_FEATURES;
+    }
+
+    @Override // com.google.android.gms.common.internal.BaseGmsClient, com.google.android.gms.common.api.Api.Client
+    public int getMinApkVersion() {
+        return 17895000;
+    }
+
+    @Override // com.google.android.gms.common.internal.BaseGmsClient
+    public String getServiceDescriptor() {
+        return "com.google.android.gms.identitycredentials.internal.IIdentityCredentialService";
+    }
+
+    @Override // com.google.android.gms.common.internal.BaseGmsClient
+    public String getStartServiceAction() {
+        return "com.google.android.gms.identitycredentials.service.START";
+    }
+
+    @Override // com.google.android.gms.common.internal.BaseGmsClient
+    public boolean getUseDynamicLookup() {
+        return true;
+    }
+
+    @Override // com.google.android.gms.common.internal.BaseGmsClient
+    public boolean usesClientTelemetry() {
+        return true;
+    }
+
+    @Override // com.google.android.gms.common.internal.BaseGmsClient
+    @Nullable
+    public IIdentityCredentialService createServiceInterface(@NonNull IBinder iBinder) {
+        Intrinsics.checkNotNullParameter(iBinder, "iBinder");
+        return IIdentityCredentialService.Stub.asInterface(iBinder);
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/internal/InternalIdentityCredentialClient.java

@@ -0,0 +1,117 @@
+package com.google.android.gms.identitycredentials.internal;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.GoogleApi;
+import com.google.android.gms.common.api.Status;
+import com.google.android.gms.common.api.internal.RemoteCall;
+import com.google.android.gms.common.api.internal.TaskApiCall;
+import com.google.android.gms.common.api.internal.TaskUtil;
+import com.google.android.gms.identitycredentials.ClearRegistryRequest;
+import com.google.android.gms.identitycredentials.ClearRegistryResponse;
+import com.google.android.gms.identitycredentials.GetCredentialRequest;
+import com.google.android.gms.identitycredentials.IdentityCredentialClient;
+import com.google.android.gms.identitycredentials.PendingGetCredentialHandle;
+import com.google.android.gms.identitycredentials.RegistrationRequest;
+import com.google.android.gms.identitycredentials.RegistrationResponse;
+import com.google.android.gms.internal.identity_credentials.zze;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.TaskCompletionSource;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes2.dex */
+public final class InternalIdentityCredentialClient extends GoogleApi<Api.ApiOptions.NoOptions> implements IdentityCredentialClient {
+    /* 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 InternalIdentityCredentialClient(@androidx.annotation.NonNull android.content.Context r4) {
+        /*
+            r3 = this;
+            java.lang.String r0 = "context"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r4, r0)
+            com.google.android.gms.common.api.Api r0 = com.google.android.gms.identitycredentials.internal.InternalIdentityCredentialClientKt.access$getAPI$p()
+            com.google.android.gms.common.api.Api$ApiOptions$NoOptions r1 = com.google.android.gms.common.api.Api.ApiOptions.NO_OPTIONS
+            com.google.android.gms.common.api.GoogleApi$Settings r2 = com.google.android.gms.common.api.GoogleApi.Settings.DEFAULT_SETTINGS
+            r3.<init>(r4, r0, r1, r2)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.android.gms.identitycredentials.internal.InternalIdentityCredentialClient.<init>(android.content.Context):void");
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void clearRegistry$lambda$2(ClearRegistryRequest request, IdentityCredentialClientImpl identityCredentialClientImpl, final TaskCompletionSource taskCompletionSource) {
+        Intrinsics.checkNotNullParameter(request, "$request");
+        ((IIdentityCredentialService) identityCredentialClientImpl.getService()).clearRegistry(new IdentityCredentialBaseCallbacks() { // from class: com.google.android.gms.identitycredentials.internal.InternalIdentityCredentialClient$clearRegistry$1$callback$1
+            @Override // com.google.android.gms.identitycredentials.internal.IdentityCredentialBaseCallbacks, com.google.android.gms.identitycredentials.internal.IIdentityCredentialCallbacks
+            public void onClearRegistry(@NonNull Status status, @NonNull ClearRegistryResponse clearRegistryResponse) {
+                Intrinsics.checkNotNullParameter(status, "status");
+                TaskUtil.setResultOrApiException(status, clearRegistryResponse, taskCompletionSource);
+            }
+        }, request);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void getCredential$lambda$0(GetCredentialRequest request, IdentityCredentialClientImpl identityCredentialClientImpl, final TaskCompletionSource taskCompletionSource) {
+        Intrinsics.checkNotNullParameter(request, "$request");
+        ((IIdentityCredentialService) identityCredentialClientImpl.getService()).getCredential(new IdentityCredentialBaseCallbacks() { // from class: com.google.android.gms.identitycredentials.internal.InternalIdentityCredentialClient$getCredential$1$callback$1
+            @Override // com.google.android.gms.identitycredentials.internal.IdentityCredentialBaseCallbacks, com.google.android.gms.identitycredentials.internal.IIdentityCredentialCallbacks
+            public void onGetCredential(@NonNull Status status, @NonNull PendingGetCredentialHandle pendingGetCredentialHandle) {
+                Intrinsics.checkNotNullParameter(status, "status");
+                TaskUtil.setResultOrApiException(status, pendingGetCredentialHandle, taskCompletionSource);
+            }
+        }, request);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void registerCredentials$lambda$1(RegistrationRequest request, IdentityCredentialClientImpl identityCredentialClientImpl, final TaskCompletionSource taskCompletionSource) {
+        Intrinsics.checkNotNullParameter(request, "$request");
+        ((IIdentityCredentialService) identityCredentialClientImpl.getService()).registerCredentials(new IdentityCredentialBaseCallbacks() { // from class: com.google.android.gms.identitycredentials.internal.InternalIdentityCredentialClient$registerCredentials$1$callback$1
+            @Override // com.google.android.gms.identitycredentials.internal.IdentityCredentialBaseCallbacks, com.google.android.gms.identitycredentials.internal.IIdentityCredentialCallbacks
+            public void onRegisterCredentials(@NonNull Status status, @NonNull RegistrationResponse registrationResponse) {
+                Intrinsics.checkNotNullParameter(status, "status");
+                TaskUtil.setResultOrApiException(status, registrationResponse, taskCompletionSource);
+            }
+        }, request);
+    }
+
+    @Override // com.google.android.gms.identitycredentials.IdentityCredentialClient
+    public Task<ClearRegistryResponse> clearRegistry(@NonNull final ClearRegistryRequest request) {
+        Intrinsics.checkNotNullParameter(request, "request");
+        Task doWrite = doWrite(TaskApiCall.builder().setFeatures(zze.zzc).run(new RemoteCall() { // from class: com.google.android.gms.identitycredentials.internal.InternalIdentityCredentialClient$$ExternalSyntheticLambda1
+            @Override // com.google.android.gms.common.api.internal.RemoteCall
+            public final void accept(@NonNull Object obj, @NonNull Object obj2) {
+                InternalIdentityCredentialClient.clearRegistry$lambda$2(ClearRegistryRequest.this, (IdentityCredentialClientImpl) obj, (TaskCompletionSource) obj2);
+            }
+        }).setMethodKey(32703).build());
+        Intrinsics.checkNotNullExpressionValue(doWrite, "doWrite(...)");
+        return doWrite;
+    }
+
+    @Override // com.google.android.gms.identitycredentials.IdentityCredentialClient
+    public Task<PendingGetCredentialHandle> getCredential(@NonNull final GetCredentialRequest request) {
+        Intrinsics.checkNotNullParameter(request, "request");
+        Task doRead = doRead(TaskApiCall.builder().setFeatures(zze.zza).run(new RemoteCall() { // from class: com.google.android.gms.identitycredentials.internal.InternalIdentityCredentialClient$$ExternalSyntheticLambda3
+            @Override // com.google.android.gms.common.api.internal.RemoteCall
+            public final void accept(@NonNull Object obj, @NonNull Object obj2) {
+                InternalIdentityCredentialClient.getCredential$lambda$0(GetCredentialRequest.this, (IdentityCredentialClientImpl) obj, (TaskCompletionSource) obj2);
+            }
+        }).setMethodKey(32701).build());
+        Intrinsics.checkNotNullExpressionValue(doRead, "doRead(...)");
+        return doRead;
+    }
+
+    @Override // com.google.android.gms.identitycredentials.IdentityCredentialClient
+    public Task<RegistrationResponse> registerCredentials(@NonNull final RegistrationRequest request) {
+        Intrinsics.checkNotNullParameter(request, "request");
+        Task doWrite = doWrite(TaskApiCall.builder().setFeatures(zze.zzb).run(new RemoteCall() { // from class: com.google.android.gms.identitycredentials.internal.InternalIdentityCredentialClient$$ExternalSyntheticLambda4
+            @Override // com.google.android.gms.common.api.internal.RemoteCall
+            public final void accept(@NonNull Object obj, @NonNull Object obj2) {
+                InternalIdentityCredentialClient.registerCredentials$lambda$1(RegistrationRequest.this, (IdentityCredentialClientImpl) obj, (TaskCompletionSource) obj2);
+            }
+        }).setMethodKey(32702).build());
+        Intrinsics.checkNotNullExpressionValue(doWrite, "doWrite(...)");
+        return doWrite;
+    }
+}

decompiled/sources/com/google/android/gms/identitycredentials/internal/InternalIdentityCredentialClientKt.java

@@ -0,0 +1,38 @@
+package com.google.android.gms.identitycredentials.internal;
+
+import android.content.Context;
+import android.os.Looper;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.internal.ConnectionCallbacks;
+import com.google.android.gms.common.api.internal.OnConnectionFailedListener;
+import com.google.android.gms.common.internal.ClientSettings;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes2.dex */
+public final class InternalIdentityCredentialClientKt {
+    private static final Api<Api.ApiOptions.NoOptions> API;
+    private static final Api.ClientKey<IdentityCredentialClientImpl> CLIENT_KEY;
+    private static final InternalIdentityCredentialClientKt$clientBuilder$1 clientBuilder;
+
+    /* JADX WARN: Type inference failed for: r1v0, types: [com.google.android.gms.common.api.Api$AbstractClientBuilder, com.google.android.gms.identitycredentials.internal.InternalIdentityCredentialClientKt$clientBuilder$1] */
+    static {
+        Api.ClientKey<IdentityCredentialClientImpl> clientKey = new Api.ClientKey<>();
+        CLIENT_KEY = clientKey;
+        ?? r1 = new Api.AbstractClientBuilder<IdentityCredentialClientImpl, Api.ApiOptions.NoOptions>() { // from class: com.google.android.gms.identitycredentials.internal.InternalIdentityCredentialClientKt$clientBuilder$1
+            @Override // com.google.android.gms.common.api.Api.AbstractClientBuilder
+            @NonNull
+            public IdentityCredentialClientImpl buildClient(@NonNull Context context, @NonNull Looper looper, @NonNull ClientSettings commonSettings, @NonNull Api.ApiOptions.NoOptions apiOptions, @NonNull ConnectionCallbacks connectedListener, @NonNull OnConnectionFailedListener connectionFailedListener) {
+                Intrinsics.checkNotNullParameter(context, "context");
+                Intrinsics.checkNotNullParameter(looper, "looper");
+                Intrinsics.checkNotNullParameter(commonSettings, "commonSettings");
+                Intrinsics.checkNotNullParameter(apiOptions, "apiOptions");
+                Intrinsics.checkNotNullParameter(connectedListener, "connectedListener");
+                Intrinsics.checkNotNullParameter(connectionFailedListener, "connectionFailedListener");
+                return new IdentityCredentialClientImpl(context, looper, commonSettings, connectedListener, connectionFailedListener);
+            }
+        };
+        clientBuilder = r1;
+        API = new Api<>("IdentityCredentials.API", r1, clientKey);
+    }
+}