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/androidx/credentials/Api35Impl$setPendingGetCredentialRequest$frameworkCallback$1$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,8 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class Api35Impl$setPendingGetCredentialRequest$frameworkCallback$1$$ExternalSyntheticApiModelOutline0 {
+    public static /* bridge */ /* synthetic */ android.credentials.GetCredentialResponse m(Object obj) {
+        return (android.credentials.GetCredentialResponse) obj;
+    }
+}

decompiled/sources/androidx/credentials/Api35Impl$setPendingGetCredentialRequest$frameworkCallback$1$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class Api35Impl$setPendingGetCredentialRequest$frameworkCallback$1$$ExternalSyntheticApiModelOutline1 {
+}

decompiled/sources/androidx/credentials/Api35Impl$setPendingGetCredentialRequest$frameworkCallback$1$$ExternalSyntheticApiModelOutline2.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class Api35Impl$setPendingGetCredentialRequest$frameworkCallback$1$$ExternalSyntheticApiModelOutline2 {
+}

decompiled/sources/androidx/credentials/Api35Impl$setPendingGetCredentialRequest$frameworkCallback$1$$ExternalSyntheticApiModelOutline3.java

@@ -0,0 +1,10 @@
+package androidx.credentials;
+
+import android.credentials.GetCredentialException;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class Api35Impl$setPendingGetCredentialRequest$frameworkCallback$1$$ExternalSyntheticApiModelOutline3 {
+    public static /* bridge */ /* synthetic */ GetCredentialException m(Object obj) {
+        return (GetCredentialException) obj;
+    }
+}

decompiled/sources/androidx/credentials/Api35Impl.java

@@ -0,0 +1,59 @@
+package androidx.credentials;
+
+import android.credentials.GetCredentialException;
+import android.os.OutcomeReceiver;
+import android.util.Log;
+import android.view.View;
+import androidx.annotation.RequiresApi;
+import androidx.core.os.OutcomeReceiverKt$$ExternalSyntheticApiModelOutline0;
+import androidx.credentials.internal.FrameworkImplHelper;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+
+@RequiresApi(35)
+/* loaded from: classes.dex */
+final class Api35Impl {
+    public static final Api35Impl INSTANCE = new Api35Impl();
+
+    private Api35Impl() {
+    }
+
+    public final void setPendingGetCredentialRequest(View view, GetCredentialRequest request, final Function1 callback) {
+        Intrinsics.checkNotNullParameter(view, "view");
+        Intrinsics.checkNotNullParameter(request, "request");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        view.setPendingCredentialRequest(FrameworkImplHelper.Companion.convertGetRequestToFrameworkClass(request), OutcomeReceiverKt$$ExternalSyntheticApiModelOutline0.m(new OutcomeReceiver() { // from class: androidx.credentials.Api35Impl$setPendingGetCredentialRequest$frameworkCallback$1
+            public /* bridge */ /* synthetic */ void onError(Throwable th) {
+                onError(Api35Impl$setPendingGetCredentialRequest$frameworkCallback$1$$ExternalSyntheticApiModelOutline3.m(th));
+            }
+
+            public /* bridge */ /* synthetic */ void onResult(Object obj) {
+                onResult(Api35Impl$setPendingGetCredentialRequest$frameworkCallback$1$$ExternalSyntheticApiModelOutline0.m(obj));
+            }
+
+            public void onResult(android.credentials.GetCredentialResponse response) {
+                Intrinsics.checkNotNullParameter(response, "response");
+                Function1.this.invoke(FrameworkImplHelper.Companion.convertGetResponseToJetpackClass(response));
+            }
+
+            public void onError(GetCredentialException error) {
+                String type;
+                String message;
+                Intrinsics.checkNotNullParameter(error, "error");
+                StringBuilder sb = new StringBuilder();
+                sb.append("Error: ");
+                type = error.getType();
+                sb.append(type);
+                sb.append(" , ");
+                message = error.getMessage();
+                sb.append(message);
+                Log.w("ViewHandler", sb.toString());
+            }
+        }));
+    }
+
+    public final void clearPendingGetCredentialRequest(View view) {
+        Intrinsics.checkNotNullParameter(view, "view");
+        view.clearPendingCredentialRequest();
+    }
+}

decompiled/sources/androidx/credentials/ClearCredentialRequestTypes.java

@@ -0,0 +1,14 @@
+package androidx.credentials;
+
+import androidx.annotation.RestrictTo;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER, ElementType.TYPE_USE})
+@Retention(RetentionPolicy.SOURCE)
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public @interface ClearCredentialRequestTypes {
+}

decompiled/sources/androidx/credentials/ClearCredentialStateRequest.java

@@ -0,0 +1,54 @@
+package androidx.credentials;
+
+import android.os.Bundle;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class ClearCredentialStateRequest {
+    private static final String BUNDLE_KEY_CLEAR_RESTORE_CREDENTIAL_REQUEST = "androidx.credentials.BUNDLE_KEY_CLEAR_RESTORE_CREDENTIAL_REQUEST";
+    public static final Companion Companion = new Companion(null);
+    public static final String TYPE_CLEAR_CREDENTIAL_STATE = "androidx.credentials.TYPE_CLEAR_CREDENTIAL_STATE";
+    public static final String TYPE_CLEAR_RESTORE_CREDENTIAL = "androidx.credentials.TYPE_CLEAR_RESTORE_CREDENTIAL";
+    private final Bundle requestBundle;
+    private final String requestType;
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public ClearCredentialStateRequest() {
+        this(null, 1, 0 == true ? 1 : 0);
+    }
+
+    public final Bundle getRequestBundle() {
+        return this.requestBundle;
+    }
+
+    public final String getRequestType() {
+        return this.requestType;
+    }
+
+    public ClearCredentialStateRequest(String requestType) {
+        Intrinsics.checkNotNullParameter(requestType, "requestType");
+        this.requestType = requestType;
+        Bundle bundle = new Bundle();
+        this.requestBundle = bundle;
+        if (!Intrinsics.areEqual(requestType, TYPE_CLEAR_CREDENTIAL_STATE) && !Intrinsics.areEqual(requestType, TYPE_CLEAR_RESTORE_CREDENTIAL)) {
+            throw new IllegalArgumentException("The request type " + requestType + " is not supported.");
+        }
+        if (Intrinsics.areEqual(requestType, TYPE_CLEAR_RESTORE_CREDENTIAL)) {
+            bundle.putBoolean(BUNDLE_KEY_CLEAR_RESTORE_CREDENTIAL_REQUEST, true);
+        }
+    }
+
+    public /* synthetic */ ClearCredentialStateRequest(String str, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this((i & 1) != 0 ? TYPE_CLEAR_CREDENTIAL_STATE : str);
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+    }
+}

decompiled/sources/androidx/credentials/CreateCredentialRequest$Companion$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CreateCredentialRequest$Companion$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/credentials/CreateCredentialRequest$Companion$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CreateCredentialRequest$Companion$$ExternalSyntheticApiModelOutline1 {
+}

decompiled/sources/androidx/credentials/CreateCredentialRequest$Companion$$ExternalSyntheticApiModelOutline2.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CreateCredentialRequest$Companion$$ExternalSyntheticApiModelOutline2 {
+}

decompiled/sources/androidx/credentials/CreateCredentialRequest$Companion$$ExternalSyntheticApiModelOutline3.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CreateCredentialRequest$Companion$$ExternalSyntheticApiModelOutline3 {
+}

decompiled/sources/androidx/credentials/CreateCredentialRequest$Companion$$ExternalSyntheticApiModelOutline4.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CreateCredentialRequest$Companion$$ExternalSyntheticApiModelOutline4 {
+}

decompiled/sources/androidx/credentials/CreateCredentialRequest.java

@@ -0,0 +1,277 @@
+package androidx.credentials;
+
+import android.graphics.drawable.Icon;
+import android.os.Bundle;
+import android.text.TextUtils;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.credentials.internal.FrameworkClassParsingException;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+/* loaded from: classes.dex */
+public abstract class CreateCredentialRequest {
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static final String BUNDLE_KEY_IS_AUTO_SELECT_ALLOWED = "androidx.credentials.BUNDLE_KEY_IS_AUTO_SELECT_ALLOWED";
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static final String BUNDLE_KEY_PREFER_IMMEDIATELY_AVAILABLE_CREDENTIALS = "androidx.credentials.BUNDLE_KEY_PREFER_IMMEDIATELY_AVAILABLE_CREDENTIALS";
+    public static final Companion Companion = new Companion(null);
+    private final Bundle candidateQueryData;
+    private final Bundle credentialData;
+    private final DisplayInfo displayInfo;
+    private final boolean isAutoSelectAllowed;
+    private final boolean isSystemProviderRequired;
+    private final String origin;
+    private final boolean preferImmediatelyAvailableCredentials;
+    private final String type;
+
+    @RequiresApi(34)
+    public static final CreateCredentialRequest createFrom(android.credentials.CreateCredentialRequest createCredentialRequest) {
+        return Companion.createFrom(createCredentialRequest);
+    }
+
+    @RequiresApi(23)
+    public static final CreateCredentialRequest createFrom(String str, Bundle bundle, Bundle bundle2, boolean z) {
+        return Companion.createFrom(str, bundle, bundle2, z);
+    }
+
+    @RequiresApi(23)
+    public static final CreateCredentialRequest createFrom(String str, Bundle bundle, Bundle bundle2, boolean z, String str2) {
+        return Companion.createFrom(str, bundle, bundle2, z, str2);
+    }
+
+    public final Bundle getCandidateQueryData() {
+        return this.candidateQueryData;
+    }
+
+    public final Bundle getCredentialData() {
+        return this.credentialData;
+    }
+
+    public final DisplayInfo getDisplayInfo() {
+        return this.displayInfo;
+    }
+
+    public final String getOrigin() {
+        return this.origin;
+    }
+
+    public final String getType() {
+        return this.type;
+    }
+
+    public final boolean isAutoSelectAllowed() {
+        return this.isAutoSelectAllowed;
+    }
+
+    public final boolean isSystemProviderRequired() {
+        return this.isSystemProviderRequired;
+    }
+
+    public final boolean preferImmediatelyAvailableCredentials() {
+        return this.preferImmediatelyAvailableCredentials;
+    }
+
+    public CreateCredentialRequest(String type, Bundle credentialData, Bundle candidateQueryData, boolean z, boolean z2, DisplayInfo displayInfo, String str, boolean z3) {
+        Intrinsics.checkNotNullParameter(type, "type");
+        Intrinsics.checkNotNullParameter(credentialData, "credentialData");
+        Intrinsics.checkNotNullParameter(candidateQueryData, "candidateQueryData");
+        Intrinsics.checkNotNullParameter(displayInfo, "displayInfo");
+        this.type = type;
+        this.credentialData = credentialData;
+        this.candidateQueryData = candidateQueryData;
+        this.isSystemProviderRequired = z;
+        this.isAutoSelectAllowed = z2;
+        this.displayInfo = displayInfo;
+        this.origin = str;
+        this.preferImmediatelyAvailableCredentials = z3;
+        credentialData.putBoolean("androidx.credentials.BUNDLE_KEY_IS_AUTO_SELECT_ALLOWED", z2);
+        credentialData.putBoolean("androidx.credentials.BUNDLE_KEY_PREFER_IMMEDIATELY_AVAILABLE_CREDENTIALS", z3);
+        candidateQueryData.putBoolean("androidx.credentials.BUNDLE_KEY_IS_AUTO_SELECT_ALLOWED", z2);
+    }
+
+    @SourceDebugExtension({"SMAP\nCreateCredentialRequest.kt\nKotlin\n*S Kotlin\n*F\n+ 1 CreateCredentialRequest.kt\nandroidx/credentials/CreateCredentialRequest$DisplayInfo\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,308:1\n1#2:309\n*E\n"})
+    public static final class DisplayInfo {
+
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public static final String BUNDLE_KEY_CREDENTIAL_TYPE_ICON = "androidx.credentials.BUNDLE_KEY_CREDENTIAL_TYPE_ICON";
+        public static final String BUNDLE_KEY_DEFAULT_PROVIDER = "androidx.credentials.BUNDLE_KEY_DEFAULT_PROVIDER";
+
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public static final String BUNDLE_KEY_REQUEST_DISPLAY_INFO = "androidx.credentials.BUNDLE_KEY_REQUEST_DISPLAY_INFO";
+        public static final String BUNDLE_KEY_USER_DISPLAY_NAME = "androidx.credentials.BUNDLE_KEY_USER_DISPLAY_NAME";
+
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public static final String BUNDLE_KEY_USER_ID = "androidx.credentials.BUNDLE_KEY_USER_ID";
+        public static final Companion Companion = new Companion(null);
+        private final Icon credentialTypeIcon;
+        private final String preferDefaultProvider;
+        private final CharSequence userDisplayName;
+        private final CharSequence userId;
+
+        /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+        /* JADX WARN: Multi-variable type inference failed */
+        public DisplayInfo(CharSequence userId) {
+            this(userId, (CharSequence) null, 2, (DefaultConstructorMarker) (0 == true ? 1 : 0));
+            Intrinsics.checkNotNullParameter(userId, "userId");
+        }
+
+        @RequiresApi(23)
+        public static final DisplayInfo createFrom(Bundle bundle) {
+            return Companion.createFrom(bundle);
+        }
+
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public final Icon getCredentialTypeIcon() {
+            return this.credentialTypeIcon;
+        }
+
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public final String getPreferDefaultProvider() {
+            return this.preferDefaultProvider;
+        }
+
+        public final CharSequence getUserDisplayName() {
+            return this.userDisplayName;
+        }
+
+        public final CharSequence getUserId() {
+            return this.userId;
+        }
+
+        public DisplayInfo(CharSequence userId, CharSequence charSequence, Icon icon, String str) {
+            Intrinsics.checkNotNullParameter(userId, "userId");
+            this.userId = userId;
+            this.userDisplayName = charSequence;
+            this.credentialTypeIcon = icon;
+            this.preferDefaultProvider = str;
+            if (userId.length() <= 0) {
+                throw new IllegalArgumentException("userId should not be empty".toString());
+            }
+        }
+
+        public /* synthetic */ DisplayInfo(CharSequence charSequence, CharSequence charSequence2, int i, DefaultConstructorMarker defaultConstructorMarker) {
+            this(charSequence, (i & 2) != 0 ? null : charSequence2);
+        }
+
+        /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+        public DisplayInfo(CharSequence userId, CharSequence charSequence) {
+            this(userId, charSequence, (Icon) null, (String) null);
+            Intrinsics.checkNotNullParameter(userId, "userId");
+        }
+
+        /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+        public DisplayInfo(CharSequence userId, CharSequence charSequence, String str) {
+            this(userId, charSequence, (Icon) null, str);
+            Intrinsics.checkNotNullParameter(userId, "userId");
+        }
+
+        @RequiresApi(23)
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public final Bundle toBundle() {
+            Bundle bundle = new Bundle();
+            bundle.putCharSequence(BUNDLE_KEY_USER_ID, this.userId);
+            if (!TextUtils.isEmpty(this.userDisplayName)) {
+                bundle.putCharSequence(BUNDLE_KEY_USER_DISPLAY_NAME, this.userDisplayName);
+            }
+            if (!TextUtils.isEmpty(this.preferDefaultProvider)) {
+                bundle.putString(BUNDLE_KEY_DEFAULT_PROVIDER, this.preferDefaultProvider);
+            }
+            return bundle;
+        }
+
+        public static final class Companion {
+            public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+                this();
+            }
+
+            private Companion() {
+            }
+
+            @RequiresApi(23)
+            public final DisplayInfo createFrom(Bundle from) {
+                Intrinsics.checkNotNullParameter(from, "from");
+                try {
+                    Bundle bundle = from.getBundle(DisplayInfo.BUNDLE_KEY_REQUEST_DISPLAY_INFO);
+                    Intrinsics.checkNotNull(bundle);
+                    CharSequence charSequence = bundle.getCharSequence(DisplayInfo.BUNDLE_KEY_USER_ID);
+                    CharSequence charSequence2 = bundle.getCharSequence(DisplayInfo.BUNDLE_KEY_USER_DISPLAY_NAME);
+                    Icon icon = (Icon) bundle.getParcelable(DisplayInfo.BUNDLE_KEY_CREDENTIAL_TYPE_ICON);
+                    String string = bundle.getString(DisplayInfo.BUNDLE_KEY_DEFAULT_PROVIDER);
+                    Intrinsics.checkNotNull(charSequence);
+                    return new DisplayInfo(charSequence, charSequence2, icon, string);
+                } catch (Exception e) {
+                    throw new IllegalArgumentException(e);
+                }
+            }
+        }
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        @RequiresApi(23)
+        public final CreateCredentialRequest createFrom(String type, Bundle credentialData, Bundle candidateQueryData, boolean z) {
+            Intrinsics.checkNotNullParameter(type, "type");
+            Intrinsics.checkNotNullParameter(credentialData, "credentialData");
+            Intrinsics.checkNotNullParameter(candidateQueryData, "candidateQueryData");
+            return createFrom$default(this, type, credentialData, candidateQueryData, z, null, 16, null);
+        }
+
+        private Companion() {
+        }
+
+        @RequiresApi(34)
+        public final CreateCredentialRequest createFrom(android.credentials.CreateCredentialRequest request) {
+            String type;
+            Bundle credentialData;
+            Bundle candidateQueryData;
+            boolean isSystemProviderRequired;
+            String origin;
+            Intrinsics.checkNotNullParameter(request, "request");
+            type = request.getType();
+            Intrinsics.checkNotNullExpressionValue(type, "request.type");
+            credentialData = request.getCredentialData();
+            Intrinsics.checkNotNullExpressionValue(credentialData, "request.credentialData");
+            candidateQueryData = request.getCandidateQueryData();
+            Intrinsics.checkNotNullExpressionValue(candidateQueryData, "request.candidateQueryData");
+            isSystemProviderRequired = request.isSystemProviderRequired();
+            origin = request.getOrigin();
+            return createFrom(type, credentialData, candidateQueryData, isSystemProviderRequired, origin);
+        }
+
+        public static /* synthetic */ CreateCredentialRequest createFrom$default(Companion companion, String str, Bundle bundle, Bundle bundle2, boolean z, String str2, int i, Object obj) {
+            if ((i & 16) != 0) {
+                str2 = null;
+            }
+            return companion.createFrom(str, bundle, bundle2, z, str2);
+        }
+
+        @RequiresApi(23)
+        public final CreateCredentialRequest createFrom(String type, Bundle credentialData, Bundle candidateQueryData, boolean z, String str) {
+            Intrinsics.checkNotNullParameter(type, "type");
+            Intrinsics.checkNotNullParameter(credentialData, "credentialData");
+            Intrinsics.checkNotNullParameter(candidateQueryData, "candidateQueryData");
+            try {
+                if (Intrinsics.areEqual(type, PasswordCredential.TYPE_PASSWORD_CREDENTIAL)) {
+                    return CreatePasswordRequest.Companion.createFrom$credentials_release(credentialData, str, candidateQueryData);
+                }
+                if (Intrinsics.areEqual(type, PublicKeyCredential.TYPE_PUBLIC_KEY_CREDENTIAL)) {
+                    String string = credentialData.getString(PublicKeyCredential.BUNDLE_KEY_SUBTYPE);
+                    if (string != null && string.hashCode() == 589054771 && string.equals(CreatePublicKeyCredentialRequest.BUNDLE_VALUE_SUBTYPE_CREATE_PUBLIC_KEY_CREDENTIAL_REQUEST)) {
+                        return CreatePublicKeyCredentialRequest.Companion.createFrom$credentials_release(credentialData, str, candidateQueryData);
+                    }
+                    throw new FrameworkClassParsingException();
+                }
+                throw new FrameworkClassParsingException();
+            } catch (FrameworkClassParsingException unused) {
+                return new CreateCustomCredentialRequest(type, credentialData, candidateQueryData, z, DisplayInfo.Companion.createFrom(credentialData), credentialData.getBoolean("androidx.credentials.BUNDLE_KEY_IS_AUTO_SELECT_ALLOWED", false), str, credentialData.getBoolean("androidx.credentials.BUNDLE_KEY_PREFER_IMMEDIATELY_AVAILABLE_CREDENTIALS", false));
+            }
+        }
+    }
+}

decompiled/sources/androidx/credentials/CreateCredentialResponse.java

@@ -0,0 +1,92 @@
+package androidx.credentials;
+
+import android.os.Bundle;
+import androidx.annotation.RestrictTo;
+import androidx.credentials.internal.FrameworkClassParsingException;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public abstract class CreateCredentialResponse {
+    public static final Companion Companion = new Companion(null);
+    private static final String EXTRA_CREATE_CREDENTIAL_RESPONSE_DATA = "androidx.credentials.provider.extra.CREATE_CREDENTIAL_REQUEST_DATA";
+    private static final String EXTRA_CREATE_CREDENTIAL_RESPONSE_TYPE = "androidx.credentials.provider.extra.CREATE_CREDENTIAL_RESPONSE_TYPE";
+    private final Bundle data;
+    private final String type;
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static final Bundle asBundle(CreateCredentialResponse createCredentialResponse) {
+        return Companion.asBundle(createCredentialResponse);
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static final CreateCredentialResponse createFrom(String str, Bundle bundle) {
+        return Companion.createFrom(str, bundle);
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static final CreateCredentialResponse fromBundle(Bundle bundle) {
+        return Companion.fromBundle(bundle);
+    }
+
+    public final Bundle getData() {
+        return this.data;
+    }
+
+    public final String getType() {
+        return this.type;
+    }
+
+    public CreateCredentialResponse(String type, Bundle data) {
+        Intrinsics.checkNotNullParameter(type, "type");
+        Intrinsics.checkNotNullParameter(data, "data");
+        this.type = type;
+        this.data = data;
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public final CreateCredentialResponse createFrom(String type, Bundle data) {
+            Intrinsics.checkNotNullParameter(type, "type");
+            Intrinsics.checkNotNullParameter(data, "data");
+            try {
+                if (Intrinsics.areEqual(type, PasswordCredential.TYPE_PASSWORD_CREDENTIAL)) {
+                    return CreatePasswordResponse.Companion.createFrom$credentials_release(data);
+                }
+                if (Intrinsics.areEqual(type, PublicKeyCredential.TYPE_PUBLIC_KEY_CREDENTIAL)) {
+                    return CreatePublicKeyCredentialResponse.Companion.createFrom$credentials_release(data);
+                }
+                throw new FrameworkClassParsingException();
+            } catch (FrameworkClassParsingException unused) {
+                return new CreateCustomCredentialResponse(type, data);
+            }
+        }
+
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public final CreateCredentialResponse fromBundle(Bundle bundle) {
+            Bundle bundle2;
+            Intrinsics.checkNotNullParameter(bundle, "bundle");
+            String string = bundle.getString(CreateCredentialResponse.EXTRA_CREATE_CREDENTIAL_RESPONSE_TYPE);
+            if (string == null || (bundle2 = bundle.getBundle(CreateCredentialResponse.EXTRA_CREATE_CREDENTIAL_RESPONSE_DATA)) == null) {
+                return null;
+            }
+            return createFrom(string, bundle2);
+        }
+
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public final Bundle asBundle(CreateCredentialResponse response) {
+            Intrinsics.checkNotNullParameter(response, "response");
+            Bundle bundle = new Bundle();
+            bundle.putString(CreateCredentialResponse.EXTRA_CREATE_CREDENTIAL_RESPONSE_TYPE, response.getType());
+            bundle.putBundle(CreateCredentialResponse.EXTRA_CREATE_CREDENTIAL_RESPONSE_DATA, response.getData());
+            return bundle;
+        }
+    }
+}

decompiled/sources/androidx/credentials/CreateCustomCredentialRequest.java

@@ -0,0 +1,55 @@
+package androidx.credentials;
+
+import android.os.Bundle;
+import androidx.credentials.CreateCredentialRequest;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.PsExtractor;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nCreateCustomCredentialRequest.kt\nKotlin\n*S Kotlin\n*F\n+ 1 CreateCustomCredentialRequest.kt\nandroidx/credentials/CreateCustomCredentialRequest\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,85:1\n1#2:86\n*E\n"})
+/* loaded from: classes.dex */
+public class CreateCustomCredentialRequest extends CreateCredentialRequest {
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public CreateCustomCredentialRequest(String type, Bundle credentialData, Bundle candidateQueryData, boolean z, CreateCredentialRequest.DisplayInfo displayInfo) {
+        this(type, credentialData, candidateQueryData, z, displayInfo, false, null, false, 224, null);
+        Intrinsics.checkNotNullParameter(type, "type");
+        Intrinsics.checkNotNullParameter(credentialData, "credentialData");
+        Intrinsics.checkNotNullParameter(candidateQueryData, "candidateQueryData");
+        Intrinsics.checkNotNullParameter(displayInfo, "displayInfo");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public CreateCustomCredentialRequest(String type, Bundle credentialData, Bundle candidateQueryData, boolean z, CreateCredentialRequest.DisplayInfo displayInfo, boolean z2) {
+        this(type, credentialData, candidateQueryData, z, displayInfo, z2, null, false, PsExtractor.AUDIO_STREAM, null);
+        Intrinsics.checkNotNullParameter(type, "type");
+        Intrinsics.checkNotNullParameter(credentialData, "credentialData");
+        Intrinsics.checkNotNullParameter(candidateQueryData, "candidateQueryData");
+        Intrinsics.checkNotNullParameter(displayInfo, "displayInfo");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public CreateCustomCredentialRequest(String type, Bundle credentialData, Bundle candidateQueryData, boolean z, CreateCredentialRequest.DisplayInfo displayInfo, boolean z2, String str) {
+        this(type, credentialData, candidateQueryData, z, displayInfo, z2, str, false, 128, null);
+        Intrinsics.checkNotNullParameter(type, "type");
+        Intrinsics.checkNotNullParameter(credentialData, "credentialData");
+        Intrinsics.checkNotNullParameter(candidateQueryData, "candidateQueryData");
+        Intrinsics.checkNotNullParameter(displayInfo, "displayInfo");
+    }
+
+    public /* synthetic */ CreateCustomCredentialRequest(String str, Bundle bundle, Bundle bundle2, boolean z, CreateCredentialRequest.DisplayInfo displayInfo, boolean z2, String str2, boolean z3, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, bundle, bundle2, z, displayInfo, (i & 32) != 0 ? false : z2, (i & 64) != 0 ? null : str2, (i & 128) != 0 ? false : z3);
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CreateCustomCredentialRequest(String type, Bundle credentialData, Bundle candidateQueryData, boolean z, CreateCredentialRequest.DisplayInfo displayInfo, boolean z2, String str, boolean z3) {
+        super(type, credentialData, candidateQueryData, z, z2, displayInfo, str, z3);
+        Intrinsics.checkNotNullParameter(type, "type");
+        Intrinsics.checkNotNullParameter(credentialData, "credentialData");
+        Intrinsics.checkNotNullParameter(candidateQueryData, "candidateQueryData");
+        Intrinsics.checkNotNullParameter(displayInfo, "displayInfo");
+        if (type.length() <= 0) {
+            throw new IllegalArgumentException("type should not be empty".toString());
+        }
+    }
+}

decompiled/sources/androidx/credentials/CreateCustomCredentialResponse.java

@@ -0,0 +1,19 @@
+package androidx.credentials;
+
+import android.os.Bundle;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nCreateCustomCredentialResponse.kt\nKotlin\n*S Kotlin\n*F\n+ 1 CreateCustomCredentialResponse.kt\nandroidx/credentials/CreateCustomCredentialResponse\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,47:1\n1#2:48\n*E\n"})
+/* loaded from: classes.dex */
+public class CreateCustomCredentialResponse extends CreateCredentialResponse {
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CreateCustomCredentialResponse(String type, Bundle data) {
+        super(type, data);
+        Intrinsics.checkNotNullParameter(type, "type");
+        Intrinsics.checkNotNullParameter(data, "data");
+        if (type.length() <= 0) {
+            throw new IllegalArgumentException("type should not be empty".toString());
+        }
+    }
+}

decompiled/sources/androidx/credentials/CreatePasswordRequest.java

@@ -0,0 +1,132 @@
+package androidx.credentials;
+
+import android.os.Bundle;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.credentials.CreateCredentialRequest;
+import androidx.credentials.internal.FrameworkClassParsingException;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.PsExtractor;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nCreatePasswordRequest.kt\nKotlin\n*S Kotlin\n*F\n+ 1 CreatePasswordRequest.kt\nandroidx/credentials/CreatePasswordRequest\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,209:1\n1#2:210\n*E\n"})
+/* loaded from: classes.dex */
+public final class CreatePasswordRequest extends CreateCredentialRequest {
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static final String BUNDLE_KEY_ID = "androidx.credentials.BUNDLE_KEY_ID";
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static final String BUNDLE_KEY_PASSWORD = "androidx.credentials.BUNDLE_KEY_PASSWORD";
+    public static final Companion Companion = new Companion(null);
+    private final String id;
+    private final String password;
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public CreatePasswordRequest(String id, String password) {
+        this(id, password, null, false, false, 28, null);
+        Intrinsics.checkNotNullParameter(id, "id");
+        Intrinsics.checkNotNullParameter(password, "password");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public CreatePasswordRequest(String id, String password, String str) {
+        this(id, password, str, false, false, 24, null);
+        Intrinsics.checkNotNullParameter(id, "id");
+        Intrinsics.checkNotNullParameter(password, "password");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public CreatePasswordRequest(String id, String password, String str, boolean z) {
+        this(id, password, str, z, false, 16, null);
+        Intrinsics.checkNotNullParameter(id, "id");
+        Intrinsics.checkNotNullParameter(password, "password");
+    }
+
+    public /* synthetic */ CreatePasswordRequest(String str, String str2, boolean z, CreateCredentialRequest.DisplayInfo displayInfo, String str3, boolean z2, Bundle bundle, Bundle bundle2, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, str2, z, displayInfo, str3, z2, bundle, bundle2);
+    }
+
+    public final String getId() {
+        return this.id;
+    }
+
+    public final String getPassword() {
+        return this.password;
+    }
+
+    public /* synthetic */ CreatePasswordRequest(String str, String str2, boolean z, CreateCredentialRequest.DisplayInfo displayInfo, String str3, boolean z2, Bundle bundle, Bundle bundle2, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, str2, z, displayInfo, (i & 16) != 0 ? null : str3, z2, (i & 64) != 0 ? Companion.toCredentialDataBundle$credentials_release(str, str2) : bundle, (i & 128) != 0 ? Companion.toCandidateDataBundle$credentials_release() : bundle2);
+    }
+
+    private CreatePasswordRequest(String str, String str2, boolean z, CreateCredentialRequest.DisplayInfo displayInfo, String str3, boolean z2, Bundle bundle, Bundle bundle2) {
+        super(PasswordCredential.TYPE_PASSWORD_CREDENTIAL, bundle, bundle2, false, z, displayInfo, str3, z2);
+        this.id = str;
+        this.password = str2;
+        if (str2.length() <= 0) {
+            throw new IllegalArgumentException("password should not be empty".toString());
+        }
+    }
+
+    public /* synthetic */ CreatePasswordRequest(String str, String str2, String str3, boolean z, boolean z2, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, str2, (i & 4) != 0 ? null : str3, (i & 8) != 0 ? false : z, (i & 16) != 0 ? false : z2);
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public CreatePasswordRequest(String id, String password, String str, boolean z, boolean z2) {
+        this(id, password, z2, new CreateCredentialRequest.DisplayInfo(id, null), str, z, null, null, PsExtractor.AUDIO_STREAM, null);
+        Intrinsics.checkNotNullParameter(id, "id");
+        Intrinsics.checkNotNullParameter(password, "password");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public CreatePasswordRequest(String id, String password, String str, String str2, boolean z, boolean z2) {
+        this(id, password, z2, new CreateCredentialRequest.DisplayInfo(id, null, str2), str, z, null, null, PsExtractor.AUDIO_STREAM, null);
+        Intrinsics.checkNotNullParameter(id, "id");
+        Intrinsics.checkNotNullParameter(password, "password");
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final Bundle toCredentialDataBundle$credentials_release(String id, String password) {
+            Intrinsics.checkNotNullParameter(id, "id");
+            Intrinsics.checkNotNullParameter(password, "password");
+            Bundle bundle = new Bundle();
+            bundle.putString("androidx.credentials.BUNDLE_KEY_ID", id);
+            bundle.putString("androidx.credentials.BUNDLE_KEY_PASSWORD", password);
+            return bundle;
+        }
+
+        public final Bundle toCandidateDataBundle$credentials_release() {
+            return new Bundle();
+        }
+
+        @RequiresApi(23)
+        public final CreatePasswordRequest createFrom$credentials_release(Bundle data, String str, Bundle candidateQueryData) {
+            CreateCredentialRequest.DisplayInfo displayInfo;
+            Intrinsics.checkNotNullParameter(data, "data");
+            Intrinsics.checkNotNullParameter(candidateQueryData, "candidateQueryData");
+            try {
+                String string = data.getString("androidx.credentials.BUNDLE_KEY_ID");
+                Intrinsics.checkNotNull(string);
+                String string2 = data.getString("androidx.credentials.BUNDLE_KEY_PASSWORD");
+                Intrinsics.checkNotNull(string2);
+                try {
+                    displayInfo = CreateCredentialRequest.DisplayInfo.Companion.createFrom(data);
+                } catch (IllegalArgumentException unused) {
+                    displayInfo = new CreateCredentialRequest.DisplayInfo(string, null);
+                }
+                return new CreatePasswordRequest(string, string2, data.getBoolean("androidx.credentials.BUNDLE_KEY_IS_AUTO_SELECT_ALLOWED", false), displayInfo, str, data.getBoolean("androidx.credentials.BUNDLE_KEY_PREFER_IMMEDIATELY_AVAILABLE_CREDENTIALS", false), data, candidateQueryData, null);
+            } catch (Exception unused2) {
+                throw new FrameworkClassParsingException();
+            }
+        }
+    }
+}

decompiled/sources/androidx/credentials/CreatePasswordResponse.java

@@ -0,0 +1,36 @@
+package androidx.credentials;
+
+import android.os.Bundle;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class CreatePasswordResponse extends CreateCredentialResponse {
+    public static final Companion Companion = new Companion(null);
+
+    public /* synthetic */ CreatePasswordResponse(Bundle bundle, DefaultConstructorMarker defaultConstructorMarker) {
+        this(bundle);
+    }
+
+    private CreatePasswordResponse(Bundle bundle) {
+        super(PasswordCredential.TYPE_PASSWORD_CREDENTIAL, bundle);
+    }
+
+    public CreatePasswordResponse() {
+        this(new Bundle());
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final CreatePasswordResponse createFrom$credentials_release(Bundle data) {
+            Intrinsics.checkNotNullParameter(data, "data");
+            return new CreatePasswordResponse(data, null);
+        }
+    }
+}

decompiled/sources/androidx/credentials/CreatePublicKeyCredentialRequest.java

@@ -0,0 +1,162 @@
+package androidx.credentials;
+
+import android.graphics.drawable.Icon;
+import android.os.Bundle;
+import androidx.annotation.RequiresApi;
+import androidx.credentials.CreateCredentialRequest;
+import androidx.credentials.internal.FrameworkClassParsingException;
+import androidx.credentials.internal.RequestValidationHelper;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.PsExtractor;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import org.json.JSONObject;
+
+/* loaded from: classes.dex */
+public final class CreatePublicKeyCredentialRequest extends CreateCredentialRequest {
+    public static final String BUNDLE_KEY_CLIENT_DATA_HASH = "androidx.credentials.BUNDLE_KEY_CLIENT_DATA_HASH";
+    public static final String BUNDLE_KEY_REQUEST_JSON = "androidx.credentials.BUNDLE_KEY_REQUEST_JSON";
+    public static final String BUNDLE_VALUE_SUBTYPE_CREATE_PUBLIC_KEY_CREDENTIAL_REQUEST = "androidx.credentials.BUNDLE_VALUE_SUBTYPE_CREATE_PUBLIC_KEY_CREDENTIAL_REQUEST";
+    public static final Companion Companion = new Companion(null);
+    private final byte[] clientDataHash;
+    private final String requestJson;
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public CreatePublicKeyCredentialRequest(String requestJson) {
+        this(requestJson, null, false, null, false, 30, null);
+        Intrinsics.checkNotNullParameter(requestJson, "requestJson");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public CreatePublicKeyCredentialRequest(String requestJson, byte[] bArr) {
+        this(requestJson, bArr, false, null, false, 28, null);
+        Intrinsics.checkNotNullParameter(requestJson, "requestJson");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public CreatePublicKeyCredentialRequest(String requestJson, byte[] bArr, boolean z) {
+        this(requestJson, bArr, z, null, false, 24, null);
+        Intrinsics.checkNotNullParameter(requestJson, "requestJson");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public CreatePublicKeyCredentialRequest(String requestJson, byte[] bArr, boolean z, String str) {
+        this(requestJson, bArr, z, str, false, 16, null);
+        Intrinsics.checkNotNullParameter(requestJson, "requestJson");
+    }
+
+    public /* synthetic */ CreatePublicKeyCredentialRequest(String str, byte[] bArr, boolean z, boolean z2, CreateCredentialRequest.DisplayInfo displayInfo, String str2, Bundle bundle, Bundle bundle2, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, bArr, z, z2, displayInfo, str2, bundle, bundle2);
+    }
+
+    public final byte[] getClientDataHash() {
+        return this.clientDataHash;
+    }
+
+    public final String getRequestJson() {
+        return this.requestJson;
+    }
+
+    public /* synthetic */ CreatePublicKeyCredentialRequest(String str, byte[] bArr, boolean z, boolean z2, CreateCredentialRequest.DisplayInfo displayInfo, String str2, Bundle bundle, Bundle bundle2, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, bArr, z, z2, displayInfo, (i & 32) != 0 ? null : str2, (i & 64) != 0 ? Companion.toCredentialDataBundle$credentials_release(str, bArr) : bundle, (i & 128) != 0 ? Companion.toCandidateDataBundle$credentials_release(str, bArr) : bundle2);
+    }
+
+    private CreatePublicKeyCredentialRequest(String str, byte[] bArr, boolean z, boolean z2, CreateCredentialRequest.DisplayInfo displayInfo, String str2, Bundle bundle, Bundle bundle2) {
+        super(PublicKeyCredential.TYPE_PUBLIC_KEY_CREDENTIAL, bundle, bundle2, false, z, displayInfo, str2, z2);
+        this.requestJson = str;
+        this.clientDataHash = bArr;
+        if (!RequestValidationHelper.Companion.isValidJSON(str)) {
+            throw new IllegalArgumentException("requestJson must not be empty, and must be a valid JSON".toString());
+        }
+    }
+
+    public /* synthetic */ CreatePublicKeyCredentialRequest(String str, byte[] bArr, boolean z, String str2, boolean z2, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, (i & 2) != 0 ? null : bArr, (i & 4) != 0 ? false : z, (i & 8) != 0 ? null : str2, (i & 16) != 0 ? false : z2);
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public CreatePublicKeyCredentialRequest(String requestJson, byte[] bArr, boolean z, String str, boolean z2) {
+        this(requestJson, bArr, z2, z, Companion.getRequestDisplayInfo$credentials_release$default(Companion, requestJson, null, 2, null), str, null, null, PsExtractor.AUDIO_STREAM, null);
+        Intrinsics.checkNotNullParameter(requestJson, "requestJson");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public CreatePublicKeyCredentialRequest(String requestJson, byte[] bArr, boolean z, String str, String str2, boolean z2) {
+        this(requestJson, bArr, z2, z, Companion.getRequestDisplayInfo$credentials_release(requestJson, str2), str, null, null, PsExtractor.AUDIO_STREAM, null);
+        Intrinsics.checkNotNullParameter(requestJson, "requestJson");
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public static /* synthetic */ CreateCredentialRequest.DisplayInfo getRequestDisplayInfo$credentials_release$default(Companion companion, String str, String str2, int i, Object obj) {
+            if ((i & 2) != 0) {
+                str2 = null;
+            }
+            return companion.getRequestDisplayInfo$credentials_release(str, str2);
+        }
+
+        public final CreateCredentialRequest.DisplayInfo getRequestDisplayInfo$credentials_release(String requestJson, String str) {
+            Intrinsics.checkNotNullParameter(requestJson, "requestJson");
+            try {
+                JSONObject jSONObject = new JSONObject(requestJson).getJSONObject("user");
+                String userName = jSONObject.getString("name");
+                String string = jSONObject.isNull("displayName") ? null : jSONObject.getString("displayName");
+                Intrinsics.checkNotNullExpressionValue(userName, "userName");
+                return new CreateCredentialRequest.DisplayInfo(userName, string, (Icon) null, str);
+            } catch (Exception unused) {
+                throw new IllegalArgumentException("user.name must be defined in requestJson");
+            }
+        }
+
+        public static /* synthetic */ Bundle toCredentialDataBundle$credentials_release$default(Companion companion, String str, byte[] bArr, int i, Object obj) {
+            if ((i & 2) != 0) {
+                bArr = null;
+            }
+            return companion.toCredentialDataBundle$credentials_release(str, bArr);
+        }
+
+        public final Bundle toCredentialDataBundle$credentials_release(String requestJson, byte[] bArr) {
+            Intrinsics.checkNotNullParameter(requestJson, "requestJson");
+            Bundle bundle = new Bundle();
+            bundle.putString(PublicKeyCredential.BUNDLE_KEY_SUBTYPE, CreatePublicKeyCredentialRequest.BUNDLE_VALUE_SUBTYPE_CREATE_PUBLIC_KEY_CREDENTIAL_REQUEST);
+            bundle.putString("androidx.credentials.BUNDLE_KEY_REQUEST_JSON", requestJson);
+            bundle.putByteArray("androidx.credentials.BUNDLE_KEY_CLIENT_DATA_HASH", bArr);
+            return bundle;
+        }
+
+        public final Bundle toCandidateDataBundle$credentials_release(String requestJson, byte[] bArr) {
+            Intrinsics.checkNotNullParameter(requestJson, "requestJson");
+            Bundle bundle = new Bundle();
+            bundle.putString(PublicKeyCredential.BUNDLE_KEY_SUBTYPE, CreatePublicKeyCredentialRequest.BUNDLE_VALUE_SUBTYPE_CREATE_PUBLIC_KEY_CREDENTIAL_REQUEST);
+            bundle.putString("androidx.credentials.BUNDLE_KEY_REQUEST_JSON", requestJson);
+            bundle.putByteArray("androidx.credentials.BUNDLE_KEY_CLIENT_DATA_HASH", bArr);
+            return bundle;
+        }
+
+        @RequiresApi(23)
+        public final CreatePublicKeyCredentialRequest createFrom$credentials_release(Bundle data, String str, Bundle candidateQueryData) {
+            CreateCredentialRequest.DisplayInfo requestDisplayInfo$credentials_release$default;
+            Intrinsics.checkNotNullParameter(data, "data");
+            Intrinsics.checkNotNullParameter(candidateQueryData, "candidateQueryData");
+            try {
+                String string = data.getString("androidx.credentials.BUNDLE_KEY_REQUEST_JSON");
+                Intrinsics.checkNotNull(string);
+                byte[] byteArray = data.getByteArray("androidx.credentials.BUNDLE_KEY_CLIENT_DATA_HASH");
+                boolean z = data.getBoolean("androidx.credentials.BUNDLE_KEY_PREFER_IMMEDIATELY_AVAILABLE_CREDENTIALS", false);
+                try {
+                    requestDisplayInfo$credentials_release$default = CreateCredentialRequest.DisplayInfo.Companion.createFrom(data);
+                } catch (IllegalArgumentException unused) {
+                    requestDisplayInfo$credentials_release$default = getRequestDisplayInfo$credentials_release$default(this, string, null, 2, null);
+                }
+                return new CreatePublicKeyCredentialRequest(string, byteArray, data.getBoolean("androidx.credentials.BUNDLE_KEY_IS_AUTO_SELECT_ALLOWED", false), z, requestDisplayInfo$credentials_release$default, str, data, candidateQueryData, null);
+            } catch (Exception unused2) {
+                throw new FrameworkClassParsingException();
+            }
+        }
+    }
+}

decompiled/sources/androidx/credentials/CreatePublicKeyCredentialResponse.java

@@ -0,0 +1,63 @@
+package androidx.credentials;
+
+import android.os.Bundle;
+import androidx.credentials.internal.FrameworkClassParsingException;
+import androidx.credentials.internal.RequestValidationHelper;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class CreatePublicKeyCredentialResponse extends CreateCredentialResponse {
+    public static final String BUNDLE_KEY_REGISTRATION_RESPONSE_JSON = "androidx.credentials.BUNDLE_KEY_REGISTRATION_RESPONSE_JSON";
+    public static final Companion Companion = new Companion(null);
+    private final String registrationResponseJson;
+
+    public /* synthetic */ CreatePublicKeyCredentialResponse(String str, Bundle bundle, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, bundle);
+    }
+
+    public final String getRegistrationResponseJson() {
+        return this.registrationResponseJson;
+    }
+
+    private CreatePublicKeyCredentialResponse(String str, Bundle bundle) {
+        super(PublicKeyCredential.TYPE_PUBLIC_KEY_CREDENTIAL, bundle);
+        this.registrationResponseJson = str;
+        if (!RequestValidationHelper.Companion.isValidJSON(str)) {
+            throw new IllegalArgumentException("registrationResponseJson must not be empty, and must be a valid JSON".toString());
+        }
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public CreatePublicKeyCredentialResponse(String registrationResponseJson) {
+        this(registrationResponseJson, Companion.toBundle$credentials_release(registrationResponseJson));
+        Intrinsics.checkNotNullParameter(registrationResponseJson, "registrationResponseJson");
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final Bundle toBundle$credentials_release(String registrationResponseJson) {
+            Intrinsics.checkNotNullParameter(registrationResponseJson, "registrationResponseJson");
+            Bundle bundle = new Bundle();
+            bundle.putString(CreatePublicKeyCredentialResponse.BUNDLE_KEY_REGISTRATION_RESPONSE_JSON, registrationResponseJson);
+            return bundle;
+        }
+
+        public final CreatePublicKeyCredentialResponse createFrom$credentials_release(Bundle data) {
+            Intrinsics.checkNotNullParameter(data, "data");
+            try {
+                String string = data.getString(CreatePublicKeyCredentialResponse.BUNDLE_KEY_REGISTRATION_RESPONSE_JSON);
+                Intrinsics.checkNotNull(string);
+                return new CreatePublicKeyCredentialResponse(string, data, null);
+            } catch (Exception unused) {
+                throw new FrameworkClassParsingException();
+            }
+        }
+    }
+}

decompiled/sources/androidx/credentials/CreateRestoreCredentialRequest.java

@@ -0,0 +1,91 @@
+package androidx.credentials;
+
+import android.os.Bundle;
+import androidx.credentials.CreateCredentialRequest;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import org.json.JSONObject;
+
+/* loaded from: classes.dex */
+public final class CreateRestoreCredentialRequest extends CreateCredentialRequest {
+    private static final String BUNDLE_KEY_CREATE_RESTORE_CREDENTIAL_REQUEST = "androidx.credentials.BUNDLE_KEY_CREATE_RESTORE_CREDENTIAL_REQUEST";
+    private static final String BUNDLE_KEY_SHOULD_BACKUP_TO_CLOUD = "androidx.credentials.BUNDLE_KEY_SHOULD_BACKUP_TO_CLOUD";
+    public static final Companion Companion = new Companion(null);
+    private final boolean isCloudBackupEnabled;
+    private final String requestJson;
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public CreateRestoreCredentialRequest(String requestJson) {
+        this(requestJson, false, 2, null);
+        Intrinsics.checkNotNullParameter(requestJson, "requestJson");
+    }
+
+    public final String getRequestJson() {
+        return this.requestJson;
+    }
+
+    public final boolean isCloudBackupEnabled() {
+        return this.isCloudBackupEnabled;
+    }
+
+    public /* synthetic */ CreateRestoreCredentialRequest(String str, boolean z, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, (i & 2) != 0 ? true : z);
+    }
+
+    /* 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 CreateRestoreCredentialRequest(java.lang.String r11, boolean r12) {
+        /*
+            r10 = this;
+            java.lang.String r0 = "requestJson"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r11, r0)
+            androidx.credentials.CreateRestoreCredentialRequest$Companion r0 = androidx.credentials.CreateRestoreCredentialRequest.Companion
+            android.os.Bundle r3 = androidx.credentials.CreateRestoreCredentialRequest.Companion.access$toCredentialDataBundle(r0, r11, r12)
+            androidx.credentials.CreateCredentialRequest$DisplayInfo r7 = androidx.credentials.CreateRestoreCredentialRequest.Companion.access$getDisplayInfoFromJson(r0, r11)
+            android.os.Bundle r4 = new android.os.Bundle
+            r4.<init>()
+            java.lang.String r2 = "androidx.credentials.TYPE_RESTORE_CREDENTIAL"
+            r5 = 0
+            r6 = 0
+            r8 = 0
+            r9 = 0
+            r1 = r10
+            r1.<init>(r2, r3, r4, r5, r6, r7, r8, r9)
+            r10.requestJson = r11
+            r10.isCloudBackupEnabled = r12
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.credentials.CreateRestoreCredentialRequest.<init>(java.lang.String, boolean):void");
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public final CreateCredentialRequest.DisplayInfo getDisplayInfoFromJson(String str) {
+            try {
+                String string = new JSONObject(str).getJSONObject("user").getString("id");
+                Intrinsics.checkNotNullExpressionValue(string, "userJson.getString(\"id\")");
+                return new CreateCredentialRequest.DisplayInfo(string, (CharSequence) null, 2, (DefaultConstructorMarker) null);
+            } catch (Exception unused) {
+                throw new IllegalArgumentException("user.id must be defined in requestJson");
+            }
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public final Bundle toCredentialDataBundle(String str, boolean z) {
+            Bundle bundle = new Bundle();
+            bundle.putString(CreateRestoreCredentialRequest.BUNDLE_KEY_CREATE_RESTORE_CREDENTIAL_REQUEST, str);
+            bundle.putBoolean(CreateRestoreCredentialRequest.BUNDLE_KEY_SHOULD_BACKUP_TO_CLOUD, z);
+            return bundle;
+        }
+    }
+}

decompiled/sources/androidx/credentials/CreateRestoreCredentialResponse.java

@@ -0,0 +1,68 @@
+package androidx.credentials;
+
+import android.os.Bundle;
+import androidx.annotation.RestrictTo;
+import androidx.credentials.exceptions.CreateCredentialUnknownException;
+import androidx.credentials.internal.RequestValidationHelper;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class CreateRestoreCredentialResponse extends CreateCredentialResponse {
+    public static final String BUNDLE_KEY_CREATE_RESTORE_CREDENTIAL_RESPONSE = "androidx.credentials.BUNDLE_KEY_CREATE_RESTORE_CREDENTIAL_RESPONSE";
+    public static final Companion Companion = new Companion(null);
+    private final String responseJson;
+
+    public /* synthetic */ CreateRestoreCredentialResponse(String str, Bundle bundle, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, bundle);
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+    public static final CreateRestoreCredentialResponse createFrom(Bundle bundle) {
+        return Companion.createFrom(bundle);
+    }
+
+    public final String getResponseJson() {
+        return this.responseJson;
+    }
+
+    private CreateRestoreCredentialResponse(String str, Bundle bundle) {
+        super(RestoreCredential.TYPE_RESTORE_CREDENTIAL, bundle);
+        this.responseJson = str;
+        if (!RequestValidationHelper.Companion.isValidJSON(str)) {
+            throw new IllegalArgumentException("registrationResponseJson must not be empty, and must be a valid JSON".toString());
+        }
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public CreateRestoreCredentialResponse(String responseJson) {
+        this(responseJson, Companion.toBundle$credentials_release(responseJson));
+        Intrinsics.checkNotNullParameter(responseJson, "responseJson");
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+        public final CreateRestoreCredentialResponse createFrom(Bundle data) {
+            Intrinsics.checkNotNullParameter(data, "data");
+            String string = data.getString(CreateRestoreCredentialResponse.BUNDLE_KEY_CREATE_RESTORE_CREDENTIAL_RESPONSE);
+            if (string == null) {
+                throw new CreateCredentialUnknownException("The response bundle did not contain the response data. This should not happen.");
+            }
+            return new CreateRestoreCredentialResponse(string, data, null);
+        }
+
+        public final Bundle toBundle$credentials_release(String responseJson) {
+            Intrinsics.checkNotNullParameter(responseJson, "responseJson");
+            Bundle bundle = new Bundle();
+            bundle.putString(CreateRestoreCredentialResponse.BUNDLE_KEY_CREATE_RESTORE_CREDENTIAL_RESPONSE, responseJson);
+            return bundle;
+        }
+    }
+}

decompiled/sources/androidx/credentials/Credential$Companion$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class Credential$Companion$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/credentials/Credential$Companion$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class Credential$Companion$$ExternalSyntheticApiModelOutline1 {
+}

decompiled/sources/androidx/credentials/Credential.java

@@ -0,0 +1,98 @@
+package androidx.credentials;
+
+import android.os.Bundle;
+import androidx.annotation.RequiresApi;
+import androidx.credentials.internal.FrameworkClassParsingException;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public abstract class Credential {
+    public static final Companion Companion = new Companion(null);
+    private final Bundle data;
+    private final String type;
+
+    @RequiresApi(34)
+    public static final Credential createFrom(android.credentials.Credential credential) {
+        return Companion.createFrom(credential);
+    }
+
+    public static final Credential createFrom(String str, Bundle bundle) {
+        return Companion.createFrom(str, bundle);
+    }
+
+    public final Bundle getData() {
+        return this.data;
+    }
+
+    public final String getType() {
+        return this.type;
+    }
+
+    public Credential(String type, Bundle data) {
+        Intrinsics.checkNotNullParameter(type, "type");
+        Intrinsics.checkNotNullParameter(data, "data");
+        this.type = type;
+        this.data = data;
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        /* JADX WARN: Failed to restore switch over string. Please report as a decompilation issue
+        java.lang.NullPointerException: Cannot invoke "java.util.List.iterator()" because the return value of "jadx.core.dex.visitors.regions.SwitchOverStringVisitor$SwitchData.getNewCases()" is null
+        	at jadx.core.dex.visitors.regions.SwitchOverStringVisitor.restoreSwitchOverString(SwitchOverStringVisitor.java:109)
+        	at jadx.core.dex.visitors.regions.SwitchOverStringVisitor.visitRegion(SwitchOverStringVisitor.java:66)
+        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseIterativeStepInternal(DepthRegionTraversal.java:77)
+        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseIterativeStepInternal(DepthRegionTraversal.java:82)
+         */
+        public final Credential createFrom(String type, Bundle data) {
+            Intrinsics.checkNotNullParameter(type, "type");
+            Intrinsics.checkNotNullParameter(data, "data");
+            try {
+                switch (type.hashCode()) {
+                    case -1678407252:
+                        if (type.equals(DigitalCredential.TYPE_DIGITAL_CREDENTIAL)) {
+                            return DigitalCredential.Companion.createFrom$credentials_release(data);
+                        }
+                        break;
+                    case -1072734346:
+                        if (type.equals(RestoreCredential.TYPE_RESTORE_CREDENTIAL)) {
+                            return RestoreCredential.Companion.createFrom$credentials_release(data);
+                        }
+                        break;
+                    case -543568185:
+                        if (type.equals(PasswordCredential.TYPE_PASSWORD_CREDENTIAL)) {
+                            return PasswordCredential.Companion.createFrom$credentials_release(data);
+                        }
+                        break;
+                    case -95037569:
+                        if (type.equals(PublicKeyCredential.TYPE_PUBLIC_KEY_CREDENTIAL)) {
+                            return PublicKeyCredential.Companion.createFrom$credentials_release(data);
+                        }
+                        break;
+                }
+                throw new FrameworkClassParsingException();
+            } catch (FrameworkClassParsingException unused) {
+                return new CustomCredential(type, data);
+            }
+        }
+
+        @RequiresApi(34)
+        public final Credential createFrom(android.credentials.Credential credential) {
+            String type;
+            Bundle data;
+            Intrinsics.checkNotNullParameter(credential, "credential");
+            type = credential.getType();
+            Intrinsics.checkNotNullExpressionValue(type, "credential.type");
+            data = credential.getData();
+            Intrinsics.checkNotNullExpressionValue(data, "credential.data");
+            return createFrom(type, data);
+        }
+    }
+}

decompiled/sources/androidx/credentials/CredentialManager$$ExternalSyntheticLambda0.java

@@ -0,0 +1,11 @@
+package androidx.credentials;
+
+import java.util.concurrent.Executor;
+
+/* loaded from: classes.dex */
+public final /* synthetic */ class CredentialManager$$ExternalSyntheticLambda0 implements Executor {
+    @Override // java.util.concurrent.Executor
+    public final void execute(Runnable runnable) {
+        runnable.run();
+    }
+}

decompiled/sources/androidx/credentials/CredentialManager.java

@@ -0,0 +1,339 @@
+package androidx.credentials;
+
+import android.annotation.SuppressLint;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.os.CancellationSignal;
+import androidx.annotation.RequiresApi;
+import androidx.credentials.PrepareGetCredentialResponse;
+import androidx.credentials.exceptions.ClearCredentialException;
+import androidx.credentials.exceptions.CreateCredentialException;
+import androidx.credentials.exceptions.GetCredentialException;
+import java.util.concurrent.Executor;
+import kotlin.Result;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsJvmKt;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.DebugProbesKt;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlinx.coroutines.CancellableContinuation;
+import kotlinx.coroutines.CancellableContinuationImpl;
+
+@SuppressLint({"ObsoleteSdkInt"})
+@SourceDebugExtension({"SMAP\nCredentialManager.kt\nKotlin\n*S Kotlin\n*F\n+ 1 CredentialManager.kt\nandroidx/credentials/CredentialManager\n+ 2 CancellableContinuation.kt\nkotlinx/coroutines/CancellableContinuationKt\n*L\n1#1,475:1\n314#2,11:476\n314#2,11:487\n314#2,11:498\n314#2,11:509\n314#2,11:520\n*S KotlinDebug\n*F\n+ 1 CredentialManager.kt\nandroidx/credentials/CredentialManager\n*L\n110#1:476,11\n163#1:487,11\n210#1:498,11\n257#1:509,11\n309#1:520,11\n*E\n"})
+/* loaded from: classes.dex */
+public interface CredentialManager {
+    public static final Companion Companion = Companion.$$INSTANCE;
+
+    static CredentialManager create(Context context) {
+        return Companion.create(context);
+    }
+
+    default Object clearCredentialState(ClearCredentialStateRequest clearCredentialStateRequest, Continuation continuation) {
+        return clearCredentialState$suspendImpl(this, clearCredentialStateRequest, continuation);
+    }
+
+    void clearCredentialStateAsync(ClearCredentialStateRequest clearCredentialStateRequest, CancellationSignal cancellationSignal, Executor executor, CredentialManagerCallback<Void, ClearCredentialException> credentialManagerCallback);
+
+    default Object createCredential(Context context, CreateCredentialRequest createCredentialRequest, Continuation continuation) {
+        return createCredential$suspendImpl(this, context, createCredentialRequest, continuation);
+    }
+
+    void createCredentialAsync(Context context, CreateCredentialRequest createCredentialRequest, CancellationSignal cancellationSignal, Executor executor, CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException> credentialManagerCallback);
+
+    @RequiresApi(34)
+    PendingIntent createSettingsPendingIntent();
+
+    default Object getCredential(Context context, GetCredentialRequest getCredentialRequest, Continuation continuation) {
+        return getCredential$suspendImpl(this, context, getCredentialRequest, continuation);
+    }
+
+    @RequiresApi(34)
+    default Object getCredential(Context context, PrepareGetCredentialResponse.PendingGetCredentialHandle pendingGetCredentialHandle, Continuation continuation) {
+        return getCredential$suspendImpl(this, context, pendingGetCredentialHandle, continuation);
+    }
+
+    void getCredentialAsync(Context context, GetCredentialRequest getCredentialRequest, CancellationSignal cancellationSignal, Executor executor, CredentialManagerCallback<GetCredentialResponse, GetCredentialException> credentialManagerCallback);
+
+    @RequiresApi(34)
+    void getCredentialAsync(Context context, PrepareGetCredentialResponse.PendingGetCredentialHandle pendingGetCredentialHandle, CancellationSignal cancellationSignal, Executor executor, CredentialManagerCallback<GetCredentialResponse, GetCredentialException> credentialManagerCallback);
+
+    @RequiresApi(34)
+    default Object prepareGetCredential(GetCredentialRequest getCredentialRequest, Continuation continuation) {
+        return prepareGetCredential$suspendImpl(this, getCredentialRequest, continuation);
+    }
+
+    @RequiresApi(34)
+    void prepareGetCredentialAsync(GetCredentialRequest getCredentialRequest, CancellationSignal cancellationSignal, Executor executor, CredentialManagerCallback<PrepareGetCredentialResponse, GetCredentialException> credentialManagerCallback);
+
+    public static final class Companion {
+        static final /* synthetic */ Companion $$INSTANCE = new Companion();
+
+        private Companion() {
+        }
+
+        public final CredentialManager create(Context context) {
+            Intrinsics.checkNotNullParameter(context, "context");
+            return new CredentialManagerImpl(context);
+        }
+    }
+
+    static /* synthetic */ Object clearCredentialState$suspendImpl(CredentialManager credentialManager, ClearCredentialStateRequest clearCredentialStateRequest, Continuation continuation) {
+        Continuation intercepted;
+        Object coroutine_suspended;
+        Object coroutine_suspended2;
+        intercepted = IntrinsicsKt__IntrinsicsJvmKt.intercepted(continuation);
+        final CancellableContinuationImpl cancellableContinuationImpl = new CancellableContinuationImpl(intercepted, 1);
+        cancellableContinuationImpl.initCancellability();
+        final CancellationSignal cancellationSignal = new CancellationSignal();
+        cancellableContinuationImpl.invokeOnCancellation(new Function1() { // from class: androidx.credentials.CredentialManager$clearCredentialState$2$1
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(1);
+            }
+
+            @Override // kotlin.jvm.functions.Function1
+            public /* bridge */ /* synthetic */ Object invoke(Object obj) {
+                invoke((Throwable) obj);
+                return Unit.INSTANCE;
+            }
+
+            public final void invoke(Throwable th) {
+                cancellationSignal.cancel();
+            }
+        });
+        credentialManager.clearCredentialStateAsync(clearCredentialStateRequest, cancellationSignal, new CredentialManager$$ExternalSyntheticLambda0(), new CredentialManagerCallback<Void, ClearCredentialException>() { // from class: androidx.credentials.CredentialManager$clearCredentialState$2$callback$1
+            @Override // androidx.credentials.CredentialManagerCallback
+            public void onResult(Void r2) {
+                if (CancellableContinuation.this.isActive()) {
+                    CancellableContinuation cancellableContinuation = CancellableContinuation.this;
+                    Result.Companion companion = Result.Companion;
+                    cancellableContinuation.resumeWith(Result.m4060constructorimpl(Unit.INSTANCE));
+                }
+            }
+
+            @Override // androidx.credentials.CredentialManagerCallback
+            public void onError(ClearCredentialException e) {
+                Intrinsics.checkNotNullParameter(e, "e");
+                if (CancellableContinuation.this.isActive()) {
+                    CancellableContinuation cancellableContinuation = CancellableContinuation.this;
+                    Result.Companion companion = Result.Companion;
+                    cancellableContinuation.resumeWith(Result.m4060constructorimpl(ResultKt.createFailure(e)));
+                }
+            }
+        });
+        Object result = cancellableContinuationImpl.getResult();
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        if (result == coroutine_suspended) {
+            DebugProbesKt.probeCoroutineSuspended(continuation);
+        }
+        coroutine_suspended2 = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return result == coroutine_suspended2 ? result : Unit.INSTANCE;
+    }
+
+    static /* synthetic */ Object createCredential$suspendImpl(CredentialManager credentialManager, Context context, CreateCredentialRequest createCredentialRequest, Continuation continuation) {
+        Continuation intercepted;
+        Object coroutine_suspended;
+        intercepted = IntrinsicsKt__IntrinsicsJvmKt.intercepted(continuation);
+        final CancellableContinuationImpl cancellableContinuationImpl = new CancellableContinuationImpl(intercepted, 1);
+        cancellableContinuationImpl.initCancellability();
+        final CancellationSignal cancellationSignal = new CancellationSignal();
+        cancellableContinuationImpl.invokeOnCancellation(new Function1() { // from class: androidx.credentials.CredentialManager$createCredential$2$1
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(1);
+            }
+
+            @Override // kotlin.jvm.functions.Function1
+            public /* bridge */ /* synthetic */ Object invoke(Object obj) {
+                invoke((Throwable) obj);
+                return Unit.INSTANCE;
+            }
+
+            public final void invoke(Throwable th) {
+                cancellationSignal.cancel();
+            }
+        });
+        credentialManager.createCredentialAsync(context, createCredentialRequest, cancellationSignal, new CredentialManager$$ExternalSyntheticLambda0(), new CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException>() { // from class: androidx.credentials.CredentialManager$createCredential$2$callback$1
+            @Override // androidx.credentials.CredentialManagerCallback
+            public void onResult(CreateCredentialResponse result) {
+                Intrinsics.checkNotNullParameter(result, "result");
+                if (CancellableContinuation.this.isActive()) {
+                    CancellableContinuation.this.resumeWith(Result.m4060constructorimpl(result));
+                }
+            }
+
+            @Override // androidx.credentials.CredentialManagerCallback
+            public void onError(CreateCredentialException e) {
+                Intrinsics.checkNotNullParameter(e, "e");
+                if (CancellableContinuation.this.isActive()) {
+                    CancellableContinuation cancellableContinuation = CancellableContinuation.this;
+                    Result.Companion companion = Result.Companion;
+                    cancellableContinuation.resumeWith(Result.m4060constructorimpl(ResultKt.createFailure(e)));
+                }
+            }
+        });
+        Object result = cancellableContinuationImpl.getResult();
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        if (result == coroutine_suspended) {
+            DebugProbesKt.probeCoroutineSuspended(continuation);
+        }
+        return result;
+    }
+
+    static /* synthetic */ Object getCredential$suspendImpl(CredentialManager credentialManager, Context context, GetCredentialRequest getCredentialRequest, Continuation continuation) {
+        Continuation intercepted;
+        Object coroutine_suspended;
+        intercepted = IntrinsicsKt__IntrinsicsJvmKt.intercepted(continuation);
+        final CancellableContinuationImpl cancellableContinuationImpl = new CancellableContinuationImpl(intercepted, 1);
+        cancellableContinuationImpl.initCancellability();
+        final CancellationSignal cancellationSignal = new CancellationSignal();
+        cancellableContinuationImpl.invokeOnCancellation(new Function1() { // from class: androidx.credentials.CredentialManager$getCredential$2$1
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(1);
+            }
+
+            @Override // kotlin.jvm.functions.Function1
+            public /* bridge */ /* synthetic */ Object invoke(Object obj) {
+                invoke((Throwable) obj);
+                return Unit.INSTANCE;
+            }
+
+            public final void invoke(Throwable th) {
+                cancellationSignal.cancel();
+            }
+        });
+        credentialManager.getCredentialAsync(context, getCredentialRequest, cancellationSignal, new CredentialManager$$ExternalSyntheticLambda0(), new CredentialManagerCallback<GetCredentialResponse, GetCredentialException>() { // from class: androidx.credentials.CredentialManager$getCredential$2$callback$1
+            @Override // androidx.credentials.CredentialManagerCallback
+            public void onResult(GetCredentialResponse result) {
+                Intrinsics.checkNotNullParameter(result, "result");
+                if (CancellableContinuation.this.isActive()) {
+                    CancellableContinuation.this.resumeWith(Result.m4060constructorimpl(result));
+                }
+            }
+
+            @Override // androidx.credentials.CredentialManagerCallback
+            public void onError(GetCredentialException e) {
+                Intrinsics.checkNotNullParameter(e, "e");
+                if (CancellableContinuation.this.isActive()) {
+                    CancellableContinuation cancellableContinuation = CancellableContinuation.this;
+                    Result.Companion companion = Result.Companion;
+                    cancellableContinuation.resumeWith(Result.m4060constructorimpl(ResultKt.createFailure(e)));
+                }
+            }
+        });
+        Object result = cancellableContinuationImpl.getResult();
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        if (result == coroutine_suspended) {
+            DebugProbesKt.probeCoroutineSuspended(continuation);
+        }
+        return result;
+    }
+
+    @RequiresApi(34)
+    static /* synthetic */ Object getCredential$suspendImpl(CredentialManager credentialManager, Context context, PrepareGetCredentialResponse.PendingGetCredentialHandle pendingGetCredentialHandle, Continuation continuation) {
+        Continuation intercepted;
+        Object coroutine_suspended;
+        intercepted = IntrinsicsKt__IntrinsicsJvmKt.intercepted(continuation);
+        final CancellableContinuationImpl cancellableContinuationImpl = new CancellableContinuationImpl(intercepted, 1);
+        cancellableContinuationImpl.initCancellability();
+        final CancellationSignal cancellationSignal = new CancellationSignal();
+        cancellableContinuationImpl.invokeOnCancellation(new Function1() { // from class: androidx.credentials.CredentialManager$getCredential$4$1
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(1);
+            }
+
+            @Override // kotlin.jvm.functions.Function1
+            public /* bridge */ /* synthetic */ Object invoke(Object obj) {
+                invoke((Throwable) obj);
+                return Unit.INSTANCE;
+            }
+
+            public final void invoke(Throwable th) {
+                cancellationSignal.cancel();
+            }
+        });
+        credentialManager.getCredentialAsync(context, pendingGetCredentialHandle, cancellationSignal, new CredentialManager$$ExternalSyntheticLambda0(), new CredentialManagerCallback<GetCredentialResponse, GetCredentialException>() { // from class: androidx.credentials.CredentialManager$getCredential$4$callback$1
+            @Override // androidx.credentials.CredentialManagerCallback
+            public void onResult(GetCredentialResponse result) {
+                Intrinsics.checkNotNullParameter(result, "result");
+                if (CancellableContinuation.this.isActive()) {
+                    CancellableContinuation.this.resumeWith(Result.m4060constructorimpl(result));
+                }
+            }
+
+            @Override // androidx.credentials.CredentialManagerCallback
+            public void onError(GetCredentialException e) {
+                Intrinsics.checkNotNullParameter(e, "e");
+                if (CancellableContinuation.this.isActive()) {
+                    CancellableContinuation cancellableContinuation = CancellableContinuation.this;
+                    Result.Companion companion = Result.Companion;
+                    cancellableContinuation.resumeWith(Result.m4060constructorimpl(ResultKt.createFailure(e)));
+                }
+            }
+        });
+        Object result = cancellableContinuationImpl.getResult();
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        if (result == coroutine_suspended) {
+            DebugProbesKt.probeCoroutineSuspended(continuation);
+        }
+        return result;
+    }
+
+    @RequiresApi(34)
+    static /* synthetic */ Object prepareGetCredential$suspendImpl(CredentialManager credentialManager, GetCredentialRequest getCredentialRequest, Continuation continuation) {
+        Continuation intercepted;
+        Object coroutine_suspended;
+        intercepted = IntrinsicsKt__IntrinsicsJvmKt.intercepted(continuation);
+        final CancellableContinuationImpl cancellableContinuationImpl = new CancellableContinuationImpl(intercepted, 1);
+        cancellableContinuationImpl.initCancellability();
+        final CancellationSignal cancellationSignal = new CancellationSignal();
+        cancellableContinuationImpl.invokeOnCancellation(new Function1() { // from class: androidx.credentials.CredentialManager$prepareGetCredential$2$1
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(1);
+            }
+
+            @Override // kotlin.jvm.functions.Function1
+            public /* bridge */ /* synthetic */ Object invoke(Object obj) {
+                invoke((Throwable) obj);
+                return Unit.INSTANCE;
+            }
+
+            public final void invoke(Throwable th) {
+                cancellationSignal.cancel();
+            }
+        });
+        credentialManager.prepareGetCredentialAsync(getCredentialRequest, cancellationSignal, new CredentialManager$$ExternalSyntheticLambda0(), new CredentialManagerCallback<PrepareGetCredentialResponse, GetCredentialException>() { // from class: androidx.credentials.CredentialManager$prepareGetCredential$2$callback$1
+            @Override // androidx.credentials.CredentialManagerCallback
+            public void onResult(PrepareGetCredentialResponse result) {
+                Intrinsics.checkNotNullParameter(result, "result");
+                if (CancellableContinuation.this.isActive()) {
+                    CancellableContinuation.this.resumeWith(Result.m4060constructorimpl(result));
+                }
+            }
+
+            @Override // androidx.credentials.CredentialManagerCallback
+            public void onError(GetCredentialException e) {
+                Intrinsics.checkNotNullParameter(e, "e");
+                if (CancellableContinuation.this.isActive()) {
+                    CancellableContinuation cancellableContinuation = CancellableContinuation.this;
+                    Result.Companion companion = Result.Companion;
+                    cancellableContinuation.resumeWith(Result.m4060constructorimpl(ResultKt.createFailure(e)));
+                }
+            }
+        });
+        Object result = cancellableContinuationImpl.getResult();
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        if (result == coroutine_suspended) {
+            DebugProbesKt.probeCoroutineSuspended(continuation);
+        }
+        return result;
+    }
+}

decompiled/sources/androidx/credentials/CredentialManagerCallback.java

@@ -0,0 +1,8 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public interface CredentialManagerCallback<R, E> {
+    void onError(E e);
+
+    void onResult(R r);
+}

decompiled/sources/androidx/credentials/CredentialManagerImpl.java

@@ -0,0 +1,122 @@
+package androidx.credentials;
+
+import android.annotation.SuppressLint;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.CancellationSignal;
+import androidx.annotation.RequiresApi;
+import androidx.core.view.accessibility.AccessibilityEventCompat;
+import androidx.credentials.PrepareGetCredentialResponse;
+import androidx.credentials.exceptions.ClearCredentialException;
+import androidx.credentials.exceptions.ClearCredentialProviderConfigurationException;
+import androidx.credentials.exceptions.CreateCredentialException;
+import androidx.credentials.exceptions.CreateCredentialProviderConfigurationException;
+import androidx.credentials.exceptions.GetCredentialException;
+import androidx.credentials.exceptions.GetCredentialProviderConfigurationException;
+import java.util.concurrent.Executor;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+@SuppressLint({"ObsoleteSdkInt"})
+/* loaded from: classes.dex */
+public final class CredentialManagerImpl implements CredentialManager {
+    public static final Companion Companion = new Companion(null);
+    private static final String INTENT_ACTION_FOR_CREDENTIAL_PROVIDER_SETTINGS = "android.settings.CREDENTIAL_PROVIDER";
+    private final Context context;
+
+    public CredentialManagerImpl(Context context) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        this.context = context;
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+    }
+
+    @Override // androidx.credentials.CredentialManager
+    public void getCredentialAsync(Context context, GetCredentialRequest request, CancellationSignal cancellationSignal, Executor executor, CredentialManagerCallback<GetCredentialResponse, GetCredentialException> callback) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(request, "request");
+        Intrinsics.checkNotNullParameter(executor, "executor");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        CredentialProvider bestAvailableProvider$default = CredentialProviderFactory.getBestAvailableProvider$default(new CredentialProviderFactory(context), request, false, 2, null);
+        if (bestAvailableProvider$default == null) {
+            callback.onError(new GetCredentialProviderConfigurationException("getCredentialAsync no provider dependencies found - please ensure the desired provider dependencies are added"));
+        } else {
+            bestAvailableProvider$default.onGetCredential(context, request, cancellationSignal, executor, callback);
+        }
+    }
+
+    @Override // androidx.credentials.CredentialManager
+    @RequiresApi(34)
+    public void getCredentialAsync(Context context, PrepareGetCredentialResponse.PendingGetCredentialHandle pendingGetCredentialHandle, CancellationSignal cancellationSignal, Executor executor, CredentialManagerCallback<GetCredentialResponse, GetCredentialException> callback) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(pendingGetCredentialHandle, "pendingGetCredentialHandle");
+        Intrinsics.checkNotNullParameter(executor, "executor");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        CredentialProvider bestAvailableProvider = new CredentialProviderFactory(context).getBestAvailableProvider(false);
+        if (bestAvailableProvider == null) {
+            callback.onError(new GetCredentialProviderConfigurationException("No Credential Manager provider found"));
+        } else {
+            bestAvailableProvider.onGetCredential(context, pendingGetCredentialHandle, cancellationSignal, executor, callback);
+        }
+    }
+
+    @Override // androidx.credentials.CredentialManager
+    @RequiresApi(34)
+    public void prepareGetCredentialAsync(GetCredentialRequest request, CancellationSignal cancellationSignal, Executor executor, CredentialManagerCallback<PrepareGetCredentialResponse, GetCredentialException> callback) {
+        Intrinsics.checkNotNullParameter(request, "request");
+        Intrinsics.checkNotNullParameter(executor, "executor");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        CredentialProvider bestAvailableProvider = new CredentialProviderFactory(this.context).getBestAvailableProvider(false);
+        if (bestAvailableProvider == null) {
+            callback.onError(new GetCredentialProviderConfigurationException("No Credential Manager provider found"));
+        } else {
+            bestAvailableProvider.onPrepareCredential(request, cancellationSignal, executor, callback);
+        }
+    }
+
+    @Override // androidx.credentials.CredentialManager
+    public void createCredentialAsync(Context context, CreateCredentialRequest request, CancellationSignal cancellationSignal, Executor executor, CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException> callback) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(request, "request");
+        Intrinsics.checkNotNullParameter(executor, "executor");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        CredentialProvider bestAvailableProvider$default = CredentialProviderFactory.getBestAvailableProvider$default(new CredentialProviderFactory(this.context), request, false, 2, null);
+        if (bestAvailableProvider$default == null) {
+            callback.onError(new CreateCredentialProviderConfigurationException("createCredentialAsync no provider dependencies found - please ensure the desired provider dependencies are added"));
+        } else {
+            bestAvailableProvider$default.onCreateCredential(context, request, cancellationSignal, executor, callback);
+        }
+    }
+
+    @Override // androidx.credentials.CredentialManager
+    public void clearCredentialStateAsync(ClearCredentialStateRequest request, CancellationSignal cancellationSignal, Executor executor, CredentialManagerCallback<Void, ClearCredentialException> callback) {
+        Intrinsics.checkNotNullParameter(request, "request");
+        Intrinsics.checkNotNullParameter(executor, "executor");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        CredentialProvider bestAvailableProvider$default = CredentialProviderFactory.getBestAvailableProvider$default(new CredentialProviderFactory(this.context), request.getRequestType(), false, 2, null);
+        if (bestAvailableProvider$default == null) {
+            callback.onError(new ClearCredentialProviderConfigurationException("clearCredentialStateAsync no provider dependencies found - please ensure the desired provider dependencies are added"));
+        } else {
+            bestAvailableProvider$default.onClearCredential(request, cancellationSignal, executor, callback);
+        }
+    }
+
+    @Override // androidx.credentials.CredentialManager
+    @RequiresApi(34)
+    public PendingIntent createSettingsPendingIntent() {
+        Intent intent = new Intent(INTENT_ACTION_FOR_CREDENTIAL_PROVIDER_SETTINGS);
+        intent.setData(Uri.parse("package:" + this.context.getPackageName()));
+        PendingIntent activity = PendingIntent.getActivity(this.context, 0, intent, AccessibilityEventCompat.TYPE_VIEW_TARGETED_BY_SCROLL);
+        Intrinsics.checkNotNullExpressionValue(activity, "getActivity(context, 0, …ingIntent.FLAG_IMMUTABLE)");
+        return activity;
+    }
+}

decompiled/sources/androidx/credentials/CredentialManagerViewHandler.java

@@ -0,0 +1,39 @@
+package androidx.credentials;
+
+import android.os.Build;
+import android.view.View;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class CredentialManagerViewHandler {
+    private static final String TAG = "ViewHandler";
+
+    public static /* synthetic */ void getPendingGetCredentialRequest$annotations(View view) {
+    }
+
+    public static final PendingGetCredentialRequest getPendingGetCredentialRequest(View view) {
+        Intrinsics.checkNotNullParameter(view, "<this>");
+        Object tag = view.getTag(R.id.androidx_credential_pendingCredentialRequest);
+        if (tag instanceof PendingGetCredentialRequest) {
+            return (PendingGetCredentialRequest) tag;
+        }
+        return null;
+    }
+
+    public static final void setPendingGetCredentialRequest(View view, PendingGetCredentialRequest pendingGetCredentialRequest) {
+        Intrinsics.checkNotNullParameter(view, "<this>");
+        view.setTag(R.id.androidx_credential_pendingCredentialRequest, pendingGetCredentialRequest);
+        if (pendingGetCredentialRequest != null) {
+            int i = Build.VERSION.SDK_INT;
+            if (i >= 35 || (i == 34 && Build.VERSION.PREVIEW_SDK_INT > 0)) {
+                Api35Impl.INSTANCE.setPendingGetCredentialRequest(view, pendingGetCredentialRequest.getRequest(), pendingGetCredentialRequest.getCallback());
+                return;
+            }
+            return;
+        }
+        int i2 = Build.VERSION.SDK_INT;
+        if (i2 >= 35 || (i2 == 34 && Build.VERSION.PREVIEW_SDK_INT > 0)) {
+            Api35Impl.INSTANCE.clearPendingGetCredentialRequest(view);
+        }
+    }
+}

decompiled/sources/androidx/credentials/CredentialOption$Companion$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialOption$Companion$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/credentials/CredentialOption$Companion$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialOption$Companion$$ExternalSyntheticApiModelOutline1 {
+}

decompiled/sources/androidx/credentials/CredentialOption$Companion$$ExternalSyntheticApiModelOutline2.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialOption$Companion$$ExternalSyntheticApiModelOutline2 {
+}

decompiled/sources/androidx/credentials/CredentialOption$Companion$$ExternalSyntheticApiModelOutline3.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialOption$Companion$$ExternalSyntheticApiModelOutline3 {
+}

decompiled/sources/androidx/credentials/CredentialOption$Companion$$ExternalSyntheticApiModelOutline4.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialOption$Companion$$ExternalSyntheticApiModelOutline4 {
+}

decompiled/sources/androidx/credentials/CredentialOption.java

@@ -0,0 +1,155 @@
+package androidx.credentials;
+
+import android.content.ComponentName;
+import android.os.Bundle;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.credentials.internal.FrameworkClassParsingException;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.Set;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public abstract class CredentialOption {
+    public static final String BUNDLE_KEY_IS_AUTO_SELECT_ALLOWED = "androidx.credentials.BUNDLE_KEY_IS_AUTO_SELECT_ALLOWED";
+    public static final String BUNDLE_KEY_TYPE_PRIORITY_VALUE = "androidx.credentials.BUNDLE_KEY_TYPE_PRIORITY_VALUE";
+    public static final Companion Companion = new Companion(null);
+    public static final int PRIORITY_DEFAULT = 2000;
+    public static final int PRIORITY_OIDC_OR_SIMILAR = 500;
+    public static final int PRIORITY_PASSKEY_OR_SIMILAR = 100;
+    public static final int PRIORITY_PASSWORD_OR_SIMILAR = 1000;
+    private final Set<ComponentName> allowedProviders;
+    private final Bundle candidateQueryData;
+    private final boolean isAutoSelectAllowed;
+    private final boolean isSystemProviderRequired;
+    private final Bundle requestData;
+    private final String type;
+    private final int typePriorityHint;
+
+    @Target({ElementType.PARAMETER, ElementType.TYPE_USE})
+    @Retention(RetentionPolicy.SOURCE)
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public @interface PriorityHints {
+    }
+
+    @RequiresApi(34)
+    public static final CredentialOption createFrom(android.credentials.CredentialOption credentialOption) {
+        return Companion.createFrom(credentialOption);
+    }
+
+    public static final CredentialOption createFrom(String str, Bundle bundle, Bundle bundle2, boolean z, Set<ComponentName> set) {
+        return Companion.createFrom(str, bundle, bundle2, z, set);
+    }
+
+    public final Set<ComponentName> getAllowedProviders() {
+        return this.allowedProviders;
+    }
+
+    public final Bundle getCandidateQueryData() {
+        return this.candidateQueryData;
+    }
+
+    public final Bundle getRequestData() {
+        return this.requestData;
+    }
+
+    public final String getType() {
+        return this.type;
+    }
+
+    public final int getTypePriorityHint() {
+        return this.typePriorityHint;
+    }
+
+    public final boolean isAutoSelectAllowed() {
+        return this.isAutoSelectAllowed;
+    }
+
+    public final boolean isSystemProviderRequired() {
+        return this.isSystemProviderRequired;
+    }
+
+    public CredentialOption(String type, Bundle requestData, Bundle candidateQueryData, boolean z, boolean z2, Set<ComponentName> allowedProviders, int i) {
+        Intrinsics.checkNotNullParameter(type, "type");
+        Intrinsics.checkNotNullParameter(requestData, "requestData");
+        Intrinsics.checkNotNullParameter(candidateQueryData, "candidateQueryData");
+        Intrinsics.checkNotNullParameter(allowedProviders, "allowedProviders");
+        this.type = type;
+        this.requestData = requestData;
+        this.candidateQueryData = candidateQueryData;
+        this.isSystemProviderRequired = z;
+        this.isAutoSelectAllowed = z2;
+        this.allowedProviders = allowedProviders;
+        this.typePriorityHint = i;
+        requestData.putBoolean("androidx.credentials.BUNDLE_KEY_IS_AUTO_SELECT_ALLOWED", z2);
+        candidateQueryData.putBoolean("androidx.credentials.BUNDLE_KEY_IS_AUTO_SELECT_ALLOWED", z2);
+        requestData.putInt(BUNDLE_KEY_TYPE_PRIORITY_VALUE, i);
+        candidateQueryData.putInt(BUNDLE_KEY_TYPE_PRIORITY_VALUE, i);
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final boolean extractAutoSelectValue$credentials_release(Bundle data) {
+            Intrinsics.checkNotNullParameter(data, "data");
+            return data.getBoolean("androidx.credentials.BUNDLE_KEY_IS_AUTO_SELECT_ALLOWED");
+        }
+
+        @RequiresApi(34)
+        public final CredentialOption createFrom(android.credentials.CredentialOption option) {
+            String type;
+            Bundle credentialRetrievalData;
+            Bundle candidateQueryData;
+            boolean isSystemProviderRequired;
+            Set<ComponentName> allowedProviders;
+            Intrinsics.checkNotNullParameter(option, "option");
+            type = option.getType();
+            Intrinsics.checkNotNullExpressionValue(type, "option.type");
+            credentialRetrievalData = option.getCredentialRetrievalData();
+            Intrinsics.checkNotNullExpressionValue(credentialRetrievalData, "option.credentialRetrievalData");
+            candidateQueryData = option.getCandidateQueryData();
+            Intrinsics.checkNotNullExpressionValue(candidateQueryData, "option.candidateQueryData");
+            isSystemProviderRequired = option.isSystemProviderRequired();
+            allowedProviders = option.getAllowedProviders();
+            Intrinsics.checkNotNullExpressionValue(allowedProviders, "option.allowedProviders");
+            return createFrom(type, credentialRetrievalData, candidateQueryData, isSystemProviderRequired, allowedProviders);
+        }
+
+        public final CredentialOption createFrom(String type, Bundle requestData, Bundle candidateQueryData, boolean z, Set<ComponentName> allowedProviders) {
+            Intrinsics.checkNotNullParameter(type, "type");
+            Intrinsics.checkNotNullParameter(requestData, "requestData");
+            Intrinsics.checkNotNullParameter(candidateQueryData, "candidateQueryData");
+            Intrinsics.checkNotNullParameter(allowedProviders, "allowedProviders");
+            try {
+                int hashCode = type.hashCode();
+                if (hashCode != -1678407252) {
+                    if (hashCode != -543568185) {
+                        if (hashCode == -95037569 && type.equals(PublicKeyCredential.TYPE_PUBLIC_KEY_CREDENTIAL)) {
+                            String string = requestData.getString(PublicKeyCredential.BUNDLE_KEY_SUBTYPE);
+                            if (string != null && string.hashCode() == -613058807 && string.equals(GetPublicKeyCredentialOption.BUNDLE_VALUE_SUBTYPE_GET_PUBLIC_KEY_CREDENTIAL_OPTION)) {
+                                return GetPublicKeyCredentialOption.Companion.createFrom$credentials_release(requestData, allowedProviders, candidateQueryData);
+                            }
+                            throw new FrameworkClassParsingException();
+                        }
+                    } else if (type.equals(PasswordCredential.TYPE_PASSWORD_CREDENTIAL)) {
+                        return GetPasswordOption.Companion.createFrom$credentials_release(requestData, allowedProviders, candidateQueryData);
+                    }
+                } else if (type.equals(DigitalCredential.TYPE_DIGITAL_CREDENTIAL)) {
+                    return GetDigitalCredentialOption.Companion.createFrom$credentials_release(requestData, candidateQueryData, z, allowedProviders);
+                }
+                throw new FrameworkClassParsingException();
+            } catch (FrameworkClassParsingException unused) {
+                return new GetCustomCredentialOption(requestData, type, candidateQueryData, z, requestData.getBoolean("androidx.credentials.BUNDLE_KEY_IS_AUTO_SELECT_ALLOWED", false), allowedProviders, requestData.getInt(CredentialOption.BUNDLE_KEY_TYPE_PRIORITY_VALUE, 2000));
+            }
+        }
+    }
+}

decompiled/sources/androidx/credentials/CredentialProvider.java

@@ -0,0 +1,37 @@
+package androidx.credentials;
+
+import android.content.Context;
+import android.os.CancellationSignal;
+import androidx.annotation.RequiresApi;
+import androidx.credentials.PrepareGetCredentialResponse;
+import androidx.credentials.exceptions.ClearCredentialException;
+import androidx.credentials.exceptions.CreateCredentialException;
+import androidx.credentials.exceptions.GetCredentialException;
+import java.util.concurrent.Executor;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public interface CredentialProvider {
+    boolean isAvailableOnDevice();
+
+    void onClearCredential(ClearCredentialStateRequest clearCredentialStateRequest, CancellationSignal cancellationSignal, Executor executor, CredentialManagerCallback<Void, ClearCredentialException> credentialManagerCallback);
+
+    void onCreateCredential(Context context, CreateCredentialRequest createCredentialRequest, CancellationSignal cancellationSignal, Executor executor, CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException> credentialManagerCallback);
+
+    void onGetCredential(Context context, GetCredentialRequest getCredentialRequest, CancellationSignal cancellationSignal, Executor executor, CredentialManagerCallback<GetCredentialResponse, GetCredentialException> credentialManagerCallback);
+
+    @RequiresApi(34)
+    default void onGetCredential(Context context, PrepareGetCredentialResponse.PendingGetCredentialHandle pendingGetCredentialHandle, CancellationSignal cancellationSignal, Executor executor, CredentialManagerCallback<GetCredentialResponse, GetCredentialException> callback) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(pendingGetCredentialHandle, "pendingGetCredentialHandle");
+        Intrinsics.checkNotNullParameter(executor, "executor");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+    }
+
+    @RequiresApi(34)
+    default void onPrepareCredential(GetCredentialRequest request, CancellationSignal cancellationSignal, Executor executor, CredentialManagerCallback<PrepareGetCredentialResponse, GetCredentialException> callback) {
+        Intrinsics.checkNotNullParameter(request, "request");
+        Intrinsics.checkNotNullParameter(executor, "executor");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+    }
+}

decompiled/sources/androidx/credentials/CredentialProviderFactory.java

@@ -0,0 +1,201 @@
+package androidx.credentials;
+
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.pm.ServiceInfo;
+import android.os.Build;
+import android.os.Bundle;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderFactory {
+    private static final String CREDENTIAL_PROVIDER_KEY = "androidx.credentials.CREDENTIAL_PROVIDER_KEY";
+    public static final Companion Companion = new Companion(null);
+    private static final int MAX_CRED_MAN_PRE_FRAMEWORK_API_LEVEL = 33;
+    private static final String TAG = "CredProviderFactory";
+    private final Context context;
+    private boolean testMode;
+    private CredentialProvider testPostUProvider;
+    private CredentialProvider testPreUProvider;
+
+    public final Context getContext() {
+        return this.context;
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    @VisibleForTesting
+    public final boolean getTestMode() {
+        return this.testMode;
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    @VisibleForTesting
+    public final CredentialProvider getTestPostUProvider() {
+        return this.testPostUProvider;
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    @VisibleForTesting
+    public final CredentialProvider getTestPreUProvider() {
+        return this.testPreUProvider;
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    @VisibleForTesting
+    public final void setTestMode(boolean z) {
+        this.testMode = z;
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    @VisibleForTesting
+    public final void setTestPostUProvider(CredentialProvider credentialProvider) {
+        this.testPostUProvider = credentialProvider;
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    @VisibleForTesting
+    public final void setTestPreUProvider(CredentialProvider credentialProvider) {
+        this.testPreUProvider = credentialProvider;
+    }
+
+    public CredentialProviderFactory(Context context) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        this.context = context;
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+    }
+
+    public static /* synthetic */ CredentialProvider getBestAvailableProvider$default(CredentialProviderFactory credentialProviderFactory, Object obj, boolean z, int i, Object obj2) {
+        if ((i & 2) != 0) {
+            z = true;
+        }
+        return credentialProviderFactory.getBestAvailableProvider(obj, z);
+    }
+
+    public final CredentialProvider getBestAvailableProvider(Object request, boolean z) {
+        Intrinsics.checkNotNullParameter(request, "request");
+        if ((request instanceof CreateRestoreCredentialRequest) || Intrinsics.areEqual(request, ClearCredentialStateRequest.TYPE_CLEAR_RESTORE_CREDENTIAL)) {
+            return tryCreatePreUOemProvider();
+        }
+        if (request instanceof GetCredentialRequest) {
+            for (CredentialOption credentialOption : ((GetCredentialRequest) request).getCredentialOptions()) {
+                if ((credentialOption instanceof GetRestoreCredentialOption) || (credentialOption instanceof GetDigitalCredentialOption)) {
+                    return tryCreatePreUOemProvider();
+                }
+            }
+        }
+        return getBestAvailableProvider(z);
+    }
+
+    public static /* synthetic */ CredentialProvider getBestAvailableProvider$default(CredentialProviderFactory credentialProviderFactory, boolean z, int i, Object obj) {
+        if ((i & 1) != 0) {
+            z = true;
+        }
+        return credentialProviderFactory.getBestAvailableProvider(z);
+    }
+
+    public final CredentialProvider getBestAvailableProvider(boolean z) {
+        int i = Build.VERSION.SDK_INT;
+        if (i >= 34) {
+            CredentialProvider tryCreatePostUProvider = tryCreatePostUProvider();
+            return (tryCreatePostUProvider == null && z) ? tryCreatePreUOemProvider() : tryCreatePostUProvider;
+        }
+        if (i <= 33) {
+            return tryCreatePreUOemProvider();
+        }
+        return null;
+    }
+
+    private final CredentialProvider tryCreatePreUOemProvider() {
+        if (!this.testMode) {
+            List<String> allowedProvidersFromManifest = getAllowedProvidersFromManifest(this.context);
+            if (allowedProvidersFromManifest.isEmpty()) {
+                return null;
+            }
+            return instantiatePreUProvider(allowedProvidersFromManifest, this.context);
+        }
+        CredentialProvider credentialProvider = this.testPreUProvider;
+        if (credentialProvider == null) {
+            return null;
+        }
+        Intrinsics.checkNotNull(credentialProvider);
+        if (credentialProvider.isAvailableOnDevice()) {
+            return this.testPreUProvider;
+        }
+        return null;
+    }
+
+    @RequiresApi(34)
+    private final CredentialProvider tryCreatePostUProvider() {
+        if (!this.testMode) {
+            CredentialProviderFrameworkImpl credentialProviderFrameworkImpl = new CredentialProviderFrameworkImpl(this.context);
+            if (credentialProviderFrameworkImpl.isAvailableOnDevice()) {
+                return credentialProviderFrameworkImpl;
+            }
+            return null;
+        }
+        CredentialProvider credentialProvider = this.testPostUProvider;
+        if (credentialProvider == null) {
+            return null;
+        }
+        Intrinsics.checkNotNull(credentialProvider);
+        if (credentialProvider.isAvailableOnDevice()) {
+            return this.testPostUProvider;
+        }
+        return null;
+    }
+
+    private final CredentialProvider instantiatePreUProvider(List<String> list, Context context) {
+        Iterator<String> it = list.iterator();
+        CredentialProvider credentialProvider = null;
+        while (it.hasNext()) {
+            try {
+                Object newInstance = Class.forName(it.next()).getConstructor(Context.class).newInstance(context);
+                Intrinsics.checkNotNull(newInstance, "null cannot be cast to non-null type androidx.credentials.CredentialProvider");
+                CredentialProvider credentialProvider2 = (CredentialProvider) newInstance;
+                if (!credentialProvider2.isAvailableOnDevice()) {
+                    continue;
+                } else {
+                    if (credentialProvider != null) {
+                        return null;
+                    }
+                    credentialProvider = credentialProvider2;
+                }
+            } catch (Throwable unused) {
+            }
+        }
+        return credentialProvider;
+    }
+
+    private final List<String> getAllowedProvidersFromManifest(Context context) {
+        String string;
+        PackageInfo packageInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), 132);
+        ArrayList arrayList = new ArrayList();
+        ServiceInfo[] serviceInfoArr = packageInfo.services;
+        if (serviceInfoArr != null) {
+            Intrinsics.checkNotNull(serviceInfoArr);
+            for (ServiceInfo serviceInfo : serviceInfoArr) {
+                Bundle bundle = serviceInfo.metaData;
+                if (bundle != null && (string = bundle.getString(CREDENTIAL_PROVIDER_KEY)) != null) {
+                    arrayList.add(string);
+                }
+            }
+        }
+        return CollectionsKt___CollectionsKt.toList(arrayList);
+    }
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline1 {
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline10.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline10 {
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline11.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline11 {
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline12.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline12 {
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline13.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline13 {
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline14.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline14 {
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline15.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline15 {
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline16.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline16 {
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline17.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline17 {
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline18.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline18 {
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline19.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline19 {
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline2.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline2 {
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline20.java

@@ -0,0 +1,11 @@
+package androidx.credentials;
+
+import android.credentials.GetCredentialRequest;
+import android.os.Bundle;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline20 {
+    public static /* synthetic */ GetCredentialRequest.Builder m(Bundle bundle) {
+        return new GetCredentialRequest.Builder(bundle);
+    }
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline21.java

@@ -0,0 +1,11 @@
+package androidx.credentials;
+
+import android.credentials.CredentialOption;
+import android.os.Bundle;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline21 {
+    public static /* synthetic */ CredentialOption.Builder m(String str, Bundle bundle, Bundle bundle2) {
+        return new CredentialOption.Builder(str, bundle, bundle2);
+    }
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline22.java

@@ -0,0 +1,7 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline22 {
+    public static /* synthetic */ void m() {
+    }
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline23.java

@@ -0,0 +1,7 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline23 {
+    public static /* synthetic */ void m() {
+    }
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline24.java

@@ -0,0 +1,11 @@
+package androidx.credentials;
+
+import android.credentials.CreateCredentialRequest;
+import android.os.Bundle;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline24 {
+    public static /* synthetic */ CreateCredentialRequest.Builder m(String str, Bundle bundle, Bundle bundle2) {
+        return new CreateCredentialRequest.Builder(str, bundle, bundle2);
+    }
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline25.java

@@ -0,0 +1,7 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline25 {
+    public static /* synthetic */ void m() {
+    }
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline26.java

@@ -0,0 +1,10 @@
+package androidx.credentials;
+
+import android.os.Bundle;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline26 {
+    public static /* synthetic */ android.credentials.ClearCredentialStateRequest m(Bundle bundle) {
+        return new android.credentials.ClearCredentialStateRequest(bundle);
+    }
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline27.java

@@ -0,0 +1,7 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline27 {
+    public static /* synthetic */ void m() {
+    }
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline3.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline3 {
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline4.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline4 {
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline5.java

@@ -0,0 +1,8 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline5 {
+    public static /* bridge */ /* synthetic */ android.credentials.CredentialManager m(Object obj) {
+        return (android.credentials.CredentialManager) obj;
+    }
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline6.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline6 {
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline7.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline7 {
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline8.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline8 {
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline9.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline9 {
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$onClearCredential$outcome$1$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,10 @@
+package androidx.credentials;
+
+import android.credentials.ClearCredentialStateException;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$onClearCredential$outcome$1$$ExternalSyntheticApiModelOutline0 {
+    public static /* bridge */ /* synthetic */ ClearCredentialStateException m(Object obj) {
+        return (ClearCredentialStateException) obj;
+    }
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$onCreateCredential$outcome$1$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$onCreateCredential$outcome$1$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$onCreateCredential$outcome$1$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,8 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$onCreateCredential$outcome$1$$ExternalSyntheticApiModelOutline1 {
+    public static /* bridge */ /* synthetic */ android.credentials.CreateCredentialResponse m(Object obj) {
+        return (android.credentials.CreateCredentialResponse) obj;
+    }
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$onCreateCredential$outcome$1$$ExternalSyntheticApiModelOutline2.java

@@ -0,0 +1,10 @@
+package androidx.credentials;
+
+import android.credentials.CreateCredentialException;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$onCreateCredential$outcome$1$$ExternalSyntheticApiModelOutline2 {
+    public static /* bridge */ /* synthetic */ CreateCredentialException m(Object obj) {
+        return (CreateCredentialException) obj;
+    }
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl$onPrepareCredential$outcome$1$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,8 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class CredentialProviderFrameworkImpl$onPrepareCredential$outcome$1$$ExternalSyntheticApiModelOutline0 {
+    public static /* bridge */ /* synthetic */ android.credentials.PrepareGetCredentialResponse m(Object obj) {
+        return (android.credentials.PrepareGetCredentialResponse) obj;
+    }
+}

decompiled/sources/androidx/credentials/CredentialProviderFrameworkImpl.java

@@ -0,0 +1,411 @@
+package androidx.credentials;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.credentials.ClearCredentialStateException;
+import android.credentials.CreateCredentialRequest;
+import android.credentials.CredentialOption;
+import android.credentials.GetCredentialRequest;
+import android.credentials.PrepareGetCredentialResponse;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.CancellationSignal;
+import android.os.OutcomeReceiver;
+import androidx.annotation.RequiresApi;
+import androidx.core.os.OutcomeReceiverKt$$ExternalSyntheticApiModelOutline0;
+import androidx.credentials.CreateCredentialResponse;
+import androidx.credentials.Credential;
+import androidx.credentials.PrepareGetCredentialResponse;
+import androidx.credentials.exceptions.ClearCredentialException;
+import androidx.credentials.exceptions.ClearCredentialUnknownException;
+import androidx.credentials.exceptions.ClearCredentialUnsupportedException;
+import androidx.credentials.exceptions.CreateCredentialException;
+import androidx.credentials.exceptions.CreateCredentialUnsupportedException;
+import androidx.credentials.exceptions.GetCredentialException;
+import androidx.credentials.exceptions.GetCredentialUnsupportedException;
+import androidx.credentials.internal.ConversionUtilsKt;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@RequiresApi(34)
+@SourceDebugExtension({"SMAP\nCredentialProviderFrameworkImpl.kt\nKotlin\n*S Kotlin\n*F\n+ 1 CredentialProviderFrameworkImpl.kt\nandroidx/credentials/CredentialProviderFrameworkImpl\n+ 2 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n*L\n1#1,378:1\n1855#2,2:379\n*S KotlinDebug\n*F\n+ 1 CredentialProviderFrameworkImpl.kt\nandroidx/credentials/CredentialProviderFrameworkImpl\n*L\n261#1:379,2\n*E\n"})
+/* loaded from: classes.dex */
+public final class CredentialProviderFrameworkImpl implements CredentialProvider {
+    private static final String CREATE_DOM_EXCEPTION_PREFIX = "androidx.credentials.TYPE_CREATE_PUBLIC_KEY_CREDENTIAL_DOM_EXCEPTION";
+    private static final Companion Companion = new Companion(null);
+    private static final String GET_DOM_EXCEPTION_PREFIX = "androidx.credentials.TYPE_GET_PUBLIC_KEY_CREDENTIAL_DOM_EXCEPTION";
+    private static final String TAG = "CredManProvService";
+    private final android.credentials.CredentialManager credentialManager;
+
+    @Override // androidx.credentials.CredentialProvider
+    public boolean isAvailableOnDevice() {
+        return Build.VERSION.SDK_INT >= 34 && this.credentialManager != null;
+    }
+
+    public CredentialProviderFrameworkImpl(Context context) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        this.credentialManager = CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline5.m(context.getSystemService("credential"));
+    }
+
+    @Override // androidx.credentials.CredentialProvider
+    public void onPrepareCredential(GetCredentialRequest request, CancellationSignal cancellationSignal, Executor executor, final CredentialManagerCallback<PrepareGetCredentialResponse, GetCredentialException> callback) {
+        Intrinsics.checkNotNullParameter(request, "request");
+        Intrinsics.checkNotNullParameter(executor, "executor");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        if (isCredmanDisabled(new Function0() { // from class: androidx.credentials.CredentialProviderFrameworkImpl$onPrepareCredential$1
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(0);
+            }
+
+            @Override // kotlin.jvm.functions.Function0
+            public /* bridge */ /* synthetic */ Object invoke() {
+                m71invoke();
+                return Unit.INSTANCE;
+            }
+
+            /* renamed from: invoke, reason: collision with other method in class */
+            public final void m71invoke() {
+                callback.onError(new GetCredentialUnsupportedException("Your device doesn't support credential manager"));
+            }
+        })) {
+            return;
+        }
+        OutcomeReceiver outcomeReceiver = new OutcomeReceiver() { // from class: androidx.credentials.CredentialProviderFrameworkImpl$onPrepareCredential$outcome$1
+            public /* bridge */ /* synthetic */ void onError(Throwable th) {
+                onError(Api35Impl$setPendingGetCredentialRequest$frameworkCallback$1$$ExternalSyntheticApiModelOutline3.m(th));
+            }
+
+            public /* bridge */ /* synthetic */ void onResult(Object obj) {
+                onResult(CredentialProviderFrameworkImpl$onPrepareCredential$outcome$1$$ExternalSyntheticApiModelOutline0.m(obj));
+            }
+
+            public void onResult(android.credentials.PrepareGetCredentialResponse response) {
+                Intrinsics.checkNotNullParameter(response, "response");
+                callback.onResult(this.convertPrepareGetResponseToJetpackClass$credentials_release(response));
+            }
+
+            public void onError(android.credentials.GetCredentialException error) {
+                Intrinsics.checkNotNullParameter(error, "error");
+                callback.onError(this.convertToJetpackGetException$credentials_release(error));
+            }
+        };
+        android.credentials.CredentialManager credentialManager = this.credentialManager;
+        Intrinsics.checkNotNull(credentialManager);
+        credentialManager.prepareGetCredential(convertGetRequestToFrameworkClass(request), cancellationSignal, executor, OutcomeReceiverKt$$ExternalSyntheticApiModelOutline0.m(outcomeReceiver));
+    }
+
+    @Override // androidx.credentials.CredentialProvider
+    public void onGetCredential(Context context, PrepareGetCredentialResponse.PendingGetCredentialHandle pendingGetCredentialHandle, CancellationSignal cancellationSignal, Executor executor, final CredentialManagerCallback<GetCredentialResponse, GetCredentialException> callback) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(pendingGetCredentialHandle, "pendingGetCredentialHandle");
+        Intrinsics.checkNotNullParameter(executor, "executor");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        if (isCredmanDisabled(new Function0() { // from class: androidx.credentials.CredentialProviderFrameworkImpl$onGetCredential$1
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(0);
+            }
+
+            @Override // kotlin.jvm.functions.Function0
+            public /* bridge */ /* synthetic */ Object invoke() {
+                m69invoke();
+                return Unit.INSTANCE;
+            }
+
+            /* renamed from: invoke, reason: collision with other method in class */
+            public final void m69invoke() {
+                callback.onError(new GetCredentialUnsupportedException("Your device doesn't support credential manager"));
+            }
+        })) {
+            return;
+        }
+        OutcomeReceiver outcomeReceiver = new OutcomeReceiver() { // from class: androidx.credentials.CredentialProviderFrameworkImpl$onGetCredential$outcome$1
+            public /* bridge */ /* synthetic */ void onError(Throwable th) {
+                onError(Api35Impl$setPendingGetCredentialRequest$frameworkCallback$1$$ExternalSyntheticApiModelOutline3.m(th));
+            }
+
+            public /* bridge */ /* synthetic */ void onResult(Object obj) {
+                onResult(Api35Impl$setPendingGetCredentialRequest$frameworkCallback$1$$ExternalSyntheticApiModelOutline0.m(obj));
+            }
+
+            public void onResult(android.credentials.GetCredentialResponse response) {
+                Intrinsics.checkNotNullParameter(response, "response");
+                callback.onResult(this.convertGetResponseToJetpackClass$credentials_release(response));
+            }
+
+            public void onError(android.credentials.GetCredentialException error) {
+                Intrinsics.checkNotNullParameter(error, "error");
+                callback.onError(this.convertToJetpackGetException$credentials_release(error));
+            }
+        };
+        android.credentials.CredentialManager credentialManager = this.credentialManager;
+        Intrinsics.checkNotNull(credentialManager);
+        PrepareGetCredentialResponse.PendingGetCredentialHandle frameworkHandle = pendingGetCredentialHandle.getFrameworkHandle();
+        Intrinsics.checkNotNull(frameworkHandle);
+        credentialManager.getCredential(context, frameworkHandle, cancellationSignal, executor, (OutcomeReceiver<android.credentials.GetCredentialResponse, android.credentials.GetCredentialException>) OutcomeReceiverKt$$ExternalSyntheticApiModelOutline0.m(outcomeReceiver));
+    }
+
+    @Override // androidx.credentials.CredentialProvider
+    public void onGetCredential(Context context, GetCredentialRequest request, CancellationSignal cancellationSignal, Executor executor, final CredentialManagerCallback<GetCredentialResponse, GetCredentialException> callback) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(request, "request");
+        Intrinsics.checkNotNullParameter(executor, "executor");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        if (isCredmanDisabled(new Function0() { // from class: androidx.credentials.CredentialProviderFrameworkImpl$onGetCredential$2
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(0);
+            }
+
+            @Override // kotlin.jvm.functions.Function0
+            public /* bridge */ /* synthetic */ Object invoke() {
+                m70invoke();
+                return Unit.INSTANCE;
+            }
+
+            /* renamed from: invoke, reason: collision with other method in class */
+            public final void m70invoke() {
+                callback.onError(new GetCredentialUnsupportedException("Your device doesn't support credential manager"));
+            }
+        })) {
+            return;
+        }
+        OutcomeReceiver outcomeReceiver = new OutcomeReceiver() { // from class: androidx.credentials.CredentialProviderFrameworkImpl$onGetCredential$outcome$2
+            public /* bridge */ /* synthetic */ void onError(Throwable th) {
+                onError(Api35Impl$setPendingGetCredentialRequest$frameworkCallback$1$$ExternalSyntheticApiModelOutline3.m(th));
+            }
+
+            public /* bridge */ /* synthetic */ void onResult(Object obj) {
+                onResult(Api35Impl$setPendingGetCredentialRequest$frameworkCallback$1$$ExternalSyntheticApiModelOutline0.m(obj));
+            }
+
+            public void onResult(android.credentials.GetCredentialResponse response) {
+                Intrinsics.checkNotNullParameter(response, "response");
+                callback.onResult(this.convertGetResponseToJetpackClass$credentials_release(response));
+            }
+
+            public void onError(android.credentials.GetCredentialException error) {
+                Intrinsics.checkNotNullParameter(error, "error");
+                callback.onError(this.convertToJetpackGetException$credentials_release(error));
+            }
+        };
+        android.credentials.CredentialManager credentialManager = this.credentialManager;
+        Intrinsics.checkNotNull(credentialManager);
+        credentialManager.getCredential(context, convertGetRequestToFrameworkClass(request), cancellationSignal, executor, (OutcomeReceiver<android.credentials.GetCredentialResponse, android.credentials.GetCredentialException>) OutcomeReceiverKt$$ExternalSyntheticApiModelOutline0.m(outcomeReceiver));
+    }
+
+    private final boolean isCredmanDisabled(Function0 function0) {
+        if (this.credentialManager != null) {
+            return false;
+        }
+        function0.invoke();
+        return true;
+    }
+
+    @Override // androidx.credentials.CredentialProvider
+    public void onCreateCredential(Context context, final CreateCredentialRequest request, CancellationSignal cancellationSignal, Executor executor, final CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException> callback) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(request, "request");
+        Intrinsics.checkNotNullParameter(executor, "executor");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        if (isCredmanDisabled(new Function0() { // from class: androidx.credentials.CredentialProviderFrameworkImpl$onCreateCredential$1
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(0);
+            }
+
+            @Override // kotlin.jvm.functions.Function0
+            public /* bridge */ /* synthetic */ Object invoke() {
+                m68invoke();
+                return Unit.INSTANCE;
+            }
+
+            /* renamed from: invoke, reason: collision with other method in class */
+            public final void m68invoke() {
+                callback.onError(new CreateCredentialUnsupportedException("Your device doesn't support credential manager"));
+            }
+        })) {
+            return;
+        }
+        OutcomeReceiver outcomeReceiver = new OutcomeReceiver() { // from class: androidx.credentials.CredentialProviderFrameworkImpl$onCreateCredential$outcome$1
+            public /* bridge */ /* synthetic */ void onError(Throwable th) {
+                onError(CredentialProviderFrameworkImpl$onCreateCredential$outcome$1$$ExternalSyntheticApiModelOutline2.m(th));
+            }
+
+            public /* bridge */ /* synthetic */ void onResult(Object obj) {
+                onResult(CredentialProviderFrameworkImpl$onCreateCredential$outcome$1$$ExternalSyntheticApiModelOutline1.m(obj));
+            }
+
+            public void onResult(android.credentials.CreateCredentialResponse response) {
+                Bundle data;
+                Intrinsics.checkNotNullParameter(response, "response");
+                CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException> credentialManagerCallback = callback;
+                CreateCredentialResponse.Companion companion = CreateCredentialResponse.Companion;
+                String type = request.getType();
+                data = response.getData();
+                Intrinsics.checkNotNullExpressionValue(data, "response.data");
+                credentialManagerCallback.onResult(companion.createFrom(type, data));
+            }
+
+            public void onError(android.credentials.CreateCredentialException error) {
+                Intrinsics.checkNotNullParameter(error, "error");
+                callback.onError(this.convertToJetpackCreateException$credentials_release(error));
+            }
+        };
+        android.credentials.CredentialManager credentialManager = this.credentialManager;
+        Intrinsics.checkNotNull(credentialManager);
+        credentialManager.createCredential(context, convertCreateRequestToFrameworkClass(request, context), cancellationSignal, executor, OutcomeReceiverKt$$ExternalSyntheticApiModelOutline0.m(outcomeReceiver));
+    }
+
+    private final android.credentials.CreateCredentialRequest convertCreateRequestToFrameworkClass(CreateCredentialRequest createCredentialRequest, Context context) {
+        CreateCredentialRequest.Builder isSystemProviderRequired;
+        CreateCredentialRequest.Builder alwaysSendAppInfoToProvider;
+        android.credentials.CreateCredentialRequest build;
+        CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline25.m();
+        isSystemProviderRequired = CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline24.m(createCredentialRequest.getType(), ConversionUtilsKt.getFinalCreateCredentialData(createCredentialRequest, context), createCredentialRequest.getCandidateQueryData()).setIsSystemProviderRequired(createCredentialRequest.isSystemProviderRequired());
+        alwaysSendAppInfoToProvider = isSystemProviderRequired.setAlwaysSendAppInfoToProvider(true);
+        Intrinsics.checkNotNullExpressionValue(alwaysSendAppInfoToProvider, "Builder(\n               …ndAppInfoToProvider(true)");
+        setOriginForCreateRequest(createCredentialRequest, alwaysSendAppInfoToProvider);
+        build = alwaysSendAppInfoToProvider.build();
+        Intrinsics.checkNotNullExpressionValue(build, "createCredentialRequestBuilder.build()");
+        return build;
+    }
+
+    @SuppressLint({"MissingPermission"})
+    private final void setOriginForCreateRequest(CreateCredentialRequest createCredentialRequest, CreateCredentialRequest.Builder builder) {
+        if (createCredentialRequest.getOrigin() != null) {
+            builder.setOrigin(createCredentialRequest.getOrigin());
+        }
+    }
+
+    private final android.credentials.GetCredentialRequest convertGetRequestToFrameworkClass(GetCredentialRequest getCredentialRequest) {
+        android.credentials.GetCredentialRequest build;
+        CredentialOption.Builder isSystemProviderRequired;
+        CredentialOption.Builder allowedProviders;
+        android.credentials.CredentialOption build2;
+        CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline22.m();
+        GetCredentialRequest.Builder m = CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline20.m(GetCredentialRequest.Companion.getRequestMetadataBundle(getCredentialRequest));
+        for (CredentialOption credentialOption : getCredentialRequest.getCredentialOptions()) {
+            CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline23.m();
+            isSystemProviderRequired = CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline21.m(credentialOption.getType(), credentialOption.getRequestData(), credentialOption.getCandidateQueryData()).setIsSystemProviderRequired(credentialOption.isSystemProviderRequired());
+            allowedProviders = isSystemProviderRequired.setAllowedProviders(credentialOption.getAllowedProviders());
+            build2 = allowedProviders.build();
+            m.addCredentialOption(build2);
+        }
+        setOriginForGetRequest(getCredentialRequest, m);
+        build = m.build();
+        Intrinsics.checkNotNullExpressionValue(build, "builder.build()");
+        return build;
+    }
+
+    @SuppressLint({"MissingPermission"})
+    private final void setOriginForGetRequest(GetCredentialRequest getCredentialRequest, GetCredentialRequest.Builder builder) {
+        if (getCredentialRequest.getOrigin() != null) {
+            builder.setOrigin(getCredentialRequest.getOrigin());
+        }
+    }
+
+    private final android.credentials.ClearCredentialStateRequest createFrameworkClearCredentialRequest() {
+        CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline27.m();
+        return CredentialProviderFrameworkImpl$$ExternalSyntheticApiModelOutline26.m(new Bundle());
+    }
+
+    public final GetCredentialException convertToJetpackGetException$credentials_release(android.credentials.GetCredentialException error) {
+        String type;
+        String message;
+        Intrinsics.checkNotNullParameter(error, "error");
+        type = error.getType();
+        Intrinsics.checkNotNullExpressionValue(type, "error.type");
+        message = error.getMessage();
+        return ConversionUtilsKt.toJetpackGetException(type, message);
+    }
+
+    public final CreateCredentialException convertToJetpackCreateException$credentials_release(android.credentials.CreateCredentialException error) {
+        String type;
+        String message;
+        Intrinsics.checkNotNullParameter(error, "error");
+        type = error.getType();
+        Intrinsics.checkNotNullExpressionValue(type, "error.type");
+        message = error.getMessage();
+        return ConversionUtilsKt.toJetpackCreateException(type, message);
+    }
+
+    public final GetCredentialResponse convertGetResponseToJetpackClass$credentials_release(android.credentials.GetCredentialResponse response) {
+        android.credentials.Credential credential;
+        String type;
+        Bundle data;
+        Intrinsics.checkNotNullParameter(response, "response");
+        credential = response.getCredential();
+        Intrinsics.checkNotNullExpressionValue(credential, "response.credential");
+        Credential.Companion companion = Credential.Companion;
+        type = credential.getType();
+        Intrinsics.checkNotNullExpressionValue(type, "credential.type");
+        data = credential.getData();
+        Intrinsics.checkNotNullExpressionValue(data, "credential.data");
+        return new GetCredentialResponse(companion.createFrom(type, data));
+    }
+
+    public final PrepareGetCredentialResponse convertPrepareGetResponseToJetpackClass$credentials_release(android.credentials.PrepareGetCredentialResponse response) {
+        PrepareGetCredentialResponse.PendingGetCredentialHandle pendingGetCredentialHandle;
+        Intrinsics.checkNotNullParameter(response, "response");
+        pendingGetCredentialHandle = response.getPendingGetCredentialHandle();
+        return new PrepareGetCredentialResponse.Builder().setFrameworkResponse(response).setPendingGetCredentialHandle(new PrepareGetCredentialResponse.PendingGetCredentialHandle(pendingGetCredentialHandle)).build();
+    }
+
+    @Override // androidx.credentials.CredentialProvider
+    public void onClearCredential(ClearCredentialStateRequest request, CancellationSignal cancellationSignal, Executor executor, final CredentialManagerCallback<Void, ClearCredentialException> callback) {
+        Intrinsics.checkNotNullParameter(request, "request");
+        Intrinsics.checkNotNullParameter(executor, "executor");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        if (isCredmanDisabled(new Function0() { // from class: androidx.credentials.CredentialProviderFrameworkImpl$onClearCredential$1
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(0);
+            }
+
+            @Override // kotlin.jvm.functions.Function0
+            public /* bridge */ /* synthetic */ Object invoke() {
+                m67invoke();
+                return Unit.INSTANCE;
+            }
+
+            /* renamed from: invoke, reason: collision with other method in class */
+            public final void m67invoke() {
+                callback.onError(new ClearCredentialUnsupportedException("Your device doesn't support credential manager"));
+            }
+        })) {
+            return;
+        }
+        OutcomeReceiver outcomeReceiver = new OutcomeReceiver() { // from class: androidx.credentials.CredentialProviderFrameworkImpl$onClearCredential$outcome$1
+            public /* bridge */ /* synthetic */ void onError(Throwable th) {
+                onError(CredentialProviderFrameworkImpl$onClearCredential$outcome$1$$ExternalSyntheticApiModelOutline0.m(th));
+            }
+
+            public void onResult(Void r2) {
+                callback.onResult(r2);
+            }
+
+            public void onError(ClearCredentialStateException error) {
+                Intrinsics.checkNotNullParameter(error, "error");
+                callback.onError(new ClearCredentialUnknownException(null, 1, null));
+            }
+        };
+        android.credentials.CredentialManager credentialManager = this.credentialManager;
+        Intrinsics.checkNotNull(credentialManager);
+        credentialManager.clearCredentialState(createFrameworkClearCredentialRequest(), cancellationSignal, executor, OutcomeReceiverKt$$ExternalSyntheticApiModelOutline0.m(outcomeReceiver));
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+    }
+}

decompiled/sources/androidx/credentials/CustomCredential.java

@@ -0,0 +1,19 @@
+package androidx.credentials;
+
+import android.os.Bundle;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nCustomCredential.kt\nKotlin\n*S Kotlin\n*F\n+ 1 CustomCredential.kt\nandroidx/credentials/CustomCredential\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,46:1\n1#2:47\n*E\n"})
+/* loaded from: classes.dex */
+public class CustomCredential extends Credential {
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CustomCredential(String type, Bundle data) {
+        super(type, data);
+        Intrinsics.checkNotNullParameter(type, "type");
+        Intrinsics.checkNotNullParameter(data, "data");
+        if (type.length() <= 0) {
+            throw new IllegalArgumentException("type should not be empty".toString());
+        }
+    }
+}

decompiled/sources/androidx/credentials/DigitalCredential.java

@@ -0,0 +1,65 @@
+package androidx.credentials;
+
+import android.os.Bundle;
+import androidx.credentials.internal.FrameworkClassParsingException;
+import androidx.credentials.internal.RequestValidationHelper;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+@ExperimentalDigitalCredentialApi
+/* loaded from: classes.dex */
+public final class DigitalCredential extends Credential {
+    public static final String BUNDLE_KEY_REQUEST_JSON = "androidx.credentials.BUNDLE_KEY_REQUEST_JSON";
+    public static final Companion Companion = new Companion(null);
+    public static final String TYPE_DIGITAL_CREDENTIAL = "androidx.credentials.TYPE_DIGITAL_CREDENTIAL";
+    private final String credentialJson;
+
+    public /* synthetic */ DigitalCredential(String str, Bundle bundle, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, bundle);
+    }
+
+    public final String getCredentialJson() {
+        return this.credentialJson;
+    }
+
+    private DigitalCredential(String str, Bundle bundle) {
+        super(TYPE_DIGITAL_CREDENTIAL, bundle);
+        this.credentialJson = str;
+        if (!RequestValidationHelper.Companion.isValidJSON(str)) {
+            throw new IllegalArgumentException("credentialJson must not be empty, and must be a valid JSON".toString());
+        }
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public DigitalCredential(String credentialJson) {
+        this(credentialJson, Companion.toBundle$credentials_release(credentialJson));
+        Intrinsics.checkNotNullParameter(credentialJson, "credentialJson");
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final DigitalCredential createFrom$credentials_release(Bundle data) {
+            Intrinsics.checkNotNullParameter(data, "data");
+            try {
+                String string = data.getString("androidx.credentials.BUNDLE_KEY_REQUEST_JSON");
+                Intrinsics.checkNotNull(string);
+                return new DigitalCredential(string, data, null);
+            } catch (Exception unused) {
+                throw new FrameworkClassParsingException();
+            }
+        }
+
+        public final Bundle toBundle$credentials_release(String responseJson) {
+            Intrinsics.checkNotNullParameter(responseJson, "responseJson");
+            Bundle bundle = new Bundle();
+            bundle.putString("androidx.credentials.BUNDLE_KEY_REQUEST_JSON", responseJson);
+            return bundle;
+        }
+    }
+}

decompiled/sources/androidx/credentials/ExperimentalDigitalCredentialApi.java

@@ -0,0 +1,9 @@
+package androidx.credentials;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.CLASS)
+/* loaded from: classes.dex */
+public @interface ExperimentalDigitalCredentialApi {
+}

decompiled/sources/androidx/credentials/FederatedCredential.java

@@ -0,0 +1,23 @@
+package androidx.credentials;
+
+import android.os.Bundle;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+
+/* loaded from: classes.dex */
+public final class FederatedCredential extends Credential {
+    public static final Companion Companion = new Companion(null);
+    public static final String TYPE_FEDERATED_CREDENTIAL = "type.federated_credential";
+
+    private FederatedCredential() {
+        super(TYPE_FEDERATED_CREDENTIAL, new Bundle());
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+    }
+}

decompiled/sources/androidx/credentials/GetCredentialRequest$Companion$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class GetCredentialRequest$Companion$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/credentials/GetCredentialRequest$Companion$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,8 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class GetCredentialRequest$Companion$$ExternalSyntheticApiModelOutline1 {
+    public static /* bridge */ /* synthetic */ android.credentials.CredentialOption m(Object obj) {
+        return (android.credentials.CredentialOption) obj;
+    }
+}

decompiled/sources/androidx/credentials/GetCredentialRequest$Companion$$ExternalSyntheticApiModelOutline2.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class GetCredentialRequest$Companion$$ExternalSyntheticApiModelOutline2 {
+}

decompiled/sources/androidx/credentials/GetCredentialRequest$Companion$$ExternalSyntheticApiModelOutline3.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class GetCredentialRequest$Companion$$ExternalSyntheticApiModelOutline3 {
+}

decompiled/sources/androidx/credentials/GetCredentialRequest.java

@@ -0,0 +1,228 @@
+package androidx.credentials;
+
+import android.content.ComponentName;
+import android.os.Bundle;
+import androidx.annotation.RequiresApi;
+import androidx.credentials.CredentialOption;
+import androidx.credentials.internal.FrameworkClassParsingException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import kotlin.collections.CollectionsKt__CollectionsKt;
+import kotlin.collections.CollectionsKt__IterablesKt;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nGetCredentialRequest.kt\nKotlin\n*S Kotlin\n*F\n+ 1 GetCredentialRequest.kt\nandroidx/credentials/GetCredentialRequest\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n+ 3 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n*L\n1#1,276:1\n1#2:277\n1774#3,4:278\n*S KotlinDebug\n*F\n+ 1 GetCredentialRequest.kt\nandroidx/credentials/GetCredentialRequest\n*L\n81#1:278,4\n*E\n"})
+/* loaded from: classes.dex */
+public final class GetCredentialRequest {
+    private static final String BUNDLE_KEY_PREFER_IDENTITY_DOC_UI = "androidx.credentials.BUNDLE_KEY_PREFER_IDENTITY_DOC_UI";
+    public static final String BUNDLE_KEY_PREFER_IMMEDIATELY_AVAILABLE_CREDENTIALS = "androidx.credentials.BUNDLE_KEY_PREFER_IMMEDIATELY_AVAILABLE_CREDENTIALS";
+    private static final String BUNDLE_KEY_PREFER_UI_BRANDING_COMPONENT_NAME = "androidx.credentials.BUNDLE_KEY_PREFER_UI_BRANDING_COMPONENT_NAME";
+    public static final Companion Companion = new Companion(null);
+    private final List<CredentialOption> credentialOptions;
+    private final String origin;
+    private final boolean preferIdentityDocUi;
+    private final boolean preferImmediatelyAvailableCredentials;
+    private final ComponentName preferUiBrandingComponentName;
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public GetCredentialRequest(List<? extends CredentialOption> credentialOptions) {
+        this(credentialOptions, null, false, null, false, 30, null);
+        Intrinsics.checkNotNullParameter(credentialOptions, "credentialOptions");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public GetCredentialRequest(List<? extends CredentialOption> credentialOptions, String str) {
+        this(credentialOptions, str, false, null, false, 28, null);
+        Intrinsics.checkNotNullParameter(credentialOptions, "credentialOptions");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public GetCredentialRequest(List<? extends CredentialOption> credentialOptions, String str, boolean z) {
+        this(credentialOptions, str, z, null, false, 24, null);
+        Intrinsics.checkNotNullParameter(credentialOptions, "credentialOptions");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public GetCredentialRequest(List<? extends CredentialOption> credentialOptions, String str, boolean z, ComponentName componentName) {
+        this(credentialOptions, str, z, componentName, false, 16, null);
+        Intrinsics.checkNotNullParameter(credentialOptions, "credentialOptions");
+    }
+
+    @RequiresApi(34)
+    public static final GetCredentialRequest createFrom(android.credentials.GetCredentialRequest getCredentialRequest) {
+        return Companion.createFrom(getCredentialRequest);
+    }
+
+    public static final GetCredentialRequest createFrom(List<? extends CredentialOption> list, String str, Bundle bundle) {
+        return Companion.createFrom(list, str, bundle);
+    }
+
+    public static final Bundle getRequestMetadataBundle(GetCredentialRequest getCredentialRequest) {
+        return Companion.getRequestMetadataBundle(getCredentialRequest);
+    }
+
+    public final List<CredentialOption> getCredentialOptions() {
+        return this.credentialOptions;
+    }
+
+    public final String getOrigin() {
+        return this.origin;
+    }
+
+    public final boolean getPreferIdentityDocUi() {
+        return this.preferIdentityDocUi;
+    }
+
+    public final ComponentName getPreferUiBrandingComponentName() {
+        return this.preferUiBrandingComponentName;
+    }
+
+    public final boolean preferImmediatelyAvailableCredentials() {
+        return this.preferImmediatelyAvailableCredentials;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public GetCredentialRequest(List<? extends CredentialOption> credentialOptions, String str, boolean z, ComponentName componentName, boolean z2) {
+        Intrinsics.checkNotNullParameter(credentialOptions, "credentialOptions");
+        this.credentialOptions = credentialOptions;
+        this.origin = str;
+        this.preferIdentityDocUi = z;
+        this.preferUiBrandingComponentName = componentName;
+        this.preferImmediatelyAvailableCredentials = z2;
+        if (!(!credentialOptions.isEmpty())) {
+            throw new IllegalArgumentException("credentialOptions should not be empty".toString());
+        }
+        if (credentialOptions.size() > 1) {
+            List<? extends CredentialOption> list = credentialOptions;
+            int i = 0;
+            if (!(list instanceof Collection) || !list.isEmpty()) {
+                Iterator it = list.iterator();
+                while (it.hasNext()) {
+                    if ((((CredentialOption) it.next()) instanceof GetDigitalCredentialOption) && (i = i + 1) < 0) {
+                        CollectionsKt__CollectionsKt.throwCountOverflow();
+                    }
+                }
+            }
+            if (i > 0 && i != this.credentialOptions.size()) {
+                throw new IllegalArgumentException("Digital Credential Option cannot be used with other credential option.");
+            }
+            Iterator<CredentialOption> it2 = this.credentialOptions.iterator();
+            while (it2.hasNext()) {
+                if (it2.next() instanceof GetRestoreCredentialOption) {
+                    throw new IllegalArgumentException("Only a single GetRestoreCredentialOption should be provided.");
+                }
+            }
+        }
+    }
+
+    public /* synthetic */ GetCredentialRequest(List list, String str, boolean z, ComponentName componentName, boolean z2, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(list, (i & 2) != 0 ? null : str, (i & 4) != 0 ? false : z, (i & 8) != 0 ? null : componentName, (i & 16) != 0 ? false : z2);
+    }
+
+    public static final class Builder {
+        private List<CredentialOption> credentialOptions = new ArrayList();
+        private String origin;
+        private boolean preferIdentityDocUi;
+        private boolean preferImmediatelyAvailableCredentials;
+        private ComponentName preferUiBrandingComponentName;
+
+        public final Builder setOrigin(String origin) {
+            Intrinsics.checkNotNullParameter(origin, "origin");
+            this.origin = origin;
+            return this;
+        }
+
+        public final Builder setPreferIdentityDocUi(boolean z) {
+            this.preferIdentityDocUi = z;
+            return this;
+        }
+
+        public final Builder setPreferImmediatelyAvailableCredentials(boolean z) {
+            this.preferImmediatelyAvailableCredentials = z;
+            return this;
+        }
+
+        public final Builder setPreferUiBrandingComponentName(ComponentName componentName) {
+            this.preferUiBrandingComponentName = componentName;
+            return this;
+        }
+
+        public final Builder addCredentialOption(CredentialOption credentialOption) {
+            Intrinsics.checkNotNullParameter(credentialOption, "credentialOption");
+            this.credentialOptions.add(credentialOption);
+            return this;
+        }
+
+        public final Builder setCredentialOptions(List<? extends CredentialOption> credentialOptions) {
+            Intrinsics.checkNotNullParameter(credentialOptions, "credentialOptions");
+            this.credentialOptions = CollectionsKt___CollectionsKt.toMutableList((Collection) credentialOptions);
+            return this;
+        }
+
+        public final GetCredentialRequest build() {
+            return new GetCredentialRequest(CollectionsKt___CollectionsKt.toList(this.credentialOptions), this.origin, this.preferIdentityDocUi, this.preferUiBrandingComponentName, this.preferImmediatelyAvailableCredentials);
+        }
+    }
+
+    @SourceDebugExtension({"SMAP\nGetCredentialRequest.kt\nKotlin\n*S Kotlin\n*F\n+ 1 GetCredentialRequest.kt\nandroidx/credentials/GetCredentialRequest$Companion\n+ 2 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n*L\n1#1,276:1\n1549#2:277\n1620#2,3:278\n*S KotlinDebug\n*F\n+ 1 GetCredentialRequest.kt\nandroidx/credentials/GetCredentialRequest$Companion\n*L\n226#1:277\n226#1:278,3\n*E\n"})
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final Bundle getRequestMetadataBundle(GetCredentialRequest request) {
+            Intrinsics.checkNotNullParameter(request, "request");
+            Bundle bundle = new Bundle();
+            bundle.putBoolean(GetCredentialRequest.BUNDLE_KEY_PREFER_IDENTITY_DOC_UI, request.getPreferIdentityDocUi());
+            bundle.putBoolean("androidx.credentials.BUNDLE_KEY_PREFER_IMMEDIATELY_AVAILABLE_CREDENTIALS", request.preferImmediatelyAvailableCredentials());
+            bundle.putParcelable(GetCredentialRequest.BUNDLE_KEY_PREFER_UI_BRANDING_COMPONENT_NAME, request.getPreferUiBrandingComponentName());
+            return bundle;
+        }
+
+        @RequiresApi(34)
+        public final GetCredentialRequest createFrom(android.credentials.GetCredentialRequest request) {
+            List credentialOptions;
+            String origin;
+            Bundle data;
+            Intrinsics.checkNotNullParameter(request, "request");
+            credentialOptions = request.getCredentialOptions();
+            Intrinsics.checkNotNullExpressionValue(credentialOptions, "request.credentialOptions");
+            List list = credentialOptions;
+            ArrayList arrayList = new ArrayList(CollectionsKt__IterablesKt.collectionSizeOrDefault(list, 10));
+            Iterator it = list.iterator();
+            while (it.hasNext()) {
+                android.credentials.CredentialOption it2 = GetCredentialRequest$Companion$$ExternalSyntheticApiModelOutline1.m(it.next());
+                CredentialOption.Companion companion = CredentialOption.Companion;
+                Intrinsics.checkNotNullExpressionValue(it2, "it");
+                arrayList.add(companion.createFrom(it2));
+            }
+            origin = request.getOrigin();
+            data = request.getData();
+            Intrinsics.checkNotNullExpressionValue(data, "request.data");
+            return createFrom(arrayList, origin, data);
+        }
+
+        public final GetCredentialRequest createFrom(List<? extends CredentialOption> credentialOptions, String str, Bundle metadata) {
+            Intrinsics.checkNotNullParameter(credentialOptions, "credentialOptions");
+            Intrinsics.checkNotNullParameter(metadata, "metadata");
+            try {
+                boolean z = metadata.getBoolean(GetCredentialRequest.BUNDLE_KEY_PREFER_IDENTITY_DOC_UI);
+                Builder preferImmediatelyAvailableCredentials = new Builder().setCredentialOptions(credentialOptions).setPreferIdentityDocUi(z).setPreferUiBrandingComponentName((ComponentName) metadata.getParcelable(GetCredentialRequest.BUNDLE_KEY_PREFER_UI_BRANDING_COMPONENT_NAME)).setPreferImmediatelyAvailableCredentials(metadata.getBoolean("androidx.credentials.BUNDLE_KEY_PREFER_IMMEDIATELY_AVAILABLE_CREDENTIALS"));
+                if (str != null) {
+                    preferImmediatelyAvailableCredentials.setOrigin(str);
+                }
+                return preferImmediatelyAvailableCredentials.build();
+            } catch (Exception unused) {
+                throw new FrameworkClassParsingException();
+            }
+        }
+    }
+}

decompiled/sources/androidx/credentials/GetCredentialResponse.java

@@ -0,0 +1,62 @@
+package androidx.credentials;
+
+import android.os.Bundle;
+import androidx.annotation.RestrictTo;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class GetCredentialResponse {
+    public static final Companion Companion = new Companion(null);
+    private static final String EXTRA_CREDENTIAL_DATA = "androidx.credentials.provider.extra.EXTRA_CREDENTIAL_DATA";
+    private static final String EXTRA_CREDENTIAL_TYPE = "androidx.credentials.provider.extra.EXTRA_CREDENTIAL_TYPE";
+    private final Credential credential;
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static final Bundle asBundle(GetCredentialResponse getCredentialResponse) {
+        return Companion.asBundle(getCredentialResponse);
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static final GetCredentialResponse fromBundle(Bundle bundle) {
+        return Companion.fromBundle(bundle);
+    }
+
+    public final Credential getCredential() {
+        return this.credential;
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public final Bundle asBundle(GetCredentialResponse response) {
+            Intrinsics.checkNotNullParameter(response, "response");
+            Bundle bundle = new Bundle();
+            bundle.putString(GetCredentialResponse.EXTRA_CREDENTIAL_TYPE, response.getCredential().getType());
+            bundle.putBundle(GetCredentialResponse.EXTRA_CREDENTIAL_DATA, response.getCredential().getData());
+            return bundle;
+        }
+
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public final GetCredentialResponse fromBundle(Bundle bundle) {
+            Bundle bundle2;
+            Intrinsics.checkNotNullParameter(bundle, "bundle");
+            String string = bundle.getString(GetCredentialResponse.EXTRA_CREDENTIAL_TYPE);
+            if (string == null || (bundle2 = bundle.getBundle(GetCredentialResponse.EXTRA_CREDENTIAL_DATA)) == null) {
+                return null;
+            }
+            return new GetCredentialResponse(Credential.Companion.createFrom(string, bundle2));
+        }
+    }
+
+    public GetCredentialResponse(Credential credential) {
+        Intrinsics.checkNotNullParameter(credential, "credential");
+        this.credential = credential;
+    }
+}

decompiled/sources/androidx/credentials/GetCustomCredentialOption.java

@@ -0,0 +1,152 @@
+package androidx.credentials;
+
+import android.content.ComponentName;
+import android.os.Bundle;
+import java.util.Set;
+import kotlin.collections.SetsKt__SetsKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nGetCustomCredentialOption.kt\nKotlin\n*S Kotlin\n*F\n+ 1 GetCustomCredentialOption.kt\nandroidx/credentials/GetCustomCredentialOption\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,203:1\n1#2:204\n*E\n"})
+/* loaded from: classes.dex */
+public class GetCustomCredentialOption extends CredentialOption {
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public GetCustomCredentialOption(String type, Bundle requestData, Bundle candidateQueryData, boolean z) {
+        this(type, requestData, candidateQueryData, z, false, null, 48, null);
+        Intrinsics.checkNotNullParameter(type, "type");
+        Intrinsics.checkNotNullParameter(requestData, "requestData");
+        Intrinsics.checkNotNullParameter(candidateQueryData, "candidateQueryData");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public GetCustomCredentialOption(String type, Bundle requestData, Bundle candidateQueryData, boolean z, boolean z2) {
+        this(type, requestData, candidateQueryData, z, z2, null, 32, null);
+        Intrinsics.checkNotNullParameter(type, "type");
+        Intrinsics.checkNotNullParameter(requestData, "requestData");
+        Intrinsics.checkNotNullParameter(candidateQueryData, "candidateQueryData");
+    }
+
+    /* 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 /* synthetic */ GetCustomCredentialOption(android.os.Bundle r10, java.lang.String r11, android.os.Bundle r12, boolean r13, boolean r14, java.util.Set r15, int r16, int r17, kotlin.jvm.internal.DefaultConstructorMarker r18) {
+        /*
+            r9 = this;
+            r0 = r17 & 16
+            if (r0 == 0) goto L7
+            r0 = 0
+            r6 = r0
+            goto L8
+        L7:
+            r6 = r14
+        L8:
+            r0 = r17 & 32
+            if (r0 == 0) goto L12
+            java.util.Set r0 = kotlin.collections.SetsKt.emptySet()
+            r7 = r0
+            goto L13
+        L12:
+            r7 = r15
+        L13:
+            r0 = r17 & 64
+            if (r0 == 0) goto L1b
+            r0 = 2000(0x7d0, float:2.803E-42)
+            r8 = r0
+            goto L1d
+        L1b:
+            r8 = r16
+        L1d:
+            r1 = r9
+            r2 = r10
+            r3 = r11
+            r4 = r12
+            r5 = r13
+            r1.<init>(r2, r3, r4, r5, r6, r7, r8)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.credentials.GetCustomCredentialOption.<init>(android.os.Bundle, java.lang.String, android.os.Bundle, boolean, boolean, java.util.Set, int, int, kotlin.jvm.internal.DefaultConstructorMarker):void");
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public GetCustomCredentialOption(Bundle requestData, String type, Bundle candidateQueryData, boolean z, boolean z2, Set<ComponentName> allowedProviders, int i) {
+        super(type, requestData, candidateQueryData, z, z2, allowedProviders, i);
+        Intrinsics.checkNotNullParameter(requestData, "requestData");
+        Intrinsics.checkNotNullParameter(type, "type");
+        Intrinsics.checkNotNullParameter(candidateQueryData, "candidateQueryData");
+        Intrinsics.checkNotNullParameter(allowedProviders, "allowedProviders");
+        if (type.length() <= 0) {
+            throw new IllegalArgumentException("type should not be empty".toString());
+        }
+        if (i == 100) {
+            throw new IllegalArgumentException("Custom types should not have passkey level priority.".toString());
+        }
+    }
+
+    public /* synthetic */ GetCustomCredentialOption(String str, Bundle bundle, Bundle bundle2, boolean z, boolean z2, Set set, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, bundle, bundle2, z, (i & 16) != 0 ? false : z2, (i & 32) != 0 ? SetsKt__SetsKt.emptySet() : set);
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public GetCustomCredentialOption(String type, Bundle requestData, Bundle candidateQueryData, boolean z, boolean z2, Set<ComponentName> allowedProviders) {
+        this(requestData, type, candidateQueryData, z, z2, allowedProviders, 0, 64, (DefaultConstructorMarker) null);
+        Intrinsics.checkNotNullParameter(type, "type");
+        Intrinsics.checkNotNullParameter(requestData, "requestData");
+        Intrinsics.checkNotNullParameter(candidateQueryData, "candidateQueryData");
+        Intrinsics.checkNotNullParameter(allowedProviders, "allowedProviders");
+    }
+
+    /* 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 /* synthetic */ GetCustomCredentialOption(java.lang.String r10, android.os.Bundle r11, android.os.Bundle r12, boolean r13, boolean r14, java.util.Set r15, int r16, int r17, kotlin.jvm.internal.DefaultConstructorMarker r18) {
+        /*
+            r9 = this;
+            r0 = r17 & 16
+            if (r0 == 0) goto L7
+            r0 = 0
+            r6 = r0
+            goto L8
+        L7:
+            r6 = r14
+        L8:
+            r0 = r17 & 32
+            if (r0 == 0) goto L12
+            java.util.Set r0 = kotlin.collections.SetsKt.emptySet()
+            r7 = r0
+            goto L13
+        L12:
+            r7 = r15
+        L13:
+            r0 = r17 & 64
+            if (r0 == 0) goto L1b
+            r0 = 2000(0x7d0, float:2.803E-42)
+            r8 = r0
+            goto L1d
+        L1b:
+            r8 = r16
+        L1d:
+            r1 = r9
+            r2 = r10
+            r3 = r11
+            r4 = r12
+            r5 = r13
+            r1.<init>(r2, r3, r4, r5, r6, r7, r8)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.credentials.GetCustomCredentialOption.<init>(java.lang.String, android.os.Bundle, android.os.Bundle, boolean, boolean, java.util.Set, int, int, kotlin.jvm.internal.DefaultConstructorMarker):void");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public GetCustomCredentialOption(String type, Bundle requestData, Bundle candidateQueryData, boolean z, boolean z2, Set<ComponentName> allowedProviders, int i) {
+        this(requestData, type, candidateQueryData, z, z2, allowedProviders, i);
+        Intrinsics.checkNotNullParameter(type, "type");
+        Intrinsics.checkNotNullParameter(requestData, "requestData");
+        Intrinsics.checkNotNullParameter(candidateQueryData, "candidateQueryData");
+        Intrinsics.checkNotNullParameter(allowedProviders, "allowedProviders");
+    }
+}

decompiled/sources/androidx/credentials/GetDigitalCredentialOption.java

@@ -0,0 +1,88 @@
+package androidx.credentials;
+
+import android.content.ComponentName;
+import android.os.Bundle;
+import androidx.credentials.internal.FrameworkClassParsingException;
+import androidx.credentials.internal.RequestValidationHelper;
+import java.util.Set;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+@ExperimentalDigitalCredentialApi
+/* loaded from: classes.dex */
+public final class GetDigitalCredentialOption extends CredentialOption {
+    public static final String BUNDLE_KEY_REQUEST_JSON = "androidx.credentials.BUNDLE_KEY_REQUEST_JSON";
+    public static final Companion Companion = new Companion(null);
+    private final String requestJson;
+
+    public final String getRequestJson() {
+        return this.requestJson;
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public GetDigitalCredentialOption(String requestJson, Bundle requestData, Bundle candidateQueryData, boolean z, boolean z2, Set<ComponentName> allowedProviders, int i) {
+        super(DigitalCredential.TYPE_DIGITAL_CREDENTIAL, requestData, candidateQueryData, z, z2, allowedProviders, i);
+        Intrinsics.checkNotNullParameter(requestJson, "requestJson");
+        Intrinsics.checkNotNullParameter(requestData, "requestData");
+        Intrinsics.checkNotNullParameter(candidateQueryData, "candidateQueryData");
+        Intrinsics.checkNotNullParameter(allowedProviders, "allowedProviders");
+        this.requestJson = requestJson;
+        if (!RequestValidationHelper.Companion.isValidJSON(requestJson)) {
+            throw new IllegalArgumentException("credentialJson must not be empty, and must be a valid JSON".toString());
+        }
+    }
+
+    /* 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 GetDigitalCredentialOption(java.lang.String r10) {
+        /*
+            r9 = this;
+            java.lang.String r0 = "requestJson"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r10, r0)
+            androidx.credentials.GetDigitalCredentialOption$Companion r0 = androidx.credentials.GetDigitalCredentialOption.Companion
+            android.os.Bundle r3 = r0.toBundle$credentials_release(r10)
+            android.os.Bundle r4 = r0.toBundle$credentials_release(r10)
+            r5 = 0
+            r6 = 0
+            java.util.Set r7 = kotlin.collections.SetsKt.emptySet()
+            r8 = 100
+            r1 = r9
+            r2 = r10
+            r1.<init>(r2, r3, r4, r5, r6, r7, r8)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.credentials.GetDigitalCredentialOption.<init>(java.lang.String):void");
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final Bundle toBundle$credentials_release(String requestJson) {
+            Intrinsics.checkNotNullParameter(requestJson, "requestJson");
+            Bundle bundle = new Bundle();
+            bundle.putString("androidx.credentials.BUNDLE_KEY_REQUEST_JSON", requestJson);
+            return bundle;
+        }
+
+        public final GetDigitalCredentialOption createFrom$credentials_release(Bundle requestData, Bundle candidateQueryData, boolean z, Set<ComponentName> allowedProviders) {
+            Intrinsics.checkNotNullParameter(requestData, "requestData");
+            Intrinsics.checkNotNullParameter(candidateQueryData, "candidateQueryData");
+            Intrinsics.checkNotNullParameter(allowedProviders, "allowedProviders");
+            try {
+                String string = requestData.getString("androidx.credentials.BUNDLE_KEY_REQUEST_JSON");
+                Intrinsics.checkNotNull(string);
+                return new GetDigitalCredentialOption(string, requestData, candidateQueryData, z, requestData.getBoolean("androidx.credentials.BUNDLE_KEY_IS_AUTO_SELECT_ALLOWED", false), allowedProviders, requestData.getInt(CredentialOption.BUNDLE_KEY_TYPE_PRIORITY_VALUE, 100));
+            } catch (Exception unused) {
+                throw new FrameworkClassParsingException();
+            }
+        }
+    }
+}

decompiled/sources/androidx/credentials/GetPasswordOption.java

@@ -0,0 +1,145 @@
+package androidx.credentials;
+
+import android.content.ComponentName;
+import android.os.Bundle;
+import java.util.ArrayList;
+import java.util.Set;
+import kotlin.collections.SetsKt__SetsKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class GetPasswordOption extends CredentialOption {
+    public static final String BUNDLE_KEY_ALLOWED_USER_IDS = "androidx.credentials.BUNDLE_KEY_ALLOWED_USER_IDS";
+    public static final Companion Companion = new Companion(null);
+    private final Set<String> allowedUserIds;
+
+    public GetPasswordOption() {
+        this(null, false, null, 7, null);
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public GetPasswordOption(Set<String> allowedUserIds) {
+        this(allowedUserIds, false, null, 6, null);
+        Intrinsics.checkNotNullParameter(allowedUserIds, "allowedUserIds");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public GetPasswordOption(Set<String> allowedUserIds, boolean z) {
+        this(allowedUserIds, z, null, 4, null);
+        Intrinsics.checkNotNullParameter(allowedUserIds, "allowedUserIds");
+    }
+
+    public /* synthetic */ GetPasswordOption(Set set, boolean z, Set set2, Bundle bundle, Bundle bundle2, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(set, z, set2, bundle, bundle2, i);
+    }
+
+    public final Set<String> getAllowedUserIds() {
+        return this.allowedUserIds;
+    }
+
+    public /* synthetic */ GetPasswordOption(Set set, boolean z, Set set2, Bundle bundle, Bundle bundle2, int i, int i2, DefaultConstructorMarker defaultConstructorMarker) {
+        this(set, z, set2, bundle, bundle2, (i2 & 32) != 0 ? 1000 : i);
+    }
+
+    private GetPasswordOption(Set<String> set, boolean z, Set<ComponentName> set2, Bundle bundle, Bundle bundle2, int i) {
+        super(PasswordCredential.TYPE_PASSWORD_CREDENTIAL, bundle, bundle2, false, z, set2, i);
+        this.allowedUserIds = set;
+    }
+
+    public /* synthetic */ GetPasswordOption(Set set, boolean z, Set set2, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this((i & 1) != 0 ? SetsKt__SetsKt.emptySet() : set, (i & 2) != 0 ? false : z, (i & 4) != 0 ? SetsKt__SetsKt.emptySet() : set2);
+    }
+
+    /* 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 GetPasswordOption(java.util.Set<java.lang.String> r11, boolean r12, java.util.Set<android.content.ComponentName> r13) {
+        /*
+            r10 = this;
+            java.lang.String r0 = "allowedUserIds"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r11, r0)
+            java.lang.String r0 = "allowedProviders"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r13, r0)
+            androidx.credentials.GetPasswordOption$Companion r0 = androidx.credentials.GetPasswordOption.Companion
+            android.os.Bundle r5 = r0.toBundle$credentials_release(r11)
+            android.os.Bundle r6 = r0.toBundle$credentials_release(r11)
+            r7 = 0
+            r8 = 32
+            r9 = 0
+            r1 = r10
+            r2 = r11
+            r3 = r12
+            r4 = r13
+            r1.<init>(r2, r3, r4, r5, r6, r7, r8, r9)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.credentials.GetPasswordOption.<init>(java.util.Set, boolean, java.util.Set):void");
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        /* JADX WARN: Code restructure failed: missing block: B:3:0x0019, code lost:
+        
+            r0 = kotlin.collections.CollectionsKt___CollectionsKt.toSet(r0);
+         */
+        /*
+            Code decompiled incorrectly, please refer to instructions dump.
+            To view partially-correct add '--show-bad-code' argument
+        */
+        public final androidx.credentials.GetPasswordOption createFrom$credentials_release(android.os.Bundle r11, java.util.Set<android.content.ComponentName> r12, android.os.Bundle r13) {
+            /*
+                r10 = this;
+                java.lang.String r0 = "data"
+                kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r11, r0)
+                java.lang.String r0 = "allowedProviders"
+                kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r12, r0)
+                java.lang.String r0 = "candidateQueryData"
+                kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r13, r0)
+                java.lang.String r0 = "androidx.credentials.BUNDLE_KEY_ALLOWED_USER_IDS"
+                java.util.ArrayList r0 = r11.getStringArrayList(r0)
+                androidx.credentials.GetPasswordOption r9 = new androidx.credentials.GetPasswordOption
+                if (r0 == 0) goto L22
+                java.util.Set r0 = kotlin.collections.CollectionsKt.toSet(r0)
+                if (r0 != 0) goto L20
+                goto L22
+            L20:
+                r2 = r0
+                goto L27
+            L22:
+                java.util.Set r0 = kotlin.collections.SetsKt.emptySet()
+                goto L20
+            L27:
+                java.lang.String r0 = "androidx.credentials.BUNDLE_KEY_IS_AUTO_SELECT_ALLOWED"
+                r1 = 0
+                boolean r3 = r11.getBoolean(r0, r1)
+                java.lang.String r0 = "androidx.credentials.BUNDLE_KEY_TYPE_PRIORITY_VALUE"
+                r1 = 1000(0x3e8, float:1.401E-42)
+                int r7 = r11.getInt(r0, r1)
+                r8 = 0
+                r1 = r9
+                r4 = r12
+                r5 = r11
+                r6 = r13
+                r1.<init>(r2, r3, r4, r5, r6, r7, r8)
+                return r9
+            */
+            throw new UnsupportedOperationException("Method not decompiled: androidx.credentials.GetPasswordOption.Companion.createFrom$credentials_release(android.os.Bundle, java.util.Set, android.os.Bundle):androidx.credentials.GetPasswordOption");
+        }
+
+        public final Bundle toBundle$credentials_release(Set<String> allowUserIds) {
+            Intrinsics.checkNotNullParameter(allowUserIds, "allowUserIds");
+            Bundle bundle = new Bundle();
+            bundle.putStringArrayList(GetPasswordOption.BUNDLE_KEY_ALLOWED_USER_IDS, new ArrayList<>(allowUserIds));
+            return bundle;
+        }
+    }
+}

decompiled/sources/androidx/credentials/GetPublicKeyCredentialOption.java

@@ -0,0 +1,121 @@
+package androidx.credentials;
+
+import android.content.ComponentName;
+import android.os.Bundle;
+import androidx.credentials.internal.FrameworkClassParsingException;
+import androidx.credentials.internal.RequestValidationHelper;
+import java.util.Set;
+import kotlin.collections.SetsKt__SetsKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class GetPublicKeyCredentialOption extends CredentialOption {
+    public static final String BUNDLE_KEY_CLIENT_DATA_HASH = "androidx.credentials.BUNDLE_KEY_CLIENT_DATA_HASH";
+    public static final String BUNDLE_KEY_REQUEST_JSON = "androidx.credentials.BUNDLE_KEY_REQUEST_JSON";
+    public static final String BUNDLE_VALUE_SUBTYPE_GET_PUBLIC_KEY_CREDENTIAL_OPTION = "androidx.credentials.BUNDLE_VALUE_SUBTYPE_GET_PUBLIC_KEY_CREDENTIAL_OPTION";
+    public static final Companion Companion = new Companion(null);
+    private final byte[] clientDataHash;
+    private final String requestJson;
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public GetPublicKeyCredentialOption(String requestJson) {
+        this(requestJson, null, null, 6, null);
+        Intrinsics.checkNotNullParameter(requestJson, "requestJson");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public GetPublicKeyCredentialOption(String requestJson, byte[] bArr) {
+        this(requestJson, bArr, null, 4, null);
+        Intrinsics.checkNotNullParameter(requestJson, "requestJson");
+    }
+
+    public /* synthetic */ GetPublicKeyCredentialOption(String str, byte[] bArr, Set set, Bundle bundle, Bundle bundle2, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, bArr, set, bundle, bundle2, i);
+    }
+
+    public final byte[] getClientDataHash() {
+        return this.clientDataHash;
+    }
+
+    public final String getRequestJson() {
+        return this.requestJson;
+    }
+
+    public /* synthetic */ GetPublicKeyCredentialOption(String str, byte[] bArr, Set set, Bundle bundle, Bundle bundle2, int i, int i2, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, bArr, set, bundle, bundle2, (i2 & 32) != 0 ? 100 : i);
+    }
+
+    private GetPublicKeyCredentialOption(String str, byte[] bArr, Set<ComponentName> set, Bundle bundle, Bundle bundle2, int i) {
+        super(PublicKeyCredential.TYPE_PUBLIC_KEY_CREDENTIAL, bundle, bundle2, false, true, set, i);
+        this.requestJson = str;
+        this.clientDataHash = bArr;
+        if (!RequestValidationHelper.Companion.isValidJSON(str)) {
+            throw new IllegalArgumentException("requestJson must not be empty, and must be a valid JSON".toString());
+        }
+    }
+
+    public /* synthetic */ GetPublicKeyCredentialOption(String str, byte[] bArr, Set set, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, (i & 2) != 0 ? null : bArr, (i & 4) != 0 ? SetsKt__SetsKt.emptySet() : set);
+    }
+
+    /* 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 GetPublicKeyCredentialOption(java.lang.String r11, byte[] r12, java.util.Set<android.content.ComponentName> r13) {
+        /*
+            r10 = this;
+            java.lang.String r0 = "requestJson"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r11, r0)
+            java.lang.String r0 = "allowedProviders"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r13, r0)
+            androidx.credentials.GetPublicKeyCredentialOption$Companion r0 = androidx.credentials.GetPublicKeyCredentialOption.Companion
+            android.os.Bundle r5 = r0.toRequestDataBundle$credentials_release(r11, r12)
+            android.os.Bundle r6 = r0.toRequestDataBundle$credentials_release(r11, r12)
+            r7 = 0
+            r8 = 32
+            r9 = 0
+            r1 = r10
+            r2 = r11
+            r3 = r12
+            r4 = r13
+            r1.<init>(r2, r3, r4, r5, r6, r7, r8, r9)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.credentials.GetPublicKeyCredentialOption.<init>(java.lang.String, byte[], java.util.Set):void");
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final Bundle toRequestDataBundle$credentials_release(String requestJson, byte[] bArr) {
+            Intrinsics.checkNotNullParameter(requestJson, "requestJson");
+            Bundle bundle = new Bundle();
+            bundle.putString(PublicKeyCredential.BUNDLE_KEY_SUBTYPE, GetPublicKeyCredentialOption.BUNDLE_VALUE_SUBTYPE_GET_PUBLIC_KEY_CREDENTIAL_OPTION);
+            bundle.putString("androidx.credentials.BUNDLE_KEY_REQUEST_JSON", requestJson);
+            bundle.putByteArray("androidx.credentials.BUNDLE_KEY_CLIENT_DATA_HASH", bArr);
+            return bundle;
+        }
+
+        public final GetPublicKeyCredentialOption createFrom$credentials_release(Bundle data, Set<ComponentName> allowedProviders, Bundle candidateQueryData) {
+            Intrinsics.checkNotNullParameter(data, "data");
+            Intrinsics.checkNotNullParameter(allowedProviders, "allowedProviders");
+            Intrinsics.checkNotNullParameter(candidateQueryData, "candidateQueryData");
+            try {
+                String string = data.getString("androidx.credentials.BUNDLE_KEY_REQUEST_JSON");
+                byte[] byteArray = data.getByteArray("androidx.credentials.BUNDLE_KEY_CLIENT_DATA_HASH");
+                Intrinsics.checkNotNull(string);
+                return new GetPublicKeyCredentialOption(string, byteArray, allowedProviders, data, candidateQueryData, data.getInt(CredentialOption.BUNDLE_KEY_TYPE_PRIORITY_VALUE, 100), null);
+            } catch (Exception unused) {
+                throw new FrameworkClassParsingException();
+            }
+        }
+    }
+}

decompiled/sources/androidx/credentials/GetRestoreCredentialOption.java

@@ -0,0 +1,67 @@
+package androidx.credentials;
+
+import android.os.Bundle;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+
+/* loaded from: classes.dex */
+public final class GetRestoreCredentialOption extends CredentialOption {
+    private static final String BUNDLE_KEY_GET_RESTORE_CREDENTIAL_REQUEST = "androidx.credentials.BUNDLE_KEY_GET_RESTORE_CREDENTIAL_REQUEST";
+    private static final Companion Companion = new Companion(null);
+    private final String requestJson;
+
+    public final String getRequestJson() {
+        return this.requestJson;
+    }
+
+    /* 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 GetRestoreCredentialOption(java.lang.String r10) {
+        /*
+            r9 = this;
+            java.lang.String r0 = "requestJson"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r10, r0)
+            java.lang.String r2 = "androidx.credentials.TYPE_RESTORE_CREDENTIAL"
+            androidx.credentials.GetRestoreCredentialOption$Companion r0 = androidx.credentials.GetRestoreCredentialOption.Companion
+            android.os.Bundle r3 = androidx.credentials.GetRestoreCredentialOption.Companion.access$toRequestDataBundle(r0, r10)
+            android.os.Bundle r4 = new android.os.Bundle
+            r4.<init>()
+            r5 = 0
+            r6 = 0
+            java.util.Set r7 = kotlin.collections.SetsKt.emptySet()
+            r8 = 2000(0x7d0, float:2.803E-42)
+            r1 = r9
+            r1.<init>(r2, r3, r4, r5, r6, r7, r8)
+            r9.requestJson = r10
+            androidx.credentials.internal.RequestValidationHelper$Companion r0 = androidx.credentials.internal.RequestValidationHelper.Companion
+            boolean r10 = r0.isValidJSON(r10)
+            if (r10 == 0) goto L29
+            return
+        L29:
+            java.lang.IllegalArgumentException r10 = new java.lang.IllegalArgumentException
+            java.lang.String r0 = "requestJson must not be empty, and must be a valid JSON"
+            java.lang.String r0 = r0.toString()
+            r10.<init>(r0)
+            throw r10
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.credentials.GetRestoreCredentialOption.<init>(java.lang.String):void");
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public final Bundle toRequestDataBundle(String str) {
+            Bundle bundle = new Bundle();
+            bundle.putString(GetRestoreCredentialOption.BUNDLE_KEY_GET_RESTORE_CREDENTIAL_REQUEST, str);
+            return bundle;
+        }
+    }
+}

decompiled/sources/androidx/credentials/PasswordCredential.java

@@ -0,0 +1,77 @@
+package androidx.credentials;
+
+import android.os.Bundle;
+import androidx.credentials.internal.FrameworkClassParsingException;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nPasswordCredential.kt\nKotlin\n*S Kotlin\n*F\n+ 1 PasswordCredential.kt\nandroidx/credentials/PasswordCredential\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,78:1\n1#2:79\n*E\n"})
+/* loaded from: classes.dex */
+public final class PasswordCredential extends Credential {
+    public static final String BUNDLE_KEY_ID = "androidx.credentials.BUNDLE_KEY_ID";
+    public static final String BUNDLE_KEY_PASSWORD = "androidx.credentials.BUNDLE_KEY_PASSWORD";
+    public static final Companion Companion = new Companion(null);
+    public static final String TYPE_PASSWORD_CREDENTIAL = "android.credentials.TYPE_PASSWORD_CREDENTIAL";
+    private final String id;
+    private final String password;
+
+    public /* synthetic */ PasswordCredential(String str, String str2, Bundle bundle, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, str2, bundle);
+    }
+
+    public final String getId() {
+        return this.id;
+    }
+
+    public final String getPassword() {
+        return this.password;
+    }
+
+    private PasswordCredential(String str, String str2, Bundle bundle) {
+        super(TYPE_PASSWORD_CREDENTIAL, bundle);
+        this.id = str;
+        this.password = str2;
+        if (str2.length() <= 0) {
+            throw new IllegalArgumentException("password should not be empty".toString());
+        }
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public PasswordCredential(String id, String password) {
+        this(id, password, Companion.toBundle$credentials_release(id, password));
+        Intrinsics.checkNotNullParameter(id, "id");
+        Intrinsics.checkNotNullParameter(password, "password");
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final Bundle toBundle$credentials_release(String id, String password) {
+            Intrinsics.checkNotNullParameter(id, "id");
+            Intrinsics.checkNotNullParameter(password, "password");
+            Bundle bundle = new Bundle();
+            bundle.putString("androidx.credentials.BUNDLE_KEY_ID", id);
+            bundle.putString("androidx.credentials.BUNDLE_KEY_PASSWORD", password);
+            return bundle;
+        }
+
+        public final PasswordCredential createFrom$credentials_release(Bundle data) {
+            Intrinsics.checkNotNullParameter(data, "data");
+            try {
+                String string = data.getString("androidx.credentials.BUNDLE_KEY_ID");
+                String string2 = data.getString("androidx.credentials.BUNDLE_KEY_PASSWORD");
+                Intrinsics.checkNotNull(string);
+                Intrinsics.checkNotNull(string2);
+                return new PasswordCredential(string, string2, data, null);
+            } catch (Exception unused) {
+                throw new FrameworkClassParsingException();
+            }
+        }
+    }
+}

decompiled/sources/androidx/credentials/PendingGetCredentialRequest.java

@@ -0,0 +1,25 @@
+package androidx.credentials;
+
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class PendingGetCredentialRequest {
+    private final Function1 callback;
+    private final GetCredentialRequest request;
+
+    public final Function1 getCallback() {
+        return this.callback;
+    }
+
+    public final GetCredentialRequest getRequest() {
+        return this.request;
+    }
+
+    public PendingGetCredentialRequest(GetCredentialRequest request, Function1 callback) {
+        Intrinsics.checkNotNullParameter(request, "request");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        this.request = request;
+        this.callback = callback;
+    }
+}

decompiled/sources/androidx/credentials/PrepareGetCredentialResponse$Builder$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class PrepareGetCredentialResponse$Builder$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/credentials/PrepareGetCredentialResponse$Builder$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class PrepareGetCredentialResponse$Builder$$ExternalSyntheticApiModelOutline1 {
+}

decompiled/sources/androidx/credentials/PrepareGetCredentialResponse$Builder$$ExternalSyntheticApiModelOutline2.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class PrepareGetCredentialResponse$Builder$$ExternalSyntheticApiModelOutline2 {
+}

decompiled/sources/androidx/credentials/PrepareGetCredentialResponse$Builder$setFrameworkResponse$1.java

@@ -0,0 +1,21 @@
+package androidx.credentials;
+
+import androidx.credentials.PrepareGetCredentialResponse;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.FunctionReferenceImpl;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public /* synthetic */ class PrepareGetCredentialResponse$Builder$setFrameworkResponse$1 extends FunctionReferenceImpl implements Function1 {
+    public PrepareGetCredentialResponse$Builder$setFrameworkResponse$1(Object obj) {
+        super(1, obj, PrepareGetCredentialResponse.Builder.class, "hasCredentialType", "hasCredentialType(Ljava/lang/String;)Z", 0);
+    }
+
+    @Override // kotlin.jvm.functions.Function1
+    public final Boolean invoke(String p0) {
+        boolean hasCredentialType;
+        Intrinsics.checkNotNullParameter(p0, "p0");
+        hasCredentialType = ((PrepareGetCredentialResponse.Builder) this.receiver).hasCredentialType(p0);
+        return Boolean.valueOf(hasCredentialType);
+    }
+}

decompiled/sources/androidx/credentials/PrepareGetCredentialResponse$Builder$setFrameworkResponse$2.java

@@ -0,0 +1,19 @@
+package androidx.credentials;
+
+import androidx.credentials.PrepareGetCredentialResponse;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.FunctionReferenceImpl;
+
+/* loaded from: classes.dex */
+public /* synthetic */ class PrepareGetCredentialResponse$Builder$setFrameworkResponse$2 extends FunctionReferenceImpl implements Function0 {
+    public PrepareGetCredentialResponse$Builder$setFrameworkResponse$2(Object obj) {
+        super(0, obj, PrepareGetCredentialResponse.Builder.class, "hasAuthenticationResults", "hasAuthenticationResults()Z", 0);
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public final Boolean invoke() {
+        boolean hasAuthenticationResults;
+        hasAuthenticationResults = ((PrepareGetCredentialResponse.Builder) this.receiver).hasAuthenticationResults();
+        return Boolean.valueOf(hasAuthenticationResults);
+    }
+}

decompiled/sources/androidx/credentials/PrepareGetCredentialResponse$Builder$setFrameworkResponse$3.java

@@ -0,0 +1,19 @@
+package androidx.credentials;
+
+import androidx.credentials.PrepareGetCredentialResponse;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.FunctionReferenceImpl;
+
+/* loaded from: classes.dex */
+public /* synthetic */ class PrepareGetCredentialResponse$Builder$setFrameworkResponse$3 extends FunctionReferenceImpl implements Function0 {
+    public PrepareGetCredentialResponse$Builder$setFrameworkResponse$3(Object obj) {
+        super(0, obj, PrepareGetCredentialResponse.Builder.class, "hasRemoteResults", "hasRemoteResults()Z", 0);
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public final Boolean invoke() {
+        boolean hasRemoteResults;
+        hasRemoteResults = ((PrepareGetCredentialResponse.Builder) this.receiver).hasRemoteResults();
+        return Boolean.valueOf(hasRemoteResults);
+    }
+}

decompiled/sources/androidx/credentials/PrepareGetCredentialResponse.java

@@ -0,0 +1,196 @@
+package androidx.credentials;
+
+import android.annotation.SuppressLint;
+import android.credentials.PrepareGetCredentialResponse;
+import android.os.Build;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RequiresPermission;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+@RequiresApi(34)
+@SuppressLint({"MissingGetterMatchingBuilder"})
+/* loaded from: classes.dex */
+public final class PrepareGetCredentialResponse {
+    private final Function1 credentialTypeDelegate;
+    private final Function0 hasAuthResultsDelegate;
+    private final Function0 hasRemoteResultsDelegate;
+    private final boolean isNullHandlesForTest;
+    private final PendingGetCredentialHandle pendingGetCredentialHandle;
+
+    public /* synthetic */ PrepareGetCredentialResponse(PendingGetCredentialHandle pendingGetCredentialHandle, Function0 function0, Function0 function02, Function1 function1, boolean z, DefaultConstructorMarker defaultConstructorMarker) {
+        this(pendingGetCredentialHandle, function0, function02, function1, z);
+    }
+
+    public final Function1 getCredentialTypeDelegate() {
+        return this.credentialTypeDelegate;
+    }
+
+    public final Function0 getHasAuthResultsDelegate() {
+        return this.hasAuthResultsDelegate;
+    }
+
+    public final Function0 getHasRemoteResultsDelegate() {
+        return this.hasRemoteResultsDelegate;
+    }
+
+    public final PendingGetCredentialHandle getPendingGetCredentialHandle() {
+        return this.pendingGetCredentialHandle;
+    }
+
+    public final boolean isNullHandlesForTest() {
+        return this.isNullHandlesForTest;
+    }
+
+    private PrepareGetCredentialResponse(PendingGetCredentialHandle pendingGetCredentialHandle, Function0 function0, Function0 function02, Function1 function1, boolean z) {
+        this.pendingGetCredentialHandle = pendingGetCredentialHandle;
+        this.hasRemoteResultsDelegate = function0;
+        this.hasAuthResultsDelegate = function02;
+        this.credentialTypeDelegate = function1;
+        this.isNullHandlesForTest = z;
+        if (Build.VERSION.SDK_INT < 34 || z) {
+            return;
+        }
+        Intrinsics.checkNotNull(pendingGetCredentialHandle);
+    }
+
+    @RequiresPermission("android.permission.CREDENTIAL_MANAGER_QUERY_CANDIDATE_CREDENTIALS")
+    public final boolean hasCredentialResults(String credentialType) {
+        Intrinsics.checkNotNullParameter(credentialType, "credentialType");
+        Function1 function1 = this.credentialTypeDelegate;
+        if (function1 != null) {
+            return ((Boolean) function1.invoke(credentialType)).booleanValue();
+        }
+        return false;
+    }
+
+    @RequiresPermission("android.permission.CREDENTIAL_MANAGER_QUERY_CANDIDATE_CREDENTIALS")
+    public final boolean hasAuthenticationResults() {
+        Function0 function0 = this.hasAuthResultsDelegate;
+        if (function0 != null) {
+            return ((Boolean) function0.invoke()).booleanValue();
+        }
+        return false;
+    }
+
+    @RequiresPermission("android.permission.CREDENTIAL_MANAGER_QUERY_CANDIDATE_CREDENTIALS")
+    public final boolean hasRemoteResults() {
+        Function0 function0 = this.hasRemoteResultsDelegate;
+        if (function0 != null) {
+            return ((Boolean) function0.invoke()).booleanValue();
+        }
+        return false;
+    }
+
+    @RequiresApi(34)
+    public static final class PendingGetCredentialHandle {
+        private final PrepareGetCredentialResponse.PendingGetCredentialHandle frameworkHandle;
+
+        @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+        public final PrepareGetCredentialResponse.PendingGetCredentialHandle getFrameworkHandle() {
+            return this.frameworkHandle;
+        }
+
+        public PendingGetCredentialHandle(PrepareGetCredentialResponse.PendingGetCredentialHandle pendingGetCredentialHandle) {
+            this.frameworkHandle = pendingGetCredentialHandle;
+            if (Build.VERSION.SDK_INT >= 34) {
+                Intrinsics.checkNotNull(pendingGetCredentialHandle);
+            }
+        }
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static final class Builder {
+        private android.credentials.PrepareGetCredentialResponse frameworkResponse;
+        private Function0 hasAuthResultsDelegate;
+        private Function1 hasCredentialResultsDelegate;
+        private Function0 hasRemoteResultsDelegate;
+        private PendingGetCredentialHandle pendingGetCredentialHandle;
+
+        public final Builder setPendingGetCredentialHandle(PendingGetCredentialHandle handle) {
+            Intrinsics.checkNotNullParameter(handle, "handle");
+            this.pendingGetCredentialHandle = handle;
+            return this;
+        }
+
+        public final Builder setFrameworkResponse(android.credentials.PrepareGetCredentialResponse prepareGetCredentialResponse) {
+            this.frameworkResponse = prepareGetCredentialResponse;
+            if (prepareGetCredentialResponse != null) {
+                this.hasCredentialResultsDelegate = new PrepareGetCredentialResponse$Builder$setFrameworkResponse$1(this);
+                this.hasAuthResultsDelegate = new PrepareGetCredentialResponse$Builder$setFrameworkResponse$2(this);
+                this.hasRemoteResultsDelegate = new PrepareGetCredentialResponse$Builder$setFrameworkResponse$3(this);
+            }
+            return this;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        @RequiresPermission("android.permission.CREDENTIAL_MANAGER_QUERY_CANDIDATE_CREDENTIALS")
+        public final boolean hasCredentialType(String str) {
+            boolean hasCredentialResults;
+            android.credentials.PrepareGetCredentialResponse prepareGetCredentialResponse = this.frameworkResponse;
+            Intrinsics.checkNotNull(prepareGetCredentialResponse);
+            hasCredentialResults = prepareGetCredentialResponse.hasCredentialResults(str);
+            return hasCredentialResults;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        @RequiresPermission("android.permission.CREDENTIAL_MANAGER_QUERY_CANDIDATE_CREDENTIALS")
+        public final boolean hasAuthenticationResults() {
+            boolean hasAuthenticationResults;
+            android.credentials.PrepareGetCredentialResponse prepareGetCredentialResponse = this.frameworkResponse;
+            Intrinsics.checkNotNull(prepareGetCredentialResponse);
+            hasAuthenticationResults = prepareGetCredentialResponse.hasAuthenticationResults();
+            return hasAuthenticationResults;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        @RequiresPermission("android.permission.CREDENTIAL_MANAGER_QUERY_CANDIDATE_CREDENTIALS")
+        public final boolean hasRemoteResults() {
+            boolean hasRemoteResults;
+            android.credentials.PrepareGetCredentialResponse prepareGetCredentialResponse = this.frameworkResponse;
+            Intrinsics.checkNotNull(prepareGetCredentialResponse);
+            hasRemoteResults = prepareGetCredentialResponse.hasRemoteResults();
+            return hasRemoteResults;
+        }
+
+        public final PrepareGetCredentialResponse build() {
+            return new PrepareGetCredentialResponse(this.pendingGetCredentialHandle, this.hasRemoteResultsDelegate, this.hasAuthResultsDelegate, this.hasCredentialResultsDelegate, false, null);
+        }
+    }
+
+    @VisibleForTesting
+    public static final class TestBuilder {
+        private Function0 hasAuthResultsDelegate;
+        private Function1 hasCredentialResultsDelegate;
+        private Function0 hasRemoteResultsDelegate;
+
+        @VisibleForTesting
+        public final TestBuilder setCredentialTypeDelegate(Function1 handler) {
+            Intrinsics.checkNotNullParameter(handler, "handler");
+            this.hasCredentialResultsDelegate = handler;
+            return this;
+        }
+
+        @VisibleForTesting
+        public final TestBuilder setHasAuthResultsDelegate(Function0 handler) {
+            Intrinsics.checkNotNullParameter(handler, "handler");
+            this.hasAuthResultsDelegate = handler;
+            return this;
+        }
+
+        @VisibleForTesting
+        public final TestBuilder setHasRemoteResultsDelegate(Function0 handler) {
+            Intrinsics.checkNotNullParameter(handler, "handler");
+            this.hasRemoteResultsDelegate = handler;
+            return this;
+        }
+
+        public final PrepareGetCredentialResponse build() {
+            return new PrepareGetCredentialResponse(null, this.hasRemoteResultsDelegate, this.hasAuthResultsDelegate, this.hasCredentialResultsDelegate, true, null);
+        }
+    }
+}

decompiled/sources/androidx/credentials/PrepareGetCredentialResponseKt.java

@@ -0,0 +1,5 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public final class PrepareGetCredentialResponseKt {
+}

decompiled/sources/androidx/credentials/PublicKeyCredential.java

@@ -0,0 +1,65 @@
+package androidx.credentials;
+
+import android.os.Bundle;
+import androidx.credentials.internal.FrameworkClassParsingException;
+import androidx.credentials.internal.RequestValidationHelper;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class PublicKeyCredential extends Credential {
+    public static final String BUNDLE_KEY_AUTHENTICATION_RESPONSE_JSON = "androidx.credentials.BUNDLE_KEY_AUTHENTICATION_RESPONSE_JSON";
+    public static final String BUNDLE_KEY_SUBTYPE = "androidx.credentials.BUNDLE_KEY_SUBTYPE";
+    public static final Companion Companion = new Companion(null);
+    public static final String TYPE_PUBLIC_KEY_CREDENTIAL = "androidx.credentials.TYPE_PUBLIC_KEY_CREDENTIAL";
+    private final String authenticationResponseJson;
+
+    public /* synthetic */ PublicKeyCredential(String str, Bundle bundle, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, bundle);
+    }
+
+    public final String getAuthenticationResponseJson() {
+        return this.authenticationResponseJson;
+    }
+
+    private PublicKeyCredential(String str, Bundle bundle) {
+        super(TYPE_PUBLIC_KEY_CREDENTIAL, bundle);
+        this.authenticationResponseJson = str;
+        if (!RequestValidationHelper.Companion.isValidJSON(str)) {
+            throw new IllegalArgumentException("authenticationResponseJson must not be empty, and must be a valid JSON".toString());
+        }
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public PublicKeyCredential(String authenticationResponseJson) {
+        this(authenticationResponseJson, Companion.toBundle$credentials_release(authenticationResponseJson));
+        Intrinsics.checkNotNullParameter(authenticationResponseJson, "authenticationResponseJson");
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final Bundle toBundle$credentials_release(String authenticationResponseJson) {
+            Intrinsics.checkNotNullParameter(authenticationResponseJson, "authenticationResponseJson");
+            Bundle bundle = new Bundle();
+            bundle.putString(PublicKeyCredential.BUNDLE_KEY_AUTHENTICATION_RESPONSE_JSON, authenticationResponseJson);
+            return bundle;
+        }
+
+        public final PublicKeyCredential createFrom$credentials_release(Bundle data) {
+            Intrinsics.checkNotNullParameter(data, "data");
+            try {
+                String string = data.getString(PublicKeyCredential.BUNDLE_KEY_AUTHENTICATION_RESPONSE_JSON);
+                Intrinsics.checkNotNull(string);
+                return new PublicKeyCredential(string, data, null);
+            } catch (Exception unused) {
+                throw new FrameworkClassParsingException();
+            }
+        }
+    }
+}

decompiled/sources/androidx/credentials/R.java

@@ -0,0 +1,32 @@
+package androidx.credentials;
+
+/* loaded from: classes.dex */
+public final class R {
+
+    public static final class drawable {
+        public static int ic_other_sign_in = 0x7f080199;
+        public static int ic_passkey = 0x7f08019a;
+        public static int ic_password = 0x7f08019b;
+
+        private drawable() {
+        }
+    }
+
+    public static final class id {
+        public static int androidx_credential_pendingCredentialRequest = 0x7f0a0073;
+
+        private id() {
+        }
+    }
+
+    public static final class string {
+        public static int android_credentials_TYPE_PASSWORD_CREDENTIAL = 0x7f120068;
+        public static int androidx_credentials_TYPE_PUBLIC_KEY_CREDENTIAL = 0x7f120069;
+
+        private string() {
+        }
+    }
+
+    private R() {
+    }
+}

decompiled/sources/androidx/credentials/RestoreCredential.java

@@ -0,0 +1,49 @@
+package androidx.credentials;
+
+import android.os.Bundle;
+import androidx.credentials.exceptions.NoCredentialException;
+import androidx.credentials.internal.RequestValidationHelper;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class RestoreCredential extends Credential {
+    private static final String BUNDLE_KEY_GET_RESTORE_CREDENTIAL_RESPONSE = "androidx.credentials.BUNDLE_KEY_GET_RESTORE_CREDENTIAL_RESPONSE";
+    public static final Companion Companion = new Companion(null);
+    public static final String TYPE_RESTORE_CREDENTIAL = "androidx.credentials.TYPE_RESTORE_CREDENTIAL";
+    private final String authenticationResponseJson;
+
+    public /* synthetic */ RestoreCredential(String str, Bundle bundle, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, bundle);
+    }
+
+    public final String getAuthenticationResponseJson() {
+        return this.authenticationResponseJson;
+    }
+
+    private RestoreCredential(String str, Bundle bundle) {
+        super(TYPE_RESTORE_CREDENTIAL, bundle);
+        this.authenticationResponseJson = str;
+        if (!RequestValidationHelper.Companion.isValidJSON(str)) {
+            throw new IllegalArgumentException("authenticationResponseJson must not be empty, and must be a valid JSON".toString());
+        }
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final RestoreCredential createFrom$credentials_release(Bundle data) {
+            Intrinsics.checkNotNullParameter(data, "data");
+            String string = data.getString(RestoreCredential.BUNDLE_KEY_GET_RESTORE_CREDENTIAL_RESPONSE);
+            if (string == null) {
+                throw new NoCredentialException("The device does not contain a restore credential.");
+            }
+            return new RestoreCredential(string, data, null);
+        }
+    }
+}