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/playservices/controllers/BeginSignIn/BeginSignInControllerUtility.java

@@ -0,0 +1,89 @@
+package androidx.credentials.playservices.controllers.BeginSignIn;
+
+import android.content.Context;
+import androidx.credentials.CredentialOption;
+import androidx.credentials.GetCredentialRequest;
+import androidx.credentials.GetPasswordOption;
+import androidx.credentials.GetPublicKeyCredentialOption;
+import androidx.credentials.playservices.controllers.CreatePublicKeyCredential.PublicKeyCredentialControllerUtility;
+import com.google.android.gms.auth.api.identity.BeginSignInRequest;
+import com.google.android.libraries.identity.googleid.GetGoogleIdOption;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class BeginSignInControllerUtility {
+    private static final long AUTH_MIN_VERSION_JSON_PARSING = 231815000;
+    private static final long AUTH_MIN_VERSION_PREFER_IMME_CRED = 241217000;
+    public static final Companion Companion = new Companion(null);
+    private static final String TAG = "BeginSignInUtility";
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private final boolean needsBackwardsCompatibleRequest(long j) {
+            return j < BeginSignInControllerUtility.AUTH_MIN_VERSION_JSON_PARSING;
+        }
+
+        private Companion() {
+        }
+
+        public final BeginSignInRequest constructBeginSignInRequest$credentials_play_services_auth_release(GetCredentialRequest request, Context context) {
+            Intrinsics.checkNotNullParameter(request, "request");
+            Intrinsics.checkNotNullParameter(context, "context");
+            BeginSignInRequest.Builder builder = new BeginSignInRequest.Builder();
+            long determineDeviceGMSVersionCode = determineDeviceGMSVersionCode(context);
+            boolean z = false;
+            boolean z2 = false;
+            for (CredentialOption credentialOption : request.getCredentialOptions()) {
+                if (credentialOption instanceof GetPasswordOption) {
+                    builder.setPasswordRequestOptions(new BeginSignInRequest.PasswordRequestOptions.Builder().setSupported(true).build());
+                    if (!z && !credentialOption.isAutoSelectAllowed()) {
+                        z = false;
+                    }
+                    z = true;
+                } else if ((credentialOption instanceof GetPublicKeyCredentialOption) && !z2) {
+                    if (needsBackwardsCompatibleRequest(determineDeviceGMSVersionCode)) {
+                        builder.setPasskeysSignInRequestOptions(PublicKeyCredentialControllerUtility.Companion.convertToPlayAuthPasskeyRequest((GetPublicKeyCredentialOption) credentialOption));
+                    } else {
+                        builder.setPasskeyJsonSignInRequestOptions(PublicKeyCredentialControllerUtility.Companion.convertToPlayAuthPasskeyJsonRequest((GetPublicKeyCredentialOption) credentialOption));
+                    }
+                    z2 = true;
+                } else if (credentialOption instanceof GetGoogleIdOption) {
+                    GetGoogleIdOption getGoogleIdOption = (GetGoogleIdOption) credentialOption;
+                    builder.setGoogleIdTokenRequestOptions(convertToGoogleIdTokenOption(getGoogleIdOption));
+                    if (!z && !getGoogleIdOption.getAutoSelectEnabled()) {
+                        z = false;
+                    }
+                    z = true;
+                }
+            }
+            if (determineDeviceGMSVersionCode > BeginSignInControllerUtility.AUTH_MIN_VERSION_PREFER_IMME_CRED) {
+                builder.setPreferImmediatelyAvailableCredentials(request.preferImmediatelyAvailableCredentials());
+            }
+            BeginSignInRequest build = builder.setAutoSelectEnabled(z).build();
+            Intrinsics.checkNotNullExpressionValue(build, "build(...)");
+            return build;
+        }
+
+        private final long determineDeviceGMSVersionCode(Context context) {
+            Intrinsics.checkNotNullExpressionValue(context.getPackageManager(), "getPackageManager(...)");
+            return r3.getPackageInfo("com.google.android.gms", 0).versionCode;
+        }
+
+        private final BeginSignInRequest.GoogleIdTokenRequestOptions convertToGoogleIdTokenOption(GetGoogleIdOption getGoogleIdOption) {
+            BeginSignInRequest.GoogleIdTokenRequestOptions.Builder supported = BeginSignInRequest.GoogleIdTokenRequestOptions.builder().setFilterByAuthorizedAccounts(getGoogleIdOption.getFilterByAuthorizedAccounts()).setNonce(getGoogleIdOption.getNonce()).setRequestVerifiedPhoneNumber(getGoogleIdOption.getRequestVerifiedPhoneNumber()).setServerClientId(getGoogleIdOption.getServerClientId()).setSupported(true);
+            Intrinsics.checkNotNullExpressionValue(supported, "setSupported(...)");
+            if (getGoogleIdOption.getLinkedServiceId() != null) {
+                String linkedServiceId = getGoogleIdOption.getLinkedServiceId();
+                Intrinsics.checkNotNull(linkedServiceId);
+                supported.associateLinkedAccounts(linkedServiceId, getGoogleIdOption.getIdTokenDepositionScopes());
+            }
+            BeginSignInRequest.GoogleIdTokenRequestOptions build = supported.build();
+            Intrinsics.checkNotNullExpressionValue(build, "build(...)");
+            return build;
+        }
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/BeginSignIn/CredentialProviderBeginSignInController$handleResponse$2.java

@@ -0,0 +1,42 @@
+package androidx.credentials.playservices.controllers.BeginSignIn;
+
+import androidx.credentials.exceptions.GetCredentialException;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderBeginSignInController$handleResponse$2 extends Lambda implements Function1 {
+    final /* synthetic */ CredentialProviderBeginSignInController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderBeginSignInController$handleResponse$2(CredentialProviderBeginSignInController credentialProviderBeginSignInController) {
+        super(1);
+        this.this$0 = credentialProviderBeginSignInController;
+    }
+
+    @Override // kotlin.jvm.functions.Function1
+    public /* bridge */ /* synthetic */ Object invoke(Object obj) {
+        invoke((GetCredentialException) obj);
+        return Unit.INSTANCE;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderBeginSignInController credentialProviderBeginSignInController, GetCredentialException getCredentialException) {
+        credentialProviderBeginSignInController.getCallback().onError(getCredentialException);
+    }
+
+    public final void invoke(final GetCredentialException e) {
+        Intrinsics.checkNotNullParameter(e, "e");
+        Executor executor = this.this$0.getExecutor();
+        final CredentialProviderBeginSignInController credentialProviderBeginSignInController = this.this$0;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.BeginSignIn.CredentialProviderBeginSignInController$handleResponse$2$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderBeginSignInController$handleResponse$2.invoke$lambda$0(CredentialProviderBeginSignInController.this, e);
+            }
+        });
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/BeginSignIn/CredentialProviderBeginSignInController$handleResponse$3.java

@@ -0,0 +1,44 @@
+package androidx.credentials.playservices.controllers.BeginSignIn;
+
+import androidx.credentials.GetCredentialResponse;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderBeginSignInController$handleResponse$3 extends Lambda implements Function0 {
+    final /* synthetic */ GetCredentialResponse $response;
+    final /* synthetic */ CredentialProviderBeginSignInController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderBeginSignInController$handleResponse$3(CredentialProviderBeginSignInController credentialProviderBeginSignInController, GetCredentialResponse getCredentialResponse) {
+        super(0);
+        this.this$0 = credentialProviderBeginSignInController;
+        this.$response = getCredentialResponse;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m91invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderBeginSignInController credentialProviderBeginSignInController, GetCredentialResponse getCredentialResponse) {
+        credentialProviderBeginSignInController.getCallback().onResult(getCredentialResponse);
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m91invoke() {
+        Executor executor = this.this$0.getExecutor();
+        final CredentialProviderBeginSignInController credentialProviderBeginSignInController = this.this$0;
+        final GetCredentialResponse getCredentialResponse = this.$response;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.BeginSignIn.CredentialProviderBeginSignInController$handleResponse$3$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderBeginSignInController$handleResponse$3.invoke$lambda$0(CredentialProviderBeginSignInController.this, getCredentialResponse);
+            }
+        });
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/BeginSignIn/CredentialProviderBeginSignInController$handleResponse$4.java

@@ -0,0 +1,46 @@
+package androidx.credentials.playservices.controllers.BeginSignIn;
+
+import androidx.credentials.exceptions.GetCredentialException;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Lambda;
+import kotlin.jvm.internal.Ref;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderBeginSignInController$handleResponse$4 extends Lambda implements Function0 {
+    final /* synthetic */ Ref.ObjectRef<GetCredentialException> $exception;
+    final /* synthetic */ CredentialProviderBeginSignInController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderBeginSignInController$handleResponse$4(CredentialProviderBeginSignInController credentialProviderBeginSignInController, Ref.ObjectRef<GetCredentialException> objectRef) {
+        super(0);
+        this.this$0 = credentialProviderBeginSignInController;
+        this.$exception = objectRef;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m93invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* JADX WARN: Multi-variable type inference failed */
+    public static final void invoke$lambda$0(CredentialProviderBeginSignInController credentialProviderBeginSignInController, Ref.ObjectRef objectRef) {
+        credentialProviderBeginSignInController.getCallback().onError(objectRef.element);
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m93invoke() {
+        Executor executor = this.this$0.getExecutor();
+        final CredentialProviderBeginSignInController credentialProviderBeginSignInController = this.this$0;
+        final Ref.ObjectRef<GetCredentialException> objectRef = this.$exception;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.BeginSignIn.CredentialProviderBeginSignInController$handleResponse$4$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderBeginSignInController$handleResponse$4.invoke$lambda$0(CredentialProviderBeginSignInController.this, objectRef);
+            }
+        });
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/BeginSignIn/CredentialProviderBeginSignInController$handleResponse$5.java

@@ -0,0 +1,44 @@
+package androidx.credentials.playservices.controllers.BeginSignIn;
+
+import androidx.credentials.exceptions.GetCredentialException;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderBeginSignInController$handleResponse$5 extends Lambda implements Function0 {
+    final /* synthetic */ GetCredentialException $e;
+    final /* synthetic */ CredentialProviderBeginSignInController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderBeginSignInController$handleResponse$5(CredentialProviderBeginSignInController credentialProviderBeginSignInController, GetCredentialException getCredentialException) {
+        super(0);
+        this.this$0 = credentialProviderBeginSignInController;
+        this.$e = getCredentialException;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m94invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderBeginSignInController credentialProviderBeginSignInController, GetCredentialException getCredentialException) {
+        credentialProviderBeginSignInController.getCallback().onError(getCredentialException);
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m94invoke() {
+        Executor executor = this.this$0.getExecutor();
+        final CredentialProviderBeginSignInController credentialProviderBeginSignInController = this.this$0;
+        final GetCredentialException getCredentialException = this.$e;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.BeginSignIn.CredentialProviderBeginSignInController$handleResponse$5$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderBeginSignInController$handleResponse$5.invoke$lambda$0(CredentialProviderBeginSignInController.this, getCredentialException);
+            }
+        });
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/BeginSignIn/CredentialProviderBeginSignInController$handleResponse$6.java

@@ -0,0 +1,44 @@
+package androidx.credentials.playservices.controllers.BeginSignIn;
+
+import androidx.credentials.exceptions.GetCredentialUnknownException;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderBeginSignInController$handleResponse$6 extends Lambda implements Function0 {
+    final /* synthetic */ GetCredentialUnknownException $e;
+    final /* synthetic */ CredentialProviderBeginSignInController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderBeginSignInController$handleResponse$6(CredentialProviderBeginSignInController credentialProviderBeginSignInController, GetCredentialUnknownException getCredentialUnknownException) {
+        super(0);
+        this.this$0 = credentialProviderBeginSignInController;
+        this.$e = getCredentialUnknownException;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m95invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderBeginSignInController credentialProviderBeginSignInController, GetCredentialUnknownException getCredentialUnknownException) {
+        credentialProviderBeginSignInController.getCallback().onError(getCredentialUnknownException);
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m95invoke() {
+        Executor executor = this.this$0.getExecutor();
+        final CredentialProviderBeginSignInController credentialProviderBeginSignInController = this.this$0;
+        final GetCredentialUnknownException getCredentialUnknownException = this.$e;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.BeginSignIn.CredentialProviderBeginSignInController$handleResponse$6$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderBeginSignInController$handleResponse$6.invoke$lambda$0(CredentialProviderBeginSignInController.this, getCredentialUnknownException);
+            }
+        });
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/BeginSignIn/CredentialProviderBeginSignInController$invokePlayServices$1.java

@@ -0,0 +1,42 @@
+package androidx.credentials.playservices.controllers.BeginSignIn;
+
+import androidx.credentials.exceptions.GetCredentialUnknownException;
+import androidx.credentials.playservices.controllers.CredentialProviderController;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderBeginSignInController$invokePlayServices$1 extends Lambda implements Function0 {
+    final /* synthetic */ CredentialProviderBeginSignInController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderBeginSignInController$invokePlayServices$1(CredentialProviderBeginSignInController credentialProviderBeginSignInController) {
+        super(0);
+        this.this$0 = credentialProviderBeginSignInController;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m96invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m96invoke() {
+        Executor executor = this.this$0.getExecutor();
+        final CredentialProviderBeginSignInController credentialProviderBeginSignInController = this.this$0;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.BeginSignIn.CredentialProviderBeginSignInController$invokePlayServices$1$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderBeginSignInController$invokePlayServices$1.invoke$lambda$0(CredentialProviderBeginSignInController.this);
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderBeginSignInController credentialProviderBeginSignInController) {
+        credentialProviderBeginSignInController.getCallback().onError(new GetCredentialUnknownException(CredentialProviderController.ERROR_MESSAGE_START_ACTIVITY_FAILED));
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/BeginSignIn/CredentialProviderBeginSignInController$resultReceiver$1$onReceiveResult$1.java

@@ -0,0 +1,18 @@
+package androidx.credentials.playservices.controllers.BeginSignIn;
+
+import androidx.credentials.exceptions.GetCredentialException;
+import androidx.credentials.playservices.controllers.CredentialProviderBaseController;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.FunctionReferenceImpl;
+
+/* loaded from: classes.dex */
+public /* synthetic */ class CredentialProviderBeginSignInController$resultReceiver$1$onReceiveResult$1 extends FunctionReferenceImpl implements Function2 {
+    public CredentialProviderBeginSignInController$resultReceiver$1$onReceiveResult$1(Object obj) {
+        super(2, obj, CredentialProviderBaseController.Companion.class, "getCredentialExceptionTypeToException", "getCredentialExceptionTypeToException$credentials_play_services_auth_release(Ljava/lang/String;Ljava/lang/String;)Landroidx/credentials/exceptions/GetCredentialException;", 0);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final GetCredentialException invoke(String str, String str2) {
+        return ((CredentialProviderBaseController.Companion) this.receiver).getCredentialExceptionTypeToException$credentials_play_services_auth_release(str, str2);
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/BeginSignIn/CredentialProviderBeginSignInController.java

@@ -0,0 +1,258 @@
+package androidx.credentials.playservices.controllers.BeginSignIn;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.CancellationSignal;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.ResultReceiver;
+import android.util.Log;
+import androidx.annotation.VisibleForTesting;
+import androidx.credentials.Credential;
+import androidx.credentials.CredentialManagerCallback;
+import androidx.credentials.GetCredentialRequest;
+import androidx.credentials.GetCredentialResponse;
+import androidx.credentials.PasswordCredential;
+import androidx.credentials.PublicKeyCredential;
+import androidx.credentials.exceptions.GetCredentialCancellationException;
+import androidx.credentials.exceptions.GetCredentialException;
+import androidx.credentials.exceptions.GetCredentialInterruptedException;
+import androidx.credentials.exceptions.GetCredentialUnknownException;
+import androidx.credentials.playservices.CredentialProviderPlayServicesImpl;
+import androidx.credentials.playservices.HiddenActivity;
+import androidx.credentials.playservices.controllers.CreatePublicKeyCredential.PublicKeyCredentialControllerUtility;
+import androidx.credentials.playservices.controllers.CredentialProviderBaseController;
+import androidx.credentials.playservices.controllers.CredentialProviderController;
+import com.google.android.gms.auth.api.identity.BeginSignInRequest;
+import com.google.android.gms.auth.api.identity.Identity;
+import com.google.android.gms.auth.api.identity.SignInCredential;
+import com.google.android.gms.common.api.ApiException;
+import com.google.android.libraries.identity.googleid.GoogleIdTokenCredential;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Ref;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderBeginSignInController extends CredentialProviderController<GetCredentialRequest, BeginSignInRequest, SignInCredential, GetCredentialResponse, GetCredentialException> {
+    public static final Companion Companion = new Companion(null);
+    private static final String TAG = "BeginSignIn";
+    public CredentialManagerCallback<GetCredentialResponse, GetCredentialException> callback;
+    private CancellationSignal cancellationSignal;
+    private final Context context;
+    public Executor executor;
+    private final CredentialProviderBeginSignInController$resultReceiver$1 resultReceiver;
+
+    @VisibleForTesting(otherwise = 2)
+    public static /* synthetic */ void getCallback$annotations() {
+    }
+
+    @VisibleForTesting(otherwise = 2)
+    private static /* synthetic */ void getCancellationSignal$annotations() {
+    }
+
+    @VisibleForTesting(otherwise = 2)
+    public static /* synthetic */ void getExecutor$annotations() {
+    }
+
+    public static final CredentialProviderBeginSignInController getInstance(Context context) {
+        return Companion.getInstance(context);
+    }
+
+    public final void setCallback(CredentialManagerCallback<GetCredentialResponse, GetCredentialException> credentialManagerCallback) {
+        Intrinsics.checkNotNullParameter(credentialManagerCallback, "<set-?>");
+        this.callback = credentialManagerCallback;
+    }
+
+    public final void setExecutor(Executor executor) {
+        Intrinsics.checkNotNullParameter(executor, "<set-?>");
+        this.executor = executor;
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    /* JADX WARN: Type inference failed for: r0v2, types: [androidx.credentials.playservices.controllers.BeginSignIn.CredentialProviderBeginSignInController$resultReceiver$1] */
+    public CredentialProviderBeginSignInController(Context context) {
+        super(context);
+        Intrinsics.checkNotNullParameter(context, "context");
+        this.context = context;
+        final Handler handler = new Handler(Looper.getMainLooper());
+        this.resultReceiver = new ResultReceiver(handler) { // from class: androidx.credentials.playservices.controllers.BeginSignIn.CredentialProviderBeginSignInController$resultReceiver$1
+            @Override // android.os.ResultReceiver
+            public void onReceiveResult(int i, Bundle resultData) {
+                CancellationSignal cancellationSignal;
+                boolean maybeReportErrorFromResultReceiver;
+                Intrinsics.checkNotNullParameter(resultData, "resultData");
+                CredentialProviderBeginSignInController credentialProviderBeginSignInController = CredentialProviderBeginSignInController.this;
+                CredentialProviderBeginSignInController$resultReceiver$1$onReceiveResult$1 credentialProviderBeginSignInController$resultReceiver$1$onReceiveResult$1 = new CredentialProviderBeginSignInController$resultReceiver$1$onReceiveResult$1(CredentialProviderBaseController.Companion);
+                Executor executor = CredentialProviderBeginSignInController.this.getExecutor();
+                CredentialManagerCallback<GetCredentialResponse, GetCredentialException> callback = CredentialProviderBeginSignInController.this.getCallback();
+                cancellationSignal = CredentialProviderBeginSignInController.this.cancellationSignal;
+                maybeReportErrorFromResultReceiver = credentialProviderBeginSignInController.maybeReportErrorFromResultReceiver(resultData, credentialProviderBeginSignInController$resultReceiver$1$onReceiveResult$1, executor, callback, cancellationSignal);
+                if (maybeReportErrorFromResultReceiver) {
+                    return;
+                }
+                CredentialProviderBeginSignInController.this.handleResponse$credentials_play_services_auth_release(resultData.getInt(CredentialProviderBaseController.ACTIVITY_REQUEST_CODE_TAG), i, (Intent) resultData.getParcelable(CredentialProviderBaseController.RESULT_DATA_TAG));
+            }
+        };
+    }
+
+    public final CredentialManagerCallback<GetCredentialResponse, GetCredentialException> getCallback() {
+        CredentialManagerCallback<GetCredentialResponse, GetCredentialException> credentialManagerCallback = this.callback;
+        if (credentialManagerCallback != null) {
+            return credentialManagerCallback;
+        }
+        Intrinsics.throwUninitializedPropertyAccessException("callback");
+        return null;
+    }
+
+    public final Executor getExecutor() {
+        Executor executor = this.executor;
+        if (executor != null) {
+            return executor;
+        }
+        Intrinsics.throwUninitializedPropertyAccessException("executor");
+        return null;
+    }
+
+    @Override // androidx.credentials.playservices.controllers.CredentialProviderController
+    public void invokePlayServices(GetCredentialRequest request, CredentialManagerCallback<GetCredentialResponse, GetCredentialException> callback, Executor executor, CancellationSignal cancellationSignal) {
+        Intrinsics.checkNotNullParameter(request, "request");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        Intrinsics.checkNotNullParameter(executor, "executor");
+        this.cancellationSignal = cancellationSignal;
+        setCallback(callback);
+        setExecutor(executor);
+        if (CredentialProviderPlayServicesImpl.Companion.cancellationReviewer$credentials_play_services_auth_release(cancellationSignal)) {
+            return;
+        }
+        BeginSignInRequest convertRequestToPlayServices = convertRequestToPlayServices(request);
+        Intent intent = new Intent(this.context, (Class<?>) HiddenActivity.class);
+        intent.putExtra(CredentialProviderBaseController.REQUEST_TAG, convertRequestToPlayServices);
+        generateHiddenActivityIntent(this.resultReceiver, intent, CredentialProviderBaseController.BEGIN_SIGN_IN_TAG);
+        try {
+            this.context.startActivity(intent);
+        } catch (Exception unused) {
+            CredentialProviderController.cancelOrCallbackExceptionOrResult(cancellationSignal, new CredentialProviderBeginSignInController$invokePlayServices$1(this));
+        }
+    }
+
+    /* JADX WARN: Type inference failed for: r5v2, types: [T, androidx.credentials.exceptions.GetCredentialUnknownException] */
+    /* JADX WARN: Type inference failed for: r5v7, types: [T, androidx.credentials.exceptions.GetCredentialInterruptedException] */
+    /* JADX WARN: Type inference failed for: r5v9, types: [T, androidx.credentials.exceptions.GetCredentialCancellationException] */
+    public final void handleResponse$credentials_play_services_auth_release(int i, int i2, Intent intent) {
+        CredentialProviderBaseController.Companion companion = CredentialProviderBaseController.Companion;
+        if (i != companion.getCONTROLLER_REQUEST_CODE$credentials_play_services_auth_release()) {
+            Log.w(TAG, "Returned request code " + companion.getCONTROLLER_REQUEST_CODE$credentials_play_services_auth_release() + " which  does not match what was given " + i);
+            return;
+        }
+        if (CredentialProviderController.maybeReportErrorResultCodeGet(i2, new Function2() { // from class: androidx.credentials.playservices.controllers.BeginSignIn.CredentialProviderBeginSignInController$handleResponse$1
+            @Override // kotlin.jvm.functions.Function2
+            public /* bridge */ /* synthetic */ Object invoke(Object obj, Object obj2) {
+                invoke((CancellationSignal) obj, (Function0) obj2);
+                return Unit.INSTANCE;
+            }
+
+            public final void invoke(CancellationSignal cancellationSignal, Function0 f) {
+                Intrinsics.checkNotNullParameter(f, "f");
+                CredentialProviderController.Companion companion2 = CredentialProviderController.Companion;
+                CredentialProviderController.cancelOrCallbackExceptionOrResult(cancellationSignal, f);
+            }
+        }, new CredentialProviderBeginSignInController$handleResponse$2(this), this.cancellationSignal)) {
+            return;
+        }
+        try {
+            SignInCredential signInCredentialFromIntent = Identity.getSignInClient(this.context).getSignInCredentialFromIntent(intent);
+            Intrinsics.checkNotNullExpressionValue(signInCredentialFromIntent, "getSignInCredentialFromIntent(...)");
+            CredentialProviderController.cancelOrCallbackExceptionOrResult(this.cancellationSignal, new CredentialProviderBeginSignInController$handleResponse$3(this, convertResponseToCredentialManager(signInCredentialFromIntent)));
+        } catch (GetCredentialException e) {
+            CredentialProviderController.cancelOrCallbackExceptionOrResult(this.cancellationSignal, new CredentialProviderBeginSignInController$handleResponse$5(this, e));
+        } catch (ApiException e2) {
+            Ref.ObjectRef objectRef = new Ref.ObjectRef();
+            objectRef.element = new GetCredentialUnknownException(e2.getMessage());
+            if (e2.getStatusCode() == 16) {
+                objectRef.element = new GetCredentialCancellationException(e2.getMessage());
+            } else if (CredentialProviderBaseController.Companion.getRetryables().contains(Integer.valueOf(e2.getStatusCode()))) {
+                objectRef.element = new GetCredentialInterruptedException(e2.getMessage());
+            }
+            CredentialProviderController.cancelOrCallbackExceptionOrResult(this.cancellationSignal, new CredentialProviderBeginSignInController$handleResponse$4(this, objectRef));
+        } catch (Throwable th) {
+            CredentialProviderController.cancelOrCallbackExceptionOrResult(this.cancellationSignal, new CredentialProviderBeginSignInController$handleResponse$6(this, new GetCredentialUnknownException(th.getMessage())));
+        }
+    }
+
+    @Override // androidx.credentials.playservices.controllers.CredentialProviderController
+    @VisibleForTesting(otherwise = 4)
+    public BeginSignInRequest convertRequestToPlayServices(GetCredentialRequest request) {
+        Intrinsics.checkNotNullParameter(request, "request");
+        return BeginSignInControllerUtility.Companion.constructBeginSignInRequest$credentials_play_services_auth_release(request, this.context);
+    }
+
+    @Override // androidx.credentials.playservices.controllers.CredentialProviderController
+    @VisibleForTesting(otherwise = 4)
+    public GetCredentialResponse convertResponseToCredentialManager(SignInCredential response) {
+        Credential credential;
+        Intrinsics.checkNotNullParameter(response, "response");
+        if (response.getPassword() != null) {
+            String id = response.getId();
+            Intrinsics.checkNotNullExpressionValue(id, "getId(...)");
+            String password = response.getPassword();
+            Intrinsics.checkNotNull(password);
+            credential = new PasswordCredential(id, password);
+        } else if (response.getGoogleIdToken() != null) {
+            credential = createGoogleIdCredential(response);
+        } else if (response.getPublicKeyCredential() != null) {
+            credential = new PublicKeyCredential(PublicKeyCredentialControllerUtility.Companion.toAssertPasskeyResponse(response));
+        } else {
+            Log.w(TAG, "Credential returned but no google Id or password or passkey found");
+            credential = null;
+        }
+        if (credential == null) {
+            throw new GetCredentialUnknownException("When attempting to convert get response, null credential found");
+        }
+        return new GetCredentialResponse(credential);
+    }
+
+    private final GoogleIdTokenCredential createGoogleIdCredential(SignInCredential signInCredential) {
+        GoogleIdTokenCredential.Builder builder = new GoogleIdTokenCredential.Builder();
+        String id = signInCredential.getId();
+        Intrinsics.checkNotNullExpressionValue(id, "getId(...)");
+        GoogleIdTokenCredential.Builder id2 = builder.setId(id);
+        String googleIdToken = signInCredential.getGoogleIdToken();
+        Intrinsics.checkNotNull(googleIdToken);
+        GoogleIdTokenCredential.Builder idToken = id2.setIdToken(googleIdToken);
+        if (signInCredential.getDisplayName() != null) {
+            idToken.setDisplayName(signInCredential.getDisplayName());
+        }
+        if (signInCredential.getGivenName() != null) {
+            idToken.setGivenName(signInCredential.getGivenName());
+        }
+        if (signInCredential.getFamilyName() != null) {
+            idToken.setFamilyName(signInCredential.getFamilyName());
+        }
+        if (signInCredential.getPhoneNumber() != null) {
+            idToken.setPhoneNumber(signInCredential.getPhoneNumber());
+        }
+        if (signInCredential.getProfilePictureUri() != null) {
+            idToken.setProfilePictureUri(signInCredential.getProfilePictureUri());
+        }
+        return idToken.build();
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final CredentialProviderBeginSignInController getInstance(Context context) {
+            Intrinsics.checkNotNullParameter(context, "context");
+            return new CredentialProviderBeginSignInController(context);
+        }
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/CreatePassword/CredentialProviderCreatePasswordController$handleResponse$2.java

@@ -0,0 +1,54 @@
+package androidx.credentials.playservices.controllers.CreatePassword;
+
+import androidx.credentials.CredentialManagerCallback;
+import androidx.credentials.exceptions.CreateCredentialException;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderCreatePasswordController$handleResponse$2 extends Lambda implements Function1 {
+    final /* synthetic */ CredentialProviderCreatePasswordController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderCreatePasswordController$handleResponse$2(CredentialProviderCreatePasswordController credentialProviderCreatePasswordController) {
+        super(1);
+        this.this$0 = credentialProviderCreatePasswordController;
+    }
+
+    @Override // kotlin.jvm.functions.Function1
+    public /* bridge */ /* synthetic */ Object invoke(Object obj) {
+        invoke((CreateCredentialException) obj);
+        return Unit.INSTANCE;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderCreatePasswordController credentialProviderCreatePasswordController, CreateCredentialException createCredentialException) {
+        CredentialManagerCallback credentialManagerCallback;
+        credentialManagerCallback = credentialProviderCreatePasswordController.callback;
+        if (credentialManagerCallback == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("callback");
+            credentialManagerCallback = null;
+        }
+        credentialManagerCallback.onError(createCredentialException);
+    }
+
+    public final void invoke(final CreateCredentialException e) {
+        Executor executor;
+        Intrinsics.checkNotNullParameter(e, "e");
+        executor = this.this$0.executor;
+        if (executor == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("executor");
+            executor = null;
+        }
+        final CredentialProviderCreatePasswordController credentialProviderCreatePasswordController = this.this$0;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.CreatePassword.CredentialProviderCreatePasswordController$handleResponse$2$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderCreatePasswordController$handleResponse$2.invoke$lambda$0(CredentialProviderCreatePasswordController.this, e);
+            }
+        });
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/CreatePassword/CredentialProviderCreatePasswordController$handleResponse$3.java

@@ -0,0 +1,57 @@
+package androidx.credentials.playservices.controllers.CreatePassword;
+
+import androidx.credentials.CreateCredentialResponse;
+import androidx.credentials.CredentialManagerCallback;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderCreatePasswordController$handleResponse$3 extends Lambda implements Function0 {
+    final /* synthetic */ CreateCredentialResponse $response;
+    final /* synthetic */ CredentialProviderCreatePasswordController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderCreatePasswordController$handleResponse$3(CredentialProviderCreatePasswordController credentialProviderCreatePasswordController, CreateCredentialResponse createCredentialResponse) {
+        super(0);
+        this.this$0 = credentialProviderCreatePasswordController;
+        this.$response = createCredentialResponse;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m99invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderCreatePasswordController credentialProviderCreatePasswordController, CreateCredentialResponse createCredentialResponse) {
+        CredentialManagerCallback credentialManagerCallback;
+        credentialManagerCallback = credentialProviderCreatePasswordController.callback;
+        if (credentialManagerCallback == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("callback");
+            credentialManagerCallback = null;
+        }
+        credentialManagerCallback.onResult(createCredentialResponse);
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m99invoke() {
+        Executor executor;
+        executor = this.this$0.executor;
+        if (executor == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("executor");
+            executor = null;
+        }
+        final CredentialProviderCreatePasswordController credentialProviderCreatePasswordController = this.this$0;
+        final CreateCredentialResponse createCredentialResponse = this.$response;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.CreatePassword.CredentialProviderCreatePasswordController$handleResponse$3$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderCreatePasswordController$handleResponse$3.invoke$lambda$0(CredentialProviderCreatePasswordController.this, createCredentialResponse);
+            }
+        });
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/CreatePassword/CredentialProviderCreatePasswordController$invokePlayServices$1.java

@@ -0,0 +1,55 @@
+package androidx.credentials.playservices.controllers.CreatePassword;
+
+import androidx.credentials.CredentialManagerCallback;
+import androidx.credentials.exceptions.CreateCredentialUnknownException;
+import androidx.credentials.playservices.controllers.CredentialProviderController;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderCreatePasswordController$invokePlayServices$1 extends Lambda implements Function0 {
+    final /* synthetic */ CredentialProviderCreatePasswordController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderCreatePasswordController$invokePlayServices$1(CredentialProviderCreatePasswordController credentialProviderCreatePasswordController) {
+        super(0);
+        this.this$0 = credentialProviderCreatePasswordController;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m100invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m100invoke() {
+        Executor executor;
+        executor = this.this$0.executor;
+        if (executor == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("executor");
+            executor = null;
+        }
+        final CredentialProviderCreatePasswordController credentialProviderCreatePasswordController = this.this$0;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.CreatePassword.CredentialProviderCreatePasswordController$invokePlayServices$1$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderCreatePasswordController$invokePlayServices$1.invoke$lambda$0(CredentialProviderCreatePasswordController.this);
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderCreatePasswordController credentialProviderCreatePasswordController) {
+        CredentialManagerCallback credentialManagerCallback;
+        credentialManagerCallback = credentialProviderCreatePasswordController.callback;
+        if (credentialManagerCallback == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("callback");
+            credentialManagerCallback = null;
+        }
+        credentialManagerCallback.onError(new CreateCredentialUnknownException(CredentialProviderController.ERROR_MESSAGE_START_ACTIVITY_FAILED));
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/CreatePassword/CredentialProviderCreatePasswordController$resultReceiver$1$onReceiveResult$1.java

@@ -0,0 +1,18 @@
+package androidx.credentials.playservices.controllers.CreatePassword;
+
+import androidx.credentials.exceptions.CreateCredentialException;
+import androidx.credentials.playservices.controllers.CredentialProviderBaseController;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.FunctionReferenceImpl;
+
+/* loaded from: classes.dex */
+public /* synthetic */ class CredentialProviderCreatePasswordController$resultReceiver$1$onReceiveResult$1 extends FunctionReferenceImpl implements Function2 {
+    public CredentialProviderCreatePasswordController$resultReceiver$1$onReceiveResult$1(Object obj) {
+        super(2, obj, CredentialProviderBaseController.Companion.class, "createCredentialExceptionTypeToException", "createCredentialExceptionTypeToException$credentials_play_services_auth_release(Ljava/lang/String;Ljava/lang/String;)Landroidx/credentials/exceptions/CreateCredentialException;", 0);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final CreateCredentialException invoke(String str, String str2) {
+        return ((CredentialProviderBaseController.Companion) this.receiver).createCredentialExceptionTypeToException$credentials_play_services_auth_release(str, str2);
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/CreatePassword/CredentialProviderCreatePasswordController.java

@@ -0,0 +1,170 @@
+package androidx.credentials.playservices.controllers.CreatePassword;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.CancellationSignal;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.ResultReceiver;
+import android.util.Log;
+import androidx.annotation.VisibleForTesting;
+import androidx.credentials.CreateCredentialResponse;
+import androidx.credentials.CreatePasswordRequest;
+import androidx.credentials.CreatePasswordResponse;
+import androidx.credentials.CredentialManagerCallback;
+import androidx.credentials.exceptions.CreateCredentialException;
+import androidx.credentials.playservices.CredentialProviderPlayServicesImpl;
+import androidx.credentials.playservices.HiddenActivity;
+import androidx.credentials.playservices.controllers.CredentialProviderBaseController;
+import androidx.credentials.playservices.controllers.CredentialProviderController;
+import com.google.android.gms.auth.api.identity.SavePasswordRequest;
+import com.google.android.gms.auth.api.identity.SignInPassword;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderCreatePasswordController extends CredentialProviderController<CreatePasswordRequest, SavePasswordRequest, Unit, CreateCredentialResponse, CreateCredentialException> {
+    public static final Companion Companion = new Companion(null);
+    private static final String TAG = "CreatePassword";
+    private CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException> callback;
+    private CancellationSignal cancellationSignal;
+    private final Context context;
+    private Executor executor;
+    private final CredentialProviderCreatePasswordController$resultReceiver$1 resultReceiver;
+
+    @VisibleForTesting(otherwise = 2)
+    private static /* synthetic */ void getCallback$annotations() {
+    }
+
+    @VisibleForTesting(otherwise = 2)
+    private static /* synthetic */ void getCancellationSignal$annotations() {
+    }
+
+    public static final CredentialProviderCreatePasswordController getInstance(Context context) {
+        return Companion.getInstance(context);
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    /* JADX WARN: Type inference failed for: r0v2, types: [androidx.credentials.playservices.controllers.CreatePassword.CredentialProviderCreatePasswordController$resultReceiver$1] */
+    public CredentialProviderCreatePasswordController(Context context) {
+        super(context);
+        Intrinsics.checkNotNullParameter(context, "context");
+        this.context = context;
+        final Handler handler = new Handler(Looper.getMainLooper());
+        this.resultReceiver = new ResultReceiver(handler) { // from class: androidx.credentials.playservices.controllers.CreatePassword.CredentialProviderCreatePasswordController$resultReceiver$1
+            @Override // android.os.ResultReceiver
+            public void onReceiveResult(int i, Bundle resultData) {
+                Executor executor;
+                Executor executor2;
+                CredentialManagerCallback credentialManagerCallback;
+                CredentialManagerCallback credentialManagerCallback2;
+                CancellationSignal cancellationSignal;
+                boolean maybeReportErrorFromResultReceiver;
+                Intrinsics.checkNotNullParameter(resultData, "resultData");
+                CredentialProviderCreatePasswordController credentialProviderCreatePasswordController = CredentialProviderCreatePasswordController.this;
+                CredentialProviderCreatePasswordController$resultReceiver$1$onReceiveResult$1 credentialProviderCreatePasswordController$resultReceiver$1$onReceiveResult$1 = new CredentialProviderCreatePasswordController$resultReceiver$1$onReceiveResult$1(CredentialProviderBaseController.Companion);
+                executor = CredentialProviderCreatePasswordController.this.executor;
+                if (executor == null) {
+                    Intrinsics.throwUninitializedPropertyAccessException("executor");
+                    executor2 = null;
+                } else {
+                    executor2 = executor;
+                }
+                credentialManagerCallback = CredentialProviderCreatePasswordController.this.callback;
+                if (credentialManagerCallback == null) {
+                    Intrinsics.throwUninitializedPropertyAccessException("callback");
+                    credentialManagerCallback2 = null;
+                } else {
+                    credentialManagerCallback2 = credentialManagerCallback;
+                }
+                cancellationSignal = CredentialProviderCreatePasswordController.this.cancellationSignal;
+                maybeReportErrorFromResultReceiver = credentialProviderCreatePasswordController.maybeReportErrorFromResultReceiver(resultData, credentialProviderCreatePasswordController$resultReceiver$1$onReceiveResult$1, executor2, credentialManagerCallback2, cancellationSignal);
+                if (maybeReportErrorFromResultReceiver) {
+                    return;
+                }
+                CredentialProviderCreatePasswordController.this.handleResponse$credentials_play_services_auth_release(resultData.getInt(CredentialProviderBaseController.ACTIVITY_REQUEST_CODE_TAG), i);
+            }
+        };
+    }
+
+    @Override // androidx.credentials.playservices.controllers.CredentialProviderController
+    public void invokePlayServices(CreatePasswordRequest request, CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException> callback, Executor executor, CancellationSignal cancellationSignal) {
+        Intrinsics.checkNotNullParameter(request, "request");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        Intrinsics.checkNotNullParameter(executor, "executor");
+        this.cancellationSignal = cancellationSignal;
+        this.callback = callback;
+        this.executor = executor;
+        if (CredentialProviderPlayServicesImpl.Companion.cancellationReviewer$credentials_play_services_auth_release(cancellationSignal)) {
+            return;
+        }
+        SavePasswordRequest convertRequestToPlayServices = convertRequestToPlayServices(request);
+        Intent intent = new Intent(this.context, (Class<?>) HiddenActivity.class);
+        intent.putExtra(CredentialProviderBaseController.REQUEST_TAG, convertRequestToPlayServices);
+        generateHiddenActivityIntent(this.resultReceiver, intent, CredentialProviderBaseController.CREATE_PASSWORD_TAG);
+        try {
+            this.context.startActivity(intent);
+        } catch (Exception unused) {
+            CredentialProviderController.cancelOrCallbackExceptionOrResult(cancellationSignal, new CredentialProviderCreatePasswordController$invokePlayServices$1(this));
+        }
+    }
+
+    public final void handleResponse$credentials_play_services_auth_release(int i, int i2) {
+        CredentialProviderBaseController.Companion companion = CredentialProviderBaseController.Companion;
+        if (i != companion.getCONTROLLER_REQUEST_CODE$credentials_play_services_auth_release()) {
+            Log.w(TAG, "Returned request code " + companion.getCONTROLLER_REQUEST_CODE$credentials_play_services_auth_release() + " which does not match what was given " + i);
+            return;
+        }
+        if (CredentialProviderController.maybeReportErrorResultCodeCreate(i2, new Function2() { // from class: androidx.credentials.playservices.controllers.CreatePassword.CredentialProviderCreatePasswordController$handleResponse$1
+            @Override // kotlin.jvm.functions.Function2
+            public /* bridge */ /* synthetic */ Object invoke(Object obj, Object obj2) {
+                invoke((CancellationSignal) obj, (Function0) obj2);
+                return Unit.INSTANCE;
+            }
+
+            public final void invoke(CancellationSignal cancellationSignal, Function0 f) {
+                Intrinsics.checkNotNullParameter(f, "f");
+                CredentialProviderController.Companion companion2 = CredentialProviderController.Companion;
+                CredentialProviderController.cancelOrCallbackExceptionOrResult(cancellationSignal, f);
+            }
+        }, new CredentialProviderCreatePasswordController$handleResponse$2(this), this.cancellationSignal)) {
+            return;
+        }
+        CredentialProviderController.cancelOrCallbackExceptionOrResult(this.cancellationSignal, new CredentialProviderCreatePasswordController$handleResponse$3(this, convertResponseToCredentialManager(Unit.INSTANCE)));
+    }
+
+    @Override // androidx.credentials.playservices.controllers.CredentialProviderController
+    @VisibleForTesting(otherwise = 4)
+    public SavePasswordRequest convertRequestToPlayServices(CreatePasswordRequest request) {
+        Intrinsics.checkNotNullParameter(request, "request");
+        SavePasswordRequest build = SavePasswordRequest.builder().setSignInPassword(new SignInPassword(request.getId(), request.getPassword())).build();
+        Intrinsics.checkNotNullExpressionValue(build, "build(...)");
+        return build;
+    }
+
+    @Override // androidx.credentials.playservices.controllers.CredentialProviderController
+    @VisibleForTesting(otherwise = 4)
+    public CreateCredentialResponse convertResponseToCredentialManager(Unit response) {
+        Intrinsics.checkNotNullParameter(response, "response");
+        return new CreatePasswordResponse();
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final CredentialProviderCreatePasswordController getInstance(Context context) {
+            Intrinsics.checkNotNullParameter(context, "context");
+            return new CredentialProviderCreatePasswordController(context);
+        }
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/CreatePublicKeyCredential/CredentialProviderCreatePublicKeyCredentialController$handleResponse$2.java

@@ -0,0 +1,54 @@
+package androidx.credentials.playservices.controllers.CreatePublicKeyCredential;
+
+import androidx.credentials.CredentialManagerCallback;
+import androidx.credentials.exceptions.CreateCredentialException;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderCreatePublicKeyCredentialController$handleResponse$2 extends Lambda implements Function1 {
+    final /* synthetic */ CredentialProviderCreatePublicKeyCredentialController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderCreatePublicKeyCredentialController$handleResponse$2(CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController) {
+        super(1);
+        this.this$0 = credentialProviderCreatePublicKeyCredentialController;
+    }
+
+    @Override // kotlin.jvm.functions.Function1
+    public /* bridge */ /* synthetic */ Object invoke(Object obj) {
+        invoke((CreateCredentialException) obj);
+        return Unit.INSTANCE;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController, CreateCredentialException createCredentialException) {
+        CredentialManagerCallback credentialManagerCallback;
+        credentialManagerCallback = credentialProviderCreatePublicKeyCredentialController.callback;
+        if (credentialManagerCallback == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("callback");
+            credentialManagerCallback = null;
+        }
+        credentialManagerCallback.onError(createCredentialException);
+    }
+
+    public final void invoke(final CreateCredentialException e) {
+        Executor executor;
+        Intrinsics.checkNotNullParameter(e, "e");
+        executor = this.this$0.executor;
+        if (executor == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("executor");
+            executor = null;
+        }
+        final CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController = this.this$0;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.CreatePublicKeyCredential.CredentialProviderCreatePublicKeyCredentialController$handleResponse$2$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderCreatePublicKeyCredentialController$handleResponse$2.invoke$lambda$0(CredentialProviderCreatePublicKeyCredentialController.this, e);
+            }
+        });
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/CreatePublicKeyCredential/CredentialProviderCreatePublicKeyCredentialController$handleResponse$4.java

@@ -0,0 +1,57 @@
+package androidx.credentials.playservices.controllers.CreatePublicKeyCredential;
+
+import androidx.credentials.CredentialManagerCallback;
+import androidx.credentials.exceptions.CreateCredentialException;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderCreatePublicKeyCredentialController$handleResponse$4 extends Lambda implements Function0 {
+    final /* synthetic */ CreateCredentialException $exception;
+    final /* synthetic */ CredentialProviderCreatePublicKeyCredentialController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderCreatePublicKeyCredentialController$handleResponse$4(CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController, CreateCredentialException createCredentialException) {
+        super(0);
+        this.this$0 = credentialProviderCreatePublicKeyCredentialController;
+        this.$exception = createCredentialException;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m102invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController, CreateCredentialException createCredentialException) {
+        CredentialManagerCallback credentialManagerCallback;
+        credentialManagerCallback = credentialProviderCreatePublicKeyCredentialController.callback;
+        if (credentialManagerCallback == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("callback");
+            credentialManagerCallback = null;
+        }
+        credentialManagerCallback.onError(createCredentialException);
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m102invoke() {
+        Executor executor;
+        executor = this.this$0.executor;
+        if (executor == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("executor");
+            executor = null;
+        }
+        final CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController = this.this$0;
+        final CreateCredentialException createCredentialException = this.$exception;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.CreatePublicKeyCredential.CredentialProviderCreatePublicKeyCredentialController$handleResponse$4$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderCreatePublicKeyCredentialController$handleResponse$4.invoke$lambda$0(CredentialProviderCreatePublicKeyCredentialController.this, createCredentialException);
+            }
+        });
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/CreatePublicKeyCredential/CredentialProviderCreatePublicKeyCredentialController$handleResponse$5.java

@@ -0,0 +1,57 @@
+package androidx.credentials.playservices.controllers.CreatePublicKeyCredential;
+
+import androidx.credentials.CreateCredentialResponse;
+import androidx.credentials.CredentialManagerCallback;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderCreatePublicKeyCredentialController$handleResponse$5 extends Lambda implements Function0 {
+    final /* synthetic */ CreateCredentialResponse $response;
+    final /* synthetic */ CredentialProviderCreatePublicKeyCredentialController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderCreatePublicKeyCredentialController$handleResponse$5(CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController, CreateCredentialResponse createCredentialResponse) {
+        super(0);
+        this.this$0 = credentialProviderCreatePublicKeyCredentialController;
+        this.$response = createCredentialResponse;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m104invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController, CreateCredentialResponse createCredentialResponse) {
+        CredentialManagerCallback credentialManagerCallback;
+        credentialManagerCallback = credentialProviderCreatePublicKeyCredentialController.callback;
+        if (credentialManagerCallback == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("callback");
+            credentialManagerCallback = null;
+        }
+        credentialManagerCallback.onResult(createCredentialResponse);
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m104invoke() {
+        Executor executor;
+        executor = this.this$0.executor;
+        if (executor == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("executor");
+            executor = null;
+        }
+        final CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController = this.this$0;
+        final CreateCredentialResponse createCredentialResponse = this.$response;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.CreatePublicKeyCredential.CredentialProviderCreatePublicKeyCredentialController$handleResponse$5$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderCreatePublicKeyCredentialController$handleResponse$5.invoke$lambda$0(CredentialProviderCreatePublicKeyCredentialController.this, createCredentialResponse);
+            }
+        });
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/CreatePublicKeyCredential/CredentialProviderCreatePublicKeyCredentialController$handleResponse$6.java

@@ -0,0 +1,59 @@
+package androidx.credentials.playservices.controllers.CreatePublicKeyCredential;
+
+import androidx.credentials.CredentialManagerCallback;
+import androidx.credentials.exceptions.domerrors.EncodingError;
+import androidx.credentials.exceptions.publickeycredential.CreatePublicKeyCredentialDomException;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+import org.json.JSONException;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderCreatePublicKeyCredentialController$handleResponse$6 extends Lambda implements Function0 {
+    final /* synthetic */ JSONException $e;
+    final /* synthetic */ CredentialProviderCreatePublicKeyCredentialController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderCreatePublicKeyCredentialController$handleResponse$6(CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController, JSONException jSONException) {
+        super(0);
+        this.this$0 = credentialProviderCreatePublicKeyCredentialController;
+        this.$e = jSONException;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m106invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m106invoke() {
+        Executor executor;
+        executor = this.this$0.executor;
+        if (executor == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("executor");
+            executor = null;
+        }
+        final CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController = this.this$0;
+        final JSONException jSONException = this.$e;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.CreatePublicKeyCredential.CredentialProviderCreatePublicKeyCredentialController$handleResponse$6$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderCreatePublicKeyCredentialController$handleResponse$6.invoke$lambda$0(CredentialProviderCreatePublicKeyCredentialController.this, jSONException);
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController, JSONException jSONException) {
+        CredentialManagerCallback credentialManagerCallback;
+        credentialManagerCallback = credentialProviderCreatePublicKeyCredentialController.callback;
+        if (credentialManagerCallback == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("callback");
+            credentialManagerCallback = null;
+        }
+        credentialManagerCallback.onError(new CreatePublicKeyCredentialDomException(new EncodingError(), jSONException.getMessage()));
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/CreatePublicKeyCredential/CredentialProviderCreatePublicKeyCredentialController$handleResponse$7.java

@@ -0,0 +1,58 @@
+package androidx.credentials.playservices.controllers.CreatePublicKeyCredential;
+
+import androidx.credentials.CredentialManagerCallback;
+import androidx.credentials.exceptions.domerrors.UnknownError;
+import androidx.credentials.exceptions.publickeycredential.CreatePublicKeyCredentialDomException;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderCreatePublicKeyCredentialController$handleResponse$7 extends Lambda implements Function0 {
+    final /* synthetic */ Throwable $t;
+    final /* synthetic */ CredentialProviderCreatePublicKeyCredentialController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderCreatePublicKeyCredentialController$handleResponse$7(CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController, Throwable th) {
+        super(0);
+        this.this$0 = credentialProviderCreatePublicKeyCredentialController;
+        this.$t = th;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m107invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m107invoke() {
+        Executor executor;
+        executor = this.this$0.executor;
+        if (executor == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("executor");
+            executor = null;
+        }
+        final CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController = this.this$0;
+        final Throwable th = this.$t;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.CreatePublicKeyCredential.CredentialProviderCreatePublicKeyCredentialController$handleResponse$7$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderCreatePublicKeyCredentialController$handleResponse$7.invoke$lambda$0(CredentialProviderCreatePublicKeyCredentialController.this, th);
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController, Throwable th) {
+        CredentialManagerCallback credentialManagerCallback;
+        credentialManagerCallback = credentialProviderCreatePublicKeyCredentialController.callback;
+        if (credentialManagerCallback == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("callback");
+            credentialManagerCallback = null;
+        }
+        credentialManagerCallback.onError(new CreatePublicKeyCredentialDomException(new UnknownError(), th.getMessage()));
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/CreatePublicKeyCredential/CredentialProviderCreatePublicKeyCredentialController$invokePlayServices$1.java

@@ -0,0 +1,60 @@
+package androidx.credentials.playservices.controllers.CreatePublicKeyCredential;
+
+import androidx.credentials.CredentialManagerCallback;
+import androidx.credentials.exceptions.publickeycredential.CreatePublicKeyCredentialDomException;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+import org.json.JSONException;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderCreatePublicKeyCredentialController$invokePlayServices$1 extends Lambda implements Function0 {
+    final /* synthetic */ JSONException $e;
+    final /* synthetic */ CredentialProviderCreatePublicKeyCredentialController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderCreatePublicKeyCredentialController$invokePlayServices$1(CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController, JSONException jSONException) {
+        super(0);
+        this.this$0 = credentialProviderCreatePublicKeyCredentialController;
+        this.$e = jSONException;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m108invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController, JSONException jSONException) {
+        CredentialManagerCallback credentialManagerCallback;
+        CreatePublicKeyCredentialDomException JSONExceptionToPKCError;
+        credentialManagerCallback = credentialProviderCreatePublicKeyCredentialController.callback;
+        if (credentialManagerCallback == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("callback");
+            credentialManagerCallback = null;
+        }
+        JSONExceptionToPKCError = credentialProviderCreatePublicKeyCredentialController.JSONExceptionToPKCError(jSONException);
+        credentialManagerCallback.onError(JSONExceptionToPKCError);
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m108invoke() {
+        Executor executor;
+        executor = this.this$0.executor;
+        if (executor == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("executor");
+            executor = null;
+        }
+        final CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController = this.this$0;
+        final JSONException jSONException = this.$e;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.CreatePublicKeyCredential.CredentialProviderCreatePublicKeyCredentialController$invokePlayServices$1$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderCreatePublicKeyCredentialController$invokePlayServices$1.invoke$lambda$0(CredentialProviderCreatePublicKeyCredentialController.this, jSONException);
+            }
+        });
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/CreatePublicKeyCredential/CredentialProviderCreatePublicKeyCredentialController$invokePlayServices$2.java

@@ -0,0 +1,57 @@
+package androidx.credentials.playservices.controllers.CreatePublicKeyCredential;
+
+import androidx.credentials.CredentialManagerCallback;
+import androidx.credentials.exceptions.CreateCredentialUnknownException;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderCreatePublicKeyCredentialController$invokePlayServices$2 extends Lambda implements Function0 {
+    final /* synthetic */ Throwable $t;
+    final /* synthetic */ CredentialProviderCreatePublicKeyCredentialController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderCreatePublicKeyCredentialController$invokePlayServices$2(CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController, Throwable th) {
+        super(0);
+        this.this$0 = credentialProviderCreatePublicKeyCredentialController;
+        this.$t = th;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m110invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m110invoke() {
+        Executor executor;
+        executor = this.this$0.executor;
+        if (executor == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("executor");
+            executor = null;
+        }
+        final CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController = this.this$0;
+        final Throwable th = this.$t;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.CreatePublicKeyCredential.CredentialProviderCreatePublicKeyCredentialController$invokePlayServices$2$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderCreatePublicKeyCredentialController$invokePlayServices$2.invoke$lambda$0(CredentialProviderCreatePublicKeyCredentialController.this, th);
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController, Throwable th) {
+        CredentialManagerCallback credentialManagerCallback;
+        credentialManagerCallback = credentialProviderCreatePublicKeyCredentialController.callback;
+        if (credentialManagerCallback == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("callback");
+            credentialManagerCallback = null;
+        }
+        credentialManagerCallback.onError(new CreateCredentialUnknownException(th.getMessage()));
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/CreatePublicKeyCredential/CredentialProviderCreatePublicKeyCredentialController$invokePlayServices$3.java

@@ -0,0 +1,55 @@
+package androidx.credentials.playservices.controllers.CreatePublicKeyCredential;
+
+import androidx.credentials.CredentialManagerCallback;
+import androidx.credentials.exceptions.CreateCredentialUnknownException;
+import androidx.credentials.playservices.controllers.CredentialProviderController;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderCreatePublicKeyCredentialController$invokePlayServices$3 extends Lambda implements Function0 {
+    final /* synthetic */ CredentialProviderCreatePublicKeyCredentialController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderCreatePublicKeyCredentialController$invokePlayServices$3(CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController) {
+        super(0);
+        this.this$0 = credentialProviderCreatePublicKeyCredentialController;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m112invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m112invoke() {
+        Executor executor;
+        executor = this.this$0.executor;
+        if (executor == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("executor");
+            executor = null;
+        }
+        final CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController = this.this$0;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.CreatePublicKeyCredential.CredentialProviderCreatePublicKeyCredentialController$invokePlayServices$3$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderCreatePublicKeyCredentialController$invokePlayServices$3.invoke$lambda$0(CredentialProviderCreatePublicKeyCredentialController.this);
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController) {
+        CredentialManagerCallback credentialManagerCallback;
+        credentialManagerCallback = credentialProviderCreatePublicKeyCredentialController.callback;
+        if (credentialManagerCallback == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("callback");
+            credentialManagerCallback = null;
+        }
+        credentialManagerCallback.onError(new CreateCredentialUnknownException(CredentialProviderController.ERROR_MESSAGE_START_ACTIVITY_FAILED));
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/CreatePublicKeyCredential/CredentialProviderCreatePublicKeyCredentialController$resultReceiver$1$onReceiveResult$1.java

@@ -0,0 +1,18 @@
+package androidx.credentials.playservices.controllers.CreatePublicKeyCredential;
+
+import androidx.credentials.exceptions.CreateCredentialException;
+import androidx.credentials.playservices.controllers.CredentialProviderBaseController;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.FunctionReferenceImpl;
+
+/* loaded from: classes.dex */
+public /* synthetic */ class CredentialProviderCreatePublicKeyCredentialController$resultReceiver$1$onReceiveResult$1 extends FunctionReferenceImpl implements Function2 {
+    public CredentialProviderCreatePublicKeyCredentialController$resultReceiver$1$onReceiveResult$1(Object obj) {
+        super(2, obj, CredentialProviderBaseController.Companion.class, "createCredentialExceptionTypeToException", "createCredentialExceptionTypeToException$credentials_play_services_auth_release(Ljava/lang/String;Ljava/lang/String;)Landroidx/credentials/exceptions/CreateCredentialException;", 0);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final CreateCredentialException invoke(String str, String str2) {
+        return ((CredentialProviderBaseController.Companion) this.receiver).createCredentialExceptionTypeToException$credentials_play_services_auth_release(str, str2);
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/CreatePublicKeyCredential/CredentialProviderCreatePublicKeyCredentialController.java

@@ -0,0 +1,242 @@
+package androidx.credentials.playservices.controllers.CreatePublicKeyCredential;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.CancellationSignal;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.ResultReceiver;
+import android.util.Log;
+import androidx.annotation.VisibleForTesting;
+import androidx.credentials.CreateCredentialResponse;
+import androidx.credentials.CreatePublicKeyCredentialRequest;
+import androidx.credentials.CreatePublicKeyCredentialResponse;
+import androidx.credentials.CredentialManagerCallback;
+import androidx.credentials.exceptions.CreateCredentialException;
+import androidx.credentials.exceptions.CreateCredentialUnknownException;
+import androidx.credentials.exceptions.domerrors.EncodingError;
+import androidx.credentials.exceptions.domerrors.UnknownError;
+import androidx.credentials.exceptions.publickeycredential.CreatePublicKeyCredentialDomException;
+import androidx.credentials.playservices.CredentialProviderPlayServicesImpl;
+import androidx.credentials.playservices.HiddenActivity;
+import androidx.credentials.playservices.controllers.CredentialProviderBaseController;
+import androidx.credentials.playservices.controllers.CredentialProviderController;
+import com.google.android.gms.fido.Fido;
+import com.google.android.gms.fido.fido2.api.common.PublicKeyCredential;
+import com.google.android.gms.fido.fido2.api.common.PublicKeyCredentialCreationOptions;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import org.json.JSONException;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderCreatePublicKeyCredentialController extends CredentialProviderController<CreatePublicKeyCredentialRequest, PublicKeyCredentialCreationOptions, PublicKeyCredential, CreateCredentialResponse, CreateCredentialException> {
+    public static final Companion Companion = new Companion(null);
+    private static final String TAG = "CreatePublicKey";
+    private CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException> callback;
+    private CancellationSignal cancellationSignal;
+    private final Context context;
+    private Executor executor;
+    private final CredentialProviderCreatePublicKeyCredentialController$resultReceiver$1 resultReceiver;
+
+    @VisibleForTesting(otherwise = 2)
+    private static /* synthetic */ void getCallback$annotations() {
+    }
+
+    @VisibleForTesting(otherwise = 2)
+    private static /* synthetic */ void getCancellationSignal$annotations() {
+    }
+
+    @VisibleForTesting(otherwise = 2)
+    private static /* synthetic */ void getExecutor$annotations() {
+    }
+
+    public static final CredentialProviderCreatePublicKeyCredentialController getInstance(Context context) {
+        return Companion.getInstance(context);
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    /* JADX WARN: Type inference failed for: r0v2, types: [androidx.credentials.playservices.controllers.CreatePublicKeyCredential.CredentialProviderCreatePublicKeyCredentialController$resultReceiver$1] */
+    public CredentialProviderCreatePublicKeyCredentialController(Context context) {
+        super(context);
+        Intrinsics.checkNotNullParameter(context, "context");
+        this.context = context;
+        final Handler handler = new Handler(Looper.getMainLooper());
+        this.resultReceiver = new ResultReceiver(handler) { // from class: androidx.credentials.playservices.controllers.CreatePublicKeyCredential.CredentialProviderCreatePublicKeyCredentialController$resultReceiver$1
+            @Override // android.os.ResultReceiver
+            public void onReceiveResult(int i, Bundle resultData) {
+                Executor executor;
+                Executor executor2;
+                CredentialManagerCallback credentialManagerCallback;
+                CredentialManagerCallback credentialManagerCallback2;
+                CancellationSignal cancellationSignal;
+                boolean maybeReportErrorFromResultReceiver;
+                Intrinsics.checkNotNullParameter(resultData, "resultData");
+                CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController = CredentialProviderCreatePublicKeyCredentialController.this;
+                CredentialProviderCreatePublicKeyCredentialController$resultReceiver$1$onReceiveResult$1 credentialProviderCreatePublicKeyCredentialController$resultReceiver$1$onReceiveResult$1 = new CredentialProviderCreatePublicKeyCredentialController$resultReceiver$1$onReceiveResult$1(CredentialProviderBaseController.Companion);
+                executor = CredentialProviderCreatePublicKeyCredentialController.this.executor;
+                if (executor == null) {
+                    Intrinsics.throwUninitializedPropertyAccessException("executor");
+                    executor2 = null;
+                } else {
+                    executor2 = executor;
+                }
+                credentialManagerCallback = CredentialProviderCreatePublicKeyCredentialController.this.callback;
+                if (credentialManagerCallback == null) {
+                    Intrinsics.throwUninitializedPropertyAccessException("callback");
+                    credentialManagerCallback2 = null;
+                } else {
+                    credentialManagerCallback2 = credentialManagerCallback;
+                }
+                cancellationSignal = CredentialProviderCreatePublicKeyCredentialController.this.cancellationSignal;
+                maybeReportErrorFromResultReceiver = credentialProviderCreatePublicKeyCredentialController.maybeReportErrorFromResultReceiver(resultData, credentialProviderCreatePublicKeyCredentialController$resultReceiver$1$onReceiveResult$1, executor2, credentialManagerCallback2, cancellationSignal);
+                if (maybeReportErrorFromResultReceiver) {
+                    return;
+                }
+                CredentialProviderCreatePublicKeyCredentialController.this.handleResponse$credentials_play_services_auth_release(resultData.getInt(CredentialProviderBaseController.ACTIVITY_REQUEST_CODE_TAG), i, (Intent) resultData.getParcelable(CredentialProviderBaseController.RESULT_DATA_TAG));
+            }
+        };
+    }
+
+    @Override // androidx.credentials.playservices.controllers.CredentialProviderController
+    public void invokePlayServices(CreatePublicKeyCredentialRequest request, CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException> callback, Executor executor, CancellationSignal cancellationSignal) {
+        Intrinsics.checkNotNullParameter(request, "request");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        Intrinsics.checkNotNullParameter(executor, "executor");
+        this.cancellationSignal = cancellationSignal;
+        this.callback = callback;
+        this.executor = executor;
+        try {
+            PublicKeyCredentialCreationOptions convertRequestToPlayServices = convertRequestToPlayServices(request);
+            if (CredentialProviderPlayServicesImpl.Companion.cancellationReviewer$credentials_play_services_auth_release(cancellationSignal)) {
+                return;
+            }
+            Intent intent = new Intent(this.context, (Class<?>) HiddenActivity.class);
+            intent.putExtra(CredentialProviderBaseController.REQUEST_TAG, convertRequestToPlayServices);
+            generateHiddenActivityIntent(this.resultReceiver, intent, CredentialProviderBaseController.CREATE_PUBLIC_KEY_CREDENTIAL_TAG);
+            try {
+                this.context.startActivity(intent);
+            } catch (Exception unused) {
+                CredentialProviderController.cancelOrCallbackExceptionOrResult(cancellationSignal, new CredentialProviderCreatePublicKeyCredentialController$invokePlayServices$3(this));
+            }
+        } catch (JSONException e) {
+            CredentialProviderController.cancelOrCallbackExceptionOrResult(cancellationSignal, new CredentialProviderCreatePublicKeyCredentialController$invokePlayServices$1(this, e));
+        } catch (Throwable th) {
+            CredentialProviderController.cancelOrCallbackExceptionOrResult(cancellationSignal, new CredentialProviderCreatePublicKeyCredentialController$invokePlayServices$2(this, th));
+        }
+    }
+
+    public final void handleResponse$credentials_play_services_auth_release(int i, int i2, Intent intent) {
+        CredentialProviderBaseController.Companion companion = CredentialProviderBaseController.Companion;
+        if (i != companion.getCONTROLLER_REQUEST_CODE$credentials_play_services_auth_release()) {
+            Log.w(TAG, "Returned request code " + companion.getCONTROLLER_REQUEST_CODE$credentials_play_services_auth_release() + " does not match what was given " + i);
+            return;
+        }
+        if (CredentialProviderController.maybeReportErrorResultCodeCreate(i2, new Function2() { // from class: androidx.credentials.playservices.controllers.CreatePublicKeyCredential.CredentialProviderCreatePublicKeyCredentialController$handleResponse$1
+            @Override // kotlin.jvm.functions.Function2
+            public /* bridge */ /* synthetic */ Object invoke(Object obj, Object obj2) {
+                invoke((CancellationSignal) obj, (Function0) obj2);
+                return Unit.INSTANCE;
+            }
+
+            public final void invoke(CancellationSignal cancellationSignal, Function0 f) {
+                Intrinsics.checkNotNullParameter(f, "f");
+                CredentialProviderController.Companion companion2 = CredentialProviderController.Companion;
+                CredentialProviderController.cancelOrCallbackExceptionOrResult(cancellationSignal, f);
+            }
+        }, new CredentialProviderCreatePublicKeyCredentialController$handleResponse$2(this), this.cancellationSignal)) {
+            return;
+        }
+        Executor executor = null;
+        byte[] byteArrayExtra = intent != null ? intent.getByteArrayExtra(Fido.FIDO2_KEY_CREDENTIAL_EXTRA) : null;
+        if (byteArrayExtra == null) {
+            if (CredentialProviderPlayServicesImpl.Companion.cancellationReviewer$credentials_play_services_auth_release(this.cancellationSignal)) {
+                return;
+            }
+            Executor executor2 = this.executor;
+            if (executor2 == null) {
+                Intrinsics.throwUninitializedPropertyAccessException("executor");
+            } else {
+                executor = executor2;
+            }
+            executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.CreatePublicKeyCredential.CredentialProviderCreatePublicKeyCredentialController$$ExternalSyntheticLambda0
+                @Override // java.lang.Runnable
+                public final void run() {
+                    CredentialProviderCreatePublicKeyCredentialController.handleResponse$lambda$0(CredentialProviderCreatePublicKeyCredentialController.this);
+                }
+            });
+            return;
+        }
+        PublicKeyCredential deserializeFromBytes = PublicKeyCredential.deserializeFromBytes(byteArrayExtra);
+        Intrinsics.checkNotNullExpressionValue(deserializeFromBytes, "deserializeFromBytes(...)");
+        CreateCredentialException publicKeyCredentialResponseContainsError = PublicKeyCredentialControllerUtility.Companion.publicKeyCredentialResponseContainsError(deserializeFromBytes);
+        if (publicKeyCredentialResponseContainsError != null) {
+            CredentialProviderController.cancelOrCallbackExceptionOrResult(this.cancellationSignal, new CredentialProviderCreatePublicKeyCredentialController$handleResponse$4(this, publicKeyCredentialResponseContainsError));
+            return;
+        }
+        try {
+            CredentialProviderController.cancelOrCallbackExceptionOrResult(this.cancellationSignal, new CredentialProviderCreatePublicKeyCredentialController$handleResponse$5(this, convertResponseToCredentialManager(deserializeFromBytes)));
+        } catch (JSONException e) {
+            CredentialProviderController.cancelOrCallbackExceptionOrResult(this.cancellationSignal, new CredentialProviderCreatePublicKeyCredentialController$handleResponse$6(this, e));
+        } catch (Throwable th) {
+            CredentialProviderController.cancelOrCallbackExceptionOrResult(this.cancellationSignal, new CredentialProviderCreatePublicKeyCredentialController$handleResponse$7(this, th));
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void handleResponse$lambda$0(CredentialProviderCreatePublicKeyCredentialController credentialProviderCreatePublicKeyCredentialController) {
+        CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException> credentialManagerCallback = credentialProviderCreatePublicKeyCredentialController.callback;
+        if (credentialManagerCallback == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("callback");
+            credentialManagerCallback = null;
+        }
+        credentialManagerCallback.onError(new CreatePublicKeyCredentialDomException(new UnknownError(), "Upon handling create public key credential response, fido module giving null bytes indicating internal error"));
+    }
+
+    @Override // androidx.credentials.playservices.controllers.CredentialProviderController
+    @VisibleForTesting(otherwise = 4)
+    public PublicKeyCredentialCreationOptions convertRequestToPlayServices(CreatePublicKeyCredentialRequest request) {
+        Intrinsics.checkNotNullParameter(request, "request");
+        return PublicKeyCredentialControllerUtility.Companion.convert(request, this.context);
+    }
+
+    @Override // androidx.credentials.playservices.controllers.CredentialProviderController
+    @VisibleForTesting(otherwise = 4)
+    public CreateCredentialResponse convertResponseToCredentialManager(PublicKeyCredential response) {
+        Intrinsics.checkNotNullParameter(response, "response");
+        try {
+            String json = response.toJson();
+            Intrinsics.checkNotNullExpressionValue(json, "toJson(...)");
+            return new CreatePublicKeyCredentialResponse(json);
+        } catch (Throwable th) {
+            throw new CreateCredentialUnknownException("The PublicKeyCredential response json had an unexpected exception when parsing: " + th.getMessage());
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final CreatePublicKeyCredentialDomException JSONExceptionToPKCError(JSONException jSONException) {
+        String message = jSONException.getMessage();
+        if (message != null && message.length() > 0) {
+            return new CreatePublicKeyCredentialDomException(new EncodingError(), message);
+        }
+        return new CreatePublicKeyCredentialDomException(new EncodingError(), "Unknown error");
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final CredentialProviderCreatePublicKeyCredentialController getInstance(Context context) {
+            Intrinsics.checkNotNullParameter(context, "context");
+            return new CredentialProviderCreatePublicKeyCredentialController(context);
+        }
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/CreatePublicKeyCredential/PublicKeyCredentialControllerUtility$GetGMSVersion$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.credentials.playservices.controllers.CreatePublicKeyCredential;
+
+/* loaded from: classes.dex */
+public final /* synthetic */ class PublicKeyCredentialControllerUtility$GetGMSVersion$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/credentials/playservices/controllers/CreatePublicKeyCredential/PublicKeyCredentialControllerUtility.java

@@ -0,0 +1,618 @@
+package androidx.credentials.playservices.controllers.CreatePublicKeyCredential;
+
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.util.Base64;
+import android.util.Log;
+import androidx.annotation.RequiresApi;
+import androidx.credentials.CreatePublicKeyCredentialRequest;
+import androidx.credentials.GetPublicKeyCredentialOption;
+import androidx.credentials.exceptions.CreateCredentialCancellationException;
+import androidx.credentials.exceptions.CreateCredentialException;
+import androidx.credentials.exceptions.GetCredentialCancellationException;
+import androidx.credentials.exceptions.GetCredentialException;
+import androidx.credentials.exceptions.GetCredentialUnknownException;
+import androidx.credentials.exceptions.domerrors.AbortError;
+import androidx.credentials.exceptions.domerrors.ConstraintError;
+import androidx.credentials.exceptions.domerrors.DataError;
+import androidx.credentials.exceptions.domerrors.DomError;
+import androidx.credentials.exceptions.domerrors.EncodingError;
+import androidx.credentials.exceptions.domerrors.InvalidStateError;
+import androidx.credentials.exceptions.domerrors.NetworkError;
+import androidx.credentials.exceptions.domerrors.NotAllowedError;
+import androidx.credentials.exceptions.domerrors.NotReadableError;
+import androidx.credentials.exceptions.domerrors.NotSupportedError;
+import androidx.credentials.exceptions.domerrors.SecurityError;
+import androidx.credentials.exceptions.domerrors.TimeoutError;
+import androidx.credentials.exceptions.domerrors.UnknownError;
+import androidx.credentials.exceptions.publickeycredential.CreatePublicKeyCredentialDomException;
+import androidx.credentials.exceptions.publickeycredential.GetPublicKeyCredentialDomException;
+import com.google.android.gms.auth.api.identity.BeginSignInRequest;
+import com.google.android.gms.auth.api.identity.SignInCredential;
+import com.google.android.gms.common.GoogleApiAvailability;
+import com.google.android.gms.fido.common.Transport;
+import com.google.android.gms.fido.fido2.api.common.Attachment;
+import com.google.android.gms.fido.fido2.api.common.AttestationConveyancePreference;
+import com.google.android.gms.fido.fido2.api.common.AuthenticationExtensions;
+import com.google.android.gms.fido.fido2.api.common.AuthenticatorAssertionResponse;
+import com.google.android.gms.fido.fido2.api.common.AuthenticatorErrorResponse;
+import com.google.android.gms.fido.fido2.api.common.AuthenticatorResponse;
+import com.google.android.gms.fido.fido2.api.common.AuthenticatorSelectionCriteria;
+import com.google.android.gms.fido.fido2.api.common.COSEAlgorithmIdentifier;
+import com.google.android.gms.fido.fido2.api.common.ErrorCode;
+import com.google.android.gms.fido.fido2.api.common.FidoAppIdExtension;
+import com.google.android.gms.fido.fido2.api.common.GoogleThirdPartyPaymentExtension;
+import com.google.android.gms.fido.fido2.api.common.PublicKeyCredential;
+import com.google.android.gms.fido.fido2.api.common.PublicKeyCredentialCreationOptions;
+import com.google.android.gms.fido.fido2.api.common.PublicKeyCredentialDescriptor;
+import com.google.android.gms.fido.fido2.api.common.PublicKeyCredentialParameters;
+import com.google.android.gms.fido.fido2.api.common.PublicKeyCredentialRpEntity;
+import com.google.android.gms.fido.fido2.api.common.PublicKeyCredentialUserEntity;
+import com.google.android.gms.fido.fido2.api.common.ResidentKeyRequirement;
+import com.google.android.gms.fido.fido2.api.common.UserVerificationMethodExtension;
+import com.google.android.gms.fido.u2f.api.common.ClientData;
+import com.ironsource.cr;
+import com.unity3d.ads.metadata.InAppPurchaseMetaData;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import kotlin.TuplesKt;
+import kotlin.collections.MapsKt__MapsKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.StringsKt__StringsKt;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes.dex */
+public final class PublicKeyCredentialControllerUtility {
+    private static final long AUTH_MIN_VERSION_JSON_CREATE = 241217000;
+    private static final int FLAGS = 11;
+    private static final String TAG = "PublicKeyUtility";
+    private static final LinkedHashMap<ErrorCode, DomError> orderedErrorCodeToExceptions;
+    public static final Companion Companion = new Companion(null);
+    private static final String JSON_KEY_CLIENT_DATA = "clientDataJSON";
+    private static final String JSON_KEY_ATTESTATION_OBJ = "attestationObject";
+    private static final String JSON_KEY_AUTH_DATA = "authenticatorData";
+    private static final String JSON_KEY_SIGNATURE = InAppPurchaseMetaData.KEY_SIGNATURE;
+    private static final String JSON_KEY_USER_HANDLE = "userHandle";
+    private static final String JSON_KEY_RESPONSE = cr.n;
+    private static final String JSON_KEY_ID = "id";
+    private static final String JSON_KEY_RAW_ID = "rawId";
+    private static final String JSON_KEY_TYPE = "type";
+    private static final String JSON_KEY_RPID = "rpId";
+    private static final String JSON_KEY_CHALLENGE = ClientData.KEY_CHALLENGE;
+    private static final String JSON_KEY_APPID = "appid";
+    private static final String JSON_KEY_THIRD_PARTY_PAYMENT = "thirdPartyPayment";
+    private static final String JSON_KEY_AUTH_SELECTION = "authenticatorSelection";
+    private static final String JSON_KEY_REQUIRE_RES_KEY = "requireResidentKey";
+    private static final String JSON_KEY_RES_KEY = "residentKey";
+    private static final String JSON_KEY_AUTH_ATTACHMENT = "authenticatorAttachment";
+    private static final String JSON_KEY_TIMEOUT = "timeout";
+    private static final String JSON_KEY_EXCLUDE_CREDENTIALS = "excludeCredentials";
+    private static final String JSON_KEY_TRANSPORTS = "transports";
+    private static final String JSON_KEY_RP = "rp";
+    private static final String JSON_KEY_NAME = "name";
+    private static final String JSON_KEY_ICON = "icon";
+    private static final String JSON_KEY_ALG = "alg";
+    private static final String JSON_KEY_USER = "user";
+    private static final String JSON_KEY_DISPLAY_NAME = "displayName";
+    private static final String JSON_KEY_USER_VERIFICATION_METHOD = "userVerificationMethod";
+    private static final String JSON_KEY_KEY_PROTECTION_TYPE = "keyProtectionType";
+    private static final String JSON_KEY_MATCHER_PROTECTION_TYPE = "matcherProtectionType";
+    private static final String JSON_KEY_EXTENSTIONS = "extensions";
+    private static final String JSON_KEY_ATTESTATION = "attestation";
+    private static final String JSON_KEY_PUB_KEY_CRED_PARAMS = "pubKeyCredParams";
+    private static final String JSON_KEY_CLIENT_EXTENSION_RESULTS = "clientExtensionResults";
+    private static final String JSON_KEY_RK = "rk";
+    private static final String JSON_KEY_CRED_PROPS = "credProps";
+
+    public static final PublicKeyCredentialCreationOptions convert(CreatePublicKeyCredentialRequest createPublicKeyCredentialRequest, Context context) {
+        return Companion.convert(createPublicKeyCredentialRequest, context);
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final String getJSON_KEY_CLIENT_DATA$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_CLIENT_DATA;
+        }
+
+        public final String getJSON_KEY_ATTESTATION_OBJ$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_ATTESTATION_OBJ;
+        }
+
+        public final String getJSON_KEY_AUTH_DATA$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_AUTH_DATA;
+        }
+
+        public final String getJSON_KEY_SIGNATURE$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_SIGNATURE;
+        }
+
+        public final String getJSON_KEY_USER_HANDLE$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_USER_HANDLE;
+        }
+
+        public final String getJSON_KEY_RESPONSE$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_RESPONSE;
+        }
+
+        public final String getJSON_KEY_ID$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_ID;
+        }
+
+        public final String getJSON_KEY_RAW_ID$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_RAW_ID;
+        }
+
+        public final String getJSON_KEY_TYPE$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_TYPE;
+        }
+
+        public final String getJSON_KEY_RPID$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_RPID;
+        }
+
+        public final String getJSON_KEY_CHALLENGE$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_CHALLENGE;
+        }
+
+        public final String getJSON_KEY_APPID$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_APPID;
+        }
+
+        public final String getJSON_KEY_THIRD_PARTY_PAYMENT$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_THIRD_PARTY_PAYMENT;
+        }
+
+        public final String getJSON_KEY_AUTH_SELECTION$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_AUTH_SELECTION;
+        }
+
+        public final String getJSON_KEY_REQUIRE_RES_KEY$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_REQUIRE_RES_KEY;
+        }
+
+        public final String getJSON_KEY_RES_KEY$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_RES_KEY;
+        }
+
+        public final String getJSON_KEY_AUTH_ATTACHMENT$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_AUTH_ATTACHMENT;
+        }
+
+        public final String getJSON_KEY_TIMEOUT$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_TIMEOUT;
+        }
+
+        public final String getJSON_KEY_EXCLUDE_CREDENTIALS$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_EXCLUDE_CREDENTIALS;
+        }
+
+        public final String getJSON_KEY_TRANSPORTS$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_TRANSPORTS;
+        }
+
+        public final String getJSON_KEY_RP$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_RP;
+        }
+
+        public final String getJSON_KEY_NAME$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_NAME;
+        }
+
+        public final String getJSON_KEY_ICON$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_ICON;
+        }
+
+        public final String getJSON_KEY_ALG$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_ALG;
+        }
+
+        public final String getJSON_KEY_USER$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_USER;
+        }
+
+        public final String getJSON_KEY_DISPLAY_NAME$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_DISPLAY_NAME;
+        }
+
+        public final String getJSON_KEY_USER_VERIFICATION_METHOD$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_USER_VERIFICATION_METHOD;
+        }
+
+        public final String getJSON_KEY_KEY_PROTECTION_TYPE$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_KEY_PROTECTION_TYPE;
+        }
+
+        public final String getJSON_KEY_MATCHER_PROTECTION_TYPE$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_MATCHER_PROTECTION_TYPE;
+        }
+
+        public final String getJSON_KEY_EXTENSTIONS$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_EXTENSTIONS;
+        }
+
+        public final String getJSON_KEY_ATTESTATION$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_ATTESTATION;
+        }
+
+        public final String getJSON_KEY_PUB_KEY_CRED_PARAMS$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_PUB_KEY_CRED_PARAMS;
+        }
+
+        public final String getJSON_KEY_CLIENT_EXTENSION_RESULTS$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_CLIENT_EXTENSION_RESULTS;
+        }
+
+        public final String getJSON_KEY_RK$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_RK;
+        }
+
+        public final String getJSON_KEY_CRED_PROPS$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.JSON_KEY_CRED_PROPS;
+        }
+
+        public final PublicKeyCredentialCreationOptions convert(CreatePublicKeyCredentialRequest request, Context context) {
+            Intrinsics.checkNotNullParameter(request, "request");
+            Intrinsics.checkNotNullParameter(context, "context");
+            if (isDeviceGMSVersionOlderThan(context, PublicKeyCredentialControllerUtility.AUTH_MIN_VERSION_JSON_CREATE)) {
+                return new PublicKeyCredentialCreationOptions(request.getRequestJson());
+            }
+            return convertJSON$credentials_play_services_auth_release(new JSONObject(request.getRequestJson()));
+        }
+
+        private final boolean isDeviceGMSVersionOlderThan(Context context, long j) {
+            long j2;
+            if (GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(context) != 0) {
+                return false;
+            }
+            PackageManager packageManager = context.getPackageManager();
+            Intrinsics.checkNotNullExpressionValue(packageManager, "getPackageManager(...)");
+            if (Build.VERSION.SDK_INT >= 28) {
+                PackageInfo packageInfo = packageManager.getPackageInfo("com.google.android.gms", 0);
+                Intrinsics.checkNotNullExpressionValue(packageInfo, "getPackageInfo(...)");
+                j2 = GetGMSVersion.getVersionLong(packageInfo);
+            } else {
+                j2 = packageManager.getPackageInfo("com.google.android.gms", 0).versionCode;
+            }
+            return j2 > j;
+        }
+
+        public final PublicKeyCredentialCreationOptions convertJSON$credentials_play_services_auth_release(JSONObject json) {
+            Intrinsics.checkNotNullParameter(json, "json");
+            PublicKeyCredentialCreationOptions.Builder builder = new PublicKeyCredentialCreationOptions.Builder();
+            parseRequiredChallengeAndUser$credentials_play_services_auth_release(json, builder);
+            parseRequiredRpAndParams$credentials_play_services_auth_release(json, builder);
+            parseOptionalWithRequiredDefaultsAttestationAndExcludeCredentials$credentials_play_services_auth_release(json, builder);
+            parseOptionalTimeout$credentials_play_services_auth_release(json, builder);
+            parseOptionalAuthenticatorSelection$credentials_play_services_auth_release(json, builder);
+            parseOptionalExtensions$credentials_play_services_auth_release(json, builder);
+            PublicKeyCredentialCreationOptions build = builder.build();
+            Intrinsics.checkNotNullExpressionValue(build, "build(...)");
+            return build;
+        }
+
+        public final void addAuthenticatorAttestationResponse$credentials_play_services_auth_release(byte[] clientDataJSON, byte[] attestationObject, String[] transportArray, JSONObject json) {
+            Intrinsics.checkNotNullParameter(clientDataJSON, "clientDataJSON");
+            Intrinsics.checkNotNullParameter(attestationObject, "attestationObject");
+            Intrinsics.checkNotNullParameter(transportArray, "transportArray");
+            Intrinsics.checkNotNullParameter(json, "json");
+            JSONObject jSONObject = new JSONObject();
+            jSONObject.put(getJSON_KEY_CLIENT_DATA$credentials_play_services_auth_release(), b64Encode(clientDataJSON));
+            jSONObject.put(getJSON_KEY_ATTESTATION_OBJ$credentials_play_services_auth_release(), b64Encode(attestationObject));
+            jSONObject.put(getJSON_KEY_TRANSPORTS$credentials_play_services_auth_release(), new JSONArray(transportArray));
+            json.put(getJSON_KEY_RESPONSE$credentials_play_services_auth_release(), jSONObject);
+        }
+
+        public final String toAssertPasskeyResponse(SignInCredential cred) {
+            Intrinsics.checkNotNullParameter(cred, "cred");
+            JSONObject jSONObject = new JSONObject();
+            PublicKeyCredential publicKeyCredential = cred.getPublicKeyCredential();
+            AuthenticatorResponse response = publicKeyCredential != null ? publicKeyCredential.getResponse() : null;
+            Intrinsics.checkNotNull(response);
+            if (response instanceof AuthenticatorErrorResponse) {
+                AuthenticatorErrorResponse authenticatorErrorResponse = (AuthenticatorErrorResponse) response;
+                ErrorCode errorCode = authenticatorErrorResponse.getErrorCode();
+                Intrinsics.checkNotNullExpressionValue(errorCode, "getErrorCode(...)");
+                throw beginSignInPublicKeyCredentialResponseContainsError$credentials_play_services_auth_release(errorCode, authenticatorErrorResponse.getErrorMessage());
+            }
+            if (response instanceof AuthenticatorAssertionResponse) {
+                try {
+                    String json = publicKeyCredential.toJson();
+                    Intrinsics.checkNotNullExpressionValue(json, "toJson(...)");
+                    return json;
+                } catch (Throwable th) {
+                    throw new GetCredentialUnknownException("The PublicKeyCredential response json had an unexpected exception when parsing: " + th.getMessage());
+                }
+            }
+            Log.e(PublicKeyCredentialControllerUtility.TAG, "AuthenticatorResponse expected assertion response but got: " + response.getClass().getName());
+            String jSONObject2 = jSONObject.toString();
+            Intrinsics.checkNotNullExpressionValue(jSONObject2, "toString(...)");
+            return jSONObject2;
+        }
+
+        public final BeginSignInRequest.PasskeyJsonRequestOptions convertToPlayAuthPasskeyJsonRequest(GetPublicKeyCredentialOption option) {
+            Intrinsics.checkNotNullParameter(option, "option");
+            BeginSignInRequest.PasskeyJsonRequestOptions build = new BeginSignInRequest.PasskeyJsonRequestOptions.Builder().setSupported(true).setRequestJson(option.getRequestJson()).build();
+            Intrinsics.checkNotNullExpressionValue(build, "build(...)");
+            return build;
+        }
+
+        public final BeginSignInRequest.PasskeysRequestOptions convertToPlayAuthPasskeyRequest(GetPublicKeyCredentialOption option) {
+            Intrinsics.checkNotNullParameter(option, "option");
+            JSONObject jSONObject = new JSONObject(option.getRequestJson());
+            String optString = jSONObject.optString(getJSON_KEY_RPID$credentials_play_services_auth_release(), "");
+            Intrinsics.checkNotNull(optString);
+            if (optString.length() == 0) {
+                throw new JSONException("GetPublicKeyCredentialOption - rpId not specified in the request or is unexpectedly empty");
+            }
+            BeginSignInRequest.PasskeysRequestOptions build = new BeginSignInRequest.PasskeysRequestOptions.Builder().setSupported(true).setRpId(optString).setChallenge(getChallenge(jSONObject)).build();
+            Intrinsics.checkNotNullExpressionValue(build, "build(...)");
+            return build;
+        }
+
+        private final byte[] getChallenge(JSONObject jSONObject) {
+            String optString = jSONObject.optString(getJSON_KEY_CHALLENGE$credentials_play_services_auth_release(), "");
+            Intrinsics.checkNotNull(optString);
+            if (optString.length() == 0) {
+                throw new JSONException("Challenge not found in request or is unexpectedly empty");
+            }
+            return b64Decode(optString);
+        }
+
+        public final CreateCredentialException publicKeyCredentialResponseContainsError(PublicKeyCredential cred) {
+            boolean contains$default;
+            Intrinsics.checkNotNullParameter(cred, "cred");
+            AuthenticatorResponse response = cred.getResponse();
+            Intrinsics.checkNotNullExpressionValue(response, "getResponse(...)");
+            if (!(response instanceof AuthenticatorErrorResponse)) {
+                return null;
+            }
+            AuthenticatorErrorResponse authenticatorErrorResponse = (AuthenticatorErrorResponse) response;
+            ErrorCode errorCode = authenticatorErrorResponse.getErrorCode();
+            Intrinsics.checkNotNullExpressionValue(errorCode, "getErrorCode(...)");
+            DomError domError = getOrderedErrorCodeToExceptions$credentials_play_services_auth_release().get(errorCode);
+            String errorMessage = authenticatorErrorResponse.getErrorMessage();
+            if (domError == null) {
+                return new CreatePublicKeyCredentialDomException(new UnknownError(), "unknown fido gms exception - " + errorMessage);
+            }
+            if (errorCode == ErrorCode.NOT_ALLOWED_ERR && errorMessage != null) {
+                contains$default = StringsKt__StringsKt.contains$default(errorMessage, "Unable to get sync account", false, 2, null);
+                if (contains$default) {
+                    return new CreateCredentialCancellationException("Passkey registration was cancelled by the user.");
+                }
+            }
+            return new CreatePublicKeyCredentialDomException(domError, errorMessage);
+        }
+
+        public final GetCredentialException beginSignInPublicKeyCredentialResponseContainsError$credentials_play_services_auth_release(ErrorCode code, String str) {
+            boolean contains$default;
+            Intrinsics.checkNotNullParameter(code, "code");
+            DomError domError = getOrderedErrorCodeToExceptions$credentials_play_services_auth_release().get(code);
+            if (domError == null) {
+                return new GetPublicKeyCredentialDomException(new UnknownError(), "unknown fido gms exception - " + str);
+            }
+            if (code == ErrorCode.NOT_ALLOWED_ERR && str != null) {
+                contains$default = StringsKt__StringsKt.contains$default(str, "Unable to get sync account", false, 2, null);
+                if (contains$default) {
+                    return new GetCredentialCancellationException("Passkey retrieval was cancelled by the user.");
+                }
+            }
+            return new GetPublicKeyCredentialDomException(domError, str);
+        }
+
+        public final void parseOptionalExtensions$credentials_play_services_auth_release(JSONObject json, PublicKeyCredentialCreationOptions.Builder builder) {
+            Intrinsics.checkNotNullParameter(json, "json");
+            Intrinsics.checkNotNullParameter(builder, "builder");
+            if (json.has(getJSON_KEY_EXTENSTIONS$credentials_play_services_auth_release())) {
+                JSONObject jSONObject = json.getJSONObject(getJSON_KEY_EXTENSTIONS$credentials_play_services_auth_release());
+                AuthenticationExtensions.Builder builder2 = new AuthenticationExtensions.Builder();
+                String optString = jSONObject.optString(getJSON_KEY_APPID$credentials_play_services_auth_release(), "");
+                Intrinsics.checkNotNull(optString);
+                if (optString.length() > 0) {
+                    builder2.setFido2Extension(new FidoAppIdExtension(optString));
+                }
+                if (jSONObject.optBoolean(getJSON_KEY_THIRD_PARTY_PAYMENT$credentials_play_services_auth_release(), false)) {
+                    builder2.setGoogleThirdPartyPaymentExtension(new GoogleThirdPartyPaymentExtension(true));
+                }
+                if (jSONObject.optBoolean("uvm", false)) {
+                    builder2.setUserVerificationMethodExtension(new UserVerificationMethodExtension(true));
+                }
+                builder.setAuthenticationExtensions(builder2.build());
+            }
+        }
+
+        public final void parseOptionalAuthenticatorSelection$credentials_play_services_auth_release(JSONObject json, PublicKeyCredentialCreationOptions.Builder builder) {
+            Intrinsics.checkNotNullParameter(json, "json");
+            Intrinsics.checkNotNullParameter(builder, "builder");
+            if (json.has(getJSON_KEY_AUTH_SELECTION$credentials_play_services_auth_release())) {
+                JSONObject jSONObject = json.getJSONObject(getJSON_KEY_AUTH_SELECTION$credentials_play_services_auth_release());
+                AuthenticatorSelectionCriteria.Builder builder2 = new AuthenticatorSelectionCriteria.Builder();
+                boolean optBoolean = jSONObject.optBoolean(getJSON_KEY_REQUIRE_RES_KEY$credentials_play_services_auth_release(), false);
+                String optString = jSONObject.optString(getJSON_KEY_RES_KEY$credentials_play_services_auth_release(), "");
+                Intrinsics.checkNotNull(optString);
+                builder2.setRequireResidentKey(Boolean.valueOf(optBoolean)).setResidentKeyRequirement(optString.length() > 0 ? ResidentKeyRequirement.fromString(optString) : null);
+                String optString2 = jSONObject.optString(getJSON_KEY_AUTH_ATTACHMENT$credentials_play_services_auth_release(), "");
+                Intrinsics.checkNotNull(optString2);
+                if (optString2.length() > 0) {
+                    builder2.setAttachment(Attachment.fromString(optString2));
+                }
+                builder.setAuthenticatorSelection(builder2.build());
+            }
+        }
+
+        public final void parseOptionalTimeout$credentials_play_services_auth_release(JSONObject json, PublicKeyCredentialCreationOptions.Builder builder) {
+            Intrinsics.checkNotNullParameter(json, "json");
+            Intrinsics.checkNotNullParameter(builder, "builder");
+            if (json.has(getJSON_KEY_TIMEOUT$credentials_play_services_auth_release())) {
+                builder.setTimeoutSeconds(Double.valueOf(json.getLong(getJSON_KEY_TIMEOUT$credentials_play_services_auth_release()) / 1000));
+            }
+        }
+
+        public final void parseOptionalWithRequiredDefaultsAttestationAndExcludeCredentials$credentials_play_services_auth_release(JSONObject json, PublicKeyCredentialCreationOptions.Builder builder) {
+            ArrayList arrayList;
+            Intrinsics.checkNotNullParameter(json, "json");
+            Intrinsics.checkNotNullParameter(builder, "builder");
+            ArrayList arrayList2 = new ArrayList();
+            if (json.has(getJSON_KEY_EXCLUDE_CREDENTIALS$credentials_play_services_auth_release())) {
+                JSONArray jSONArray = json.getJSONArray(getJSON_KEY_EXCLUDE_CREDENTIALS$credentials_play_services_auth_release());
+                int length = jSONArray.length();
+                for (int i = 0; i < length; i++) {
+                    JSONObject jSONObject = jSONArray.getJSONObject(i);
+                    String string = jSONObject.getString(getJSON_KEY_ID$credentials_play_services_auth_release());
+                    Intrinsics.checkNotNullExpressionValue(string, "getString(...)");
+                    byte[] b64Decode = b64Decode(string);
+                    String string2 = jSONObject.getString(getJSON_KEY_TYPE$credentials_play_services_auth_release());
+                    Intrinsics.checkNotNull(string2);
+                    if (string2.length() == 0) {
+                        throw new JSONException("PublicKeyCredentialDescriptor type value is not found or unexpectedly empty");
+                    }
+                    if (b64Decode.length == 0) {
+                        throw new JSONException("PublicKeyCredentialDescriptor id value is not found or unexpectedly empty");
+                    }
+                    if (jSONObject.has(getJSON_KEY_TRANSPORTS$credentials_play_services_auth_release())) {
+                        arrayList = new ArrayList();
+                        JSONArray jSONArray2 = jSONObject.getJSONArray(getJSON_KEY_TRANSPORTS$credentials_play_services_auth_release());
+                        int length2 = jSONArray2.length();
+                        for (int i2 = 0; i2 < length2; i2++) {
+                            try {
+                                Transport fromString = Transport.fromString(jSONArray2.getString(i2));
+                                Intrinsics.checkNotNullExpressionValue(fromString, "fromString(...)");
+                                arrayList.add(fromString);
+                            } catch (Transport.UnsupportedTransportException e) {
+                                throw new CreatePublicKeyCredentialDomException(new EncodingError(), e.getMessage());
+                            }
+                        }
+                    } else {
+                        arrayList = null;
+                    }
+                    arrayList2.add(new PublicKeyCredentialDescriptor(string2, b64Decode, arrayList));
+                }
+            }
+            builder.setExcludeList(arrayList2);
+            String optString = json.optString(getJSON_KEY_ATTESTATION$credentials_play_services_auth_release(), "none");
+            Intrinsics.checkNotNull(optString);
+            builder.setAttestationConveyancePreference(AttestationConveyancePreference.fromString(optString.length() != 0 ? optString : "none"));
+        }
+
+        public final void parseRequiredRpAndParams$credentials_play_services_auth_release(JSONObject json, PublicKeyCredentialCreationOptions.Builder builder) {
+            Intrinsics.checkNotNullParameter(json, "json");
+            Intrinsics.checkNotNullParameter(builder, "builder");
+            JSONObject jSONObject = json.getJSONObject(getJSON_KEY_RP$credentials_play_services_auth_release());
+            String string = jSONObject.getString(getJSON_KEY_ID$credentials_play_services_auth_release());
+            String optString = jSONObject.optString(getJSON_KEY_NAME$credentials_play_services_auth_release(), "");
+            String optString2 = jSONObject.optString(getJSON_KEY_ICON$credentials_play_services_auth_release(), "");
+            Intrinsics.checkNotNull(optString2);
+            if (optString2.length() == 0) {
+                optString2 = null;
+            }
+            Intrinsics.checkNotNull(optString);
+            if (optString.length() == 0) {
+                throw new JSONException("PublicKeyCredentialCreationOptions rp name is missing or unexpectedly empty");
+            }
+            Intrinsics.checkNotNull(string);
+            if (string.length() == 0) {
+                throw new JSONException("PublicKeyCredentialCreationOptions rp ID is missing or unexpectedly empty");
+            }
+            builder.setRp(new PublicKeyCredentialRpEntity(string, optString, optString2));
+            JSONArray jSONArray = json.getJSONArray(getJSON_KEY_PUB_KEY_CRED_PARAMS$credentials_play_services_auth_release());
+            ArrayList arrayList = new ArrayList();
+            int length = jSONArray.length();
+            for (int i = 0; i < length; i++) {
+                JSONObject jSONObject2 = jSONArray.getJSONObject(i);
+                int i2 = (int) jSONObject2.getLong(getJSON_KEY_ALG$credentials_play_services_auth_release());
+                String optString3 = jSONObject2.optString(getJSON_KEY_TYPE$credentials_play_services_auth_release(), "");
+                Intrinsics.checkNotNull(optString3);
+                if (optString3.length() == 0) {
+                    throw new JSONException("PublicKeyCredentialCreationOptions PublicKeyCredentialParameter type missing or unexpectedly empty");
+                }
+                if (checkAlgSupported(i2)) {
+                    arrayList.add(new PublicKeyCredentialParameters(optString3, i2));
+                }
+            }
+            builder.setParameters(arrayList);
+        }
+
+        public final void parseRequiredChallengeAndUser$credentials_play_services_auth_release(JSONObject json, PublicKeyCredentialCreationOptions.Builder builder) {
+            Intrinsics.checkNotNullParameter(json, "json");
+            Intrinsics.checkNotNullParameter(builder, "builder");
+            builder.setChallenge(getChallenge(json));
+            JSONObject jSONObject = json.getJSONObject(getJSON_KEY_USER$credentials_play_services_auth_release());
+            String string = jSONObject.getString(getJSON_KEY_ID$credentials_play_services_auth_release());
+            Intrinsics.checkNotNullExpressionValue(string, "getString(...)");
+            byte[] b64Decode = b64Decode(string);
+            String string2 = jSONObject.getString(getJSON_KEY_NAME$credentials_play_services_auth_release());
+            String string3 = jSONObject.getString(getJSON_KEY_DISPLAY_NAME$credentials_play_services_auth_release());
+            String optString = jSONObject.optString(getJSON_KEY_ICON$credentials_play_services_auth_release(), "");
+            Intrinsics.checkNotNull(string3);
+            if (string3.length() == 0) {
+                throw new JSONException("PublicKeyCredentialCreationOptions UserEntity missing displayName or they are unexpectedly empty");
+            }
+            if (b64Decode.length == 0) {
+                throw new JSONException("PublicKeyCredentialCreationOptions UserEntity missing user id or they are unexpectedly empty");
+            }
+            Intrinsics.checkNotNull(string2);
+            if (string2.length() == 0) {
+                throw new JSONException("PublicKeyCredentialCreationOptions UserEntity missing user name or they are unexpectedly empty");
+            }
+            builder.setUser(new PublicKeyCredentialUserEntity(b64Decode, string2, optString, string3));
+        }
+
+        public final byte[] b64Decode(String str) {
+            Intrinsics.checkNotNullParameter(str, "str");
+            byte[] decode = Base64.decode(str, 11);
+            Intrinsics.checkNotNullExpressionValue(decode, "decode(...)");
+            return decode;
+        }
+
+        public final String b64Encode(byte[] data) {
+            Intrinsics.checkNotNullParameter(data, "data");
+            String encodeToString = Base64.encodeToString(data, 11);
+            Intrinsics.checkNotNullExpressionValue(encodeToString, "encodeToString(...)");
+            return encodeToString;
+        }
+
+        public final boolean checkAlgSupported(int i) {
+            try {
+                COSEAlgorithmIdentifier.fromCoseValue(i);
+                return true;
+            } catch (Throwable unused) {
+                return false;
+            }
+        }
+
+        public final LinkedHashMap<ErrorCode, DomError> getOrderedErrorCodeToExceptions$credentials_play_services_auth_release() {
+            return PublicKeyCredentialControllerUtility.orderedErrorCodeToExceptions;
+        }
+    }
+
+    static {
+        LinkedHashMap<ErrorCode, DomError> linkedMapOf;
+        linkedMapOf = MapsKt__MapsKt.linkedMapOf(TuplesKt.to(ErrorCode.UNKNOWN_ERR, new UnknownError()), TuplesKt.to(ErrorCode.ABORT_ERR, new AbortError()), TuplesKt.to(ErrorCode.ATTESTATION_NOT_PRIVATE_ERR, new NotReadableError()), TuplesKt.to(ErrorCode.CONSTRAINT_ERR, new ConstraintError()), TuplesKt.to(ErrorCode.DATA_ERR, new DataError()), TuplesKt.to(ErrorCode.INVALID_STATE_ERR, new InvalidStateError()), TuplesKt.to(ErrorCode.ENCODING_ERR, new EncodingError()), TuplesKt.to(ErrorCode.NETWORK_ERR, new NetworkError()), TuplesKt.to(ErrorCode.NOT_ALLOWED_ERR, new NotAllowedError()), TuplesKt.to(ErrorCode.NOT_SUPPORTED_ERR, new NotSupportedError()), TuplesKt.to(ErrorCode.SECURITY_ERR, new SecurityError()), TuplesKt.to(ErrorCode.TIMEOUT_ERR, new TimeoutError()));
+        orderedErrorCodeToExceptions = linkedMapOf;
+    }
+
+    @RequiresApi(28)
+    public static final class GetGMSVersion {
+        public static final GetGMSVersion INSTANCE = new GetGMSVersion();
+
+        private GetGMSVersion() {
+        }
+
+        public static final long getVersionLong(PackageInfo info) {
+            long longVersionCode;
+            Intrinsics.checkNotNullParameter(info, "info");
+            longVersionCode = info.getLongVersionCode();
+            return longVersionCode;
+        }
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/CreateRestoreCredential/CredentialProviderCreateRestoreCredentialController$invokePlayServices$2$1.java

@@ -0,0 +1,49 @@
+package androidx.credentials.playservices.controllers.CreateRestoreCredential;
+
+import androidx.credentials.CreateCredentialResponse;
+import androidx.credentials.CredentialManagerCallback;
+import androidx.credentials.exceptions.CreateCredentialException;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Lambda;
+import kotlin.jvm.internal.Ref;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderCreateRestoreCredentialController$invokePlayServices$2$1 extends Lambda implements Function0 {
+    final /* synthetic */ CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException> $callback;
+    final /* synthetic */ Ref.ObjectRef<CreateCredentialException> $createException;
+    final /* synthetic */ Executor $executor;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderCreateRestoreCredentialController$invokePlayServices$2$1(Executor executor, CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException> credentialManagerCallback, Ref.ObjectRef<CreateCredentialException> objectRef) {
+        super(0);
+        this.$executor = executor;
+        this.$callback = credentialManagerCallback;
+        this.$createException = objectRef;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m116invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialManagerCallback credentialManagerCallback, Ref.ObjectRef objectRef) {
+        credentialManagerCallback.onError(objectRef.element);
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m116invoke() {
+        Executor executor = this.$executor;
+        final CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException> credentialManagerCallback = this.$callback;
+        final Ref.ObjectRef<CreateCredentialException> objectRef = this.$createException;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.CreateRestoreCredential.CredentialProviderCreateRestoreCredentialController$invokePlayServices$2$1$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderCreateRestoreCredentialController$invokePlayServices$2$1.invoke$lambda$0(CredentialManagerCallback.this, objectRef);
+            }
+        });
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/CreateRestoreCredential/CredentialProviderCreateRestoreCredentialController.java

@@ -0,0 +1,290 @@
+package androidx.credentials.playservices.controllers.CreateRestoreCredential;
+
+import android.content.Context;
+import android.os.CancellationSignal;
+import androidx.credentials.CreateCredentialResponse;
+import androidx.credentials.CreateRestoreCredentialRequest;
+import androidx.credentials.CredentialManagerCallback;
+import androidx.credentials.exceptions.CreateCredentialException;
+import androidx.credentials.exceptions.CreateCredentialUnknownException;
+import androidx.credentials.exceptions.domerrors.DataError;
+import androidx.credentials.exceptions.restorecredential.CreateRestoreCredentialDomException;
+import androidx.credentials.exceptions.restorecredential.E2eeUnavailableException;
+import androidx.credentials.playservices.CredentialProviderPlayServicesImpl;
+import androidx.credentials.playservices.controllers.CredentialProviderController;
+import com.google.android.gms.auth.blockstore.restorecredential.CreateRestoreCredentialResponse;
+import com.google.android.gms.auth.blockstore.restorecredential.RestoreCredential;
+import com.google.android.gms.auth.blockstore.restorecredential.RestoreCredentialStatusCodes;
+import com.google.android.gms.common.api.ApiException;
+import com.google.android.gms.tasks.OnFailureListener;
+import com.google.android.gms.tasks.OnSuccessListener;
+import com.google.android.gms.tasks.Task;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+import kotlin.jvm.internal.Ref;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderCreateRestoreCredentialController extends CredentialProviderController<CreateRestoreCredentialRequest, com.google.android.gms.auth.blockstore.restorecredential.CreateRestoreCredentialRequest, CreateRestoreCredentialResponse, CreateCredentialResponse, CreateCredentialException> {
+    private final Context context;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderCreateRestoreCredentialController(Context context) {
+        super(context);
+        Intrinsics.checkNotNullParameter(context, "context");
+        this.context = context;
+    }
+
+    @Override // androidx.credentials.playservices.controllers.CredentialProviderController
+    public void invokePlayServices(CreateRestoreCredentialRequest request, final CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException> callback, final Executor executor, final CancellationSignal cancellationSignal) {
+        Intrinsics.checkNotNullParameter(request, "request");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        Intrinsics.checkNotNullParameter(executor, "executor");
+        if (CredentialProviderPlayServicesImpl.Companion.cancellationReviewer$credentials_play_services_auth_release(cancellationSignal)) {
+            return;
+        }
+        Task<CreateRestoreCredentialResponse> createRestoreCredential = RestoreCredential.getRestoreCredentialClient(this.context).createRestoreCredential(convertRequestToPlayServices(request));
+        final Function1 function1 = new Function1() { // from class: androidx.credentials.playservices.controllers.CreateRestoreCredential.CredentialProviderCreateRestoreCredentialController$invokePlayServices$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((CreateRestoreCredentialResponse) obj);
+                return Unit.INSTANCE;
+            }
+
+            /* renamed from: androidx.credentials.playservices.controllers.CreateRestoreCredential.CredentialProviderCreateRestoreCredentialController$invokePlayServices$1$1, reason: invalid class name */
+            public static final class AnonymousClass1 extends Lambda implements Function0 {
+                final /* synthetic */ CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException> $callback;
+                final /* synthetic */ Executor $executor;
+                final /* synthetic */ CreateCredentialResponse $response;
+
+                /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+                public AnonymousClass1(Executor executor, CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException> credentialManagerCallback, CreateCredentialResponse createCredentialResponse) {
+                    super(0);
+                    this.$executor = executor;
+                    this.$callback = credentialManagerCallback;
+                    this.$response = createCredentialResponse;
+                }
+
+                @Override // kotlin.jvm.functions.Function0
+                public /* bridge */ /* synthetic */ Object invoke() {
+                    m113invoke();
+                    return Unit.INSTANCE;
+                }
+
+                /* renamed from: invoke, reason: collision with other method in class */
+                public final void m113invoke() {
+                    Executor executor = this.$executor;
+                    final CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException> credentialManagerCallback = this.$callback;
+                    final CreateCredentialResponse createCredentialResponse = this.$response;
+                    executor.execute(
+                    /*  JADX ERROR: Method code generation error
+                        jadx.core.utils.exceptions.CodegenException: Error generate insn: 0x000b: INVOKE 
+                          (r0v0 'executor' java.util.concurrent.Executor)
+                          (wrap:java.lang.Runnable:0x0008: CONSTRUCTOR 
+                          (r1v0 'credentialManagerCallback' androidx.credentials.CredentialManagerCallback<androidx.credentials.CreateCredentialResponse, androidx.credentials.exceptions.CreateCredentialException> A[DONT_INLINE])
+                          (r2v0 'createCredentialResponse' androidx.credentials.CreateCredentialResponse A[DONT_INLINE])
+                         A[MD:(androidx.credentials.CredentialManagerCallback, androidx.credentials.CreateCredentialResponse):void (m), WRAPPED] (LINE:64) call: androidx.credentials.playservices.controllers.CreateRestoreCredential.CredentialProviderCreateRestoreCredentialController$invokePlayServices$1$1$$ExternalSyntheticLambda0.<init>(androidx.credentials.CredentialManagerCallback, androidx.credentials.CreateCredentialResponse):void type: CONSTRUCTOR)
+                         INTERFACE call: java.util.concurrent.Executor.execute(java.lang.Runnable):void A[MD:(java.lang.Runnable):void (c)] (LINE:64) in method: androidx.credentials.playservices.controllers.CreateRestoreCredential.CredentialProviderCreateRestoreCredentialController$invokePlayServices$1.1.invoke():void, file: classes.dex
+                        	at jadx.core.codegen.InsnGen.makeInsn(InsnGen.java:310)
+                        	at jadx.core.codegen.InsnGen.makeInsn(InsnGen.java:273)
+                        	at jadx.core.codegen.RegionGen.makeSimpleBlock(RegionGen.java:94)
+                        	at jadx.core.dex.nodes.IBlock.generate(IBlock.java:15)
+                        	at jadx.core.codegen.RegionGen.makeRegion(RegionGen.java:66)
+                        	at jadx.core.dex.regions.Region.generate(Region.java:35)
+                        	at jadx.core.codegen.RegionGen.makeRegion(RegionGen.java:66)
+                        	at jadx.core.codegen.MethodGen.addRegionInsns(MethodGen.java:297)
+                        	at jadx.core.codegen.MethodGen.addInstructions(MethodGen.java:276)
+                        	at jadx.core.codegen.ClassGen.addMethodCode(ClassGen.java:406)
+                        	at jadx.core.codegen.ClassGen.addMethod(ClassGen.java:335)
+                        	at jadx.core.codegen.ClassGen.lambda$addInnerClsAndMethods$3(ClassGen.java:301)
+                        	at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.accept(ForEachOps.java:184)
+                        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
+                        	at java.base/java.util.stream.SortedOps$RefSortingSink.end(SortedOps.java:395)
+                        	at java.base/java.util.stream.Sink$ChainedReference.end(Sink.java:261)
+                        Caused by: jadx.core.utils.exceptions.JadxRuntimeException: Expected class to be processed at this point, class: androidx.credentials.playservices.controllers.CreateRestoreCredential.CredentialProviderCreateRestoreCredentialController$invokePlayServices$1$1$$ExternalSyntheticLambda0, state: NOT_LOADED
+                        	at jadx.core.dex.nodes.ClassNode.ensureProcessed(ClassNode.java:305)
+                        	at jadx.core.codegen.InsnGen.inlineAnonymousConstructor(InsnGen.java:807)
+                        	at jadx.core.codegen.InsnGen.makeConstructor(InsnGen.java:730)
+                        	at jadx.core.codegen.InsnGen.makeInsnBody(InsnGen.java:418)
+                        	at jadx.core.codegen.InsnGen.addWrappedArg(InsnGen.java:145)
+                        	at jadx.core.codegen.InsnGen.addArg(InsnGen.java:121)
+                        	at jadx.core.codegen.InsnGen.addArg(InsnGen.java:108)
+                        	at jadx.core.codegen.InsnGen.generateMethodArguments(InsnGen.java:1143)
+                        	at jadx.core.codegen.InsnGen.makeInvoke(InsnGen.java:910)
+                        	at jadx.core.codegen.InsnGen.makeInsnBody(InsnGen.java:422)
+                        	at jadx.core.codegen.InsnGen.makeInsn(InsnGen.java:303)
+                        	... 15 more
+                        */
+                    /*
+                        this = this;
+                        java.util.concurrent.Executor r0 = r4.$executor
+                        androidx.credentials.CredentialManagerCallback<androidx.credentials.CreateCredentialResponse, androidx.credentials.exceptions.CreateCredentialException> r1 = r4.$callback
+                        androidx.credentials.CreateCredentialResponse r2 = r4.$response
+                        androidx.credentials.playservices.controllers.CreateRestoreCredential.CredentialProviderCreateRestoreCredentialController$invokePlayServices$1$1$$ExternalSyntheticLambda0 r3 = new androidx.credentials.playservices.controllers.CreateRestoreCredential.CredentialProviderCreateRestoreCredentialController$invokePlayServices$1$1$$ExternalSyntheticLambda0
+                        r3.<init>(r1, r2)
+                        r0.execute(r3)
+                        return
+                    */
+                    throw new UnsupportedOperationException("Method not decompiled: androidx.credentials.playservices.controllers.CreateRestoreCredential.CredentialProviderCreateRestoreCredentialController$invokePlayServices$1.AnonymousClass1.m113invoke():void");
+                }
+            }
+
+            public final void invoke(CreateRestoreCredentialResponse createRestoreCredentialResponse) {
+                try {
+                    CredentialProviderCreateRestoreCredentialController credentialProviderCreateRestoreCredentialController = CredentialProviderCreateRestoreCredentialController.this;
+                    Intrinsics.checkNotNull(createRestoreCredentialResponse);
+                    CreateCredentialResponse convertResponseToCredentialManager = credentialProviderCreateRestoreCredentialController.convertResponseToCredentialManager(createRestoreCredentialResponse);
+                    CredentialProviderController.Companion companion = CredentialProviderController.Companion;
+                    CredentialProviderController.cancelOrCallbackExceptionOrResult(cancellationSignal, new AnonymousClass1(executor, callback, convertResponseToCredentialManager));
+                } catch (Exception e) {
+                    CredentialProviderController.Companion companion2 = CredentialProviderController.Companion;
+                    CredentialProviderController.cancelOrCallbackExceptionOrResult(cancellationSignal, new AnonymousClass2(executor, callback, e));
+                }
+            }
+
+            /* renamed from: androidx.credentials.playservices.controllers.CreateRestoreCredential.CredentialProviderCreateRestoreCredentialController$invokePlayServices$1$2, reason: invalid class name */
+            public static final class AnonymousClass2 extends Lambda implements Function0 {
+                final /* synthetic */ CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException> $callback;
+                final /* synthetic */ Exception $e;
+                final /* synthetic */ Executor $executor;
+
+                /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+                public AnonymousClass2(Executor executor, CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException> credentialManagerCallback, Exception exc) {
+                    super(0);
+                    this.$executor = executor;
+                    this.$callback = credentialManagerCallback;
+                    this.$e = exc;
+                }
+
+                @Override // kotlin.jvm.functions.Function0
+                public /* bridge */ /* synthetic */ Object invoke() {
+                    m115invoke();
+                    return Unit.INSTANCE;
+                }
+
+                /* renamed from: invoke, reason: collision with other method in class */
+                public final void m115invoke() {
+                    Executor executor = this.$executor;
+                    final CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException> credentialManagerCallback = this.$callback;
+                    final Exception exc = this.$e;
+                    executor.execute(
+                    /*  JADX ERROR: Method code generation error
+                        jadx.core.utils.exceptions.CodegenException: Error generate insn: 0x000b: INVOKE 
+                          (r0v0 'executor' java.util.concurrent.Executor)
+                          (wrap:java.lang.Runnable:0x0008: CONSTRUCTOR 
+                          (r1v0 'credentialManagerCallback' androidx.credentials.CredentialManagerCallback<androidx.credentials.CreateCredentialResponse, androidx.credentials.exceptions.CreateCredentialException> A[DONT_INLINE])
+                          (r2v0 'exc' java.lang.Exception A[DONT_INLINE])
+                         A[MD:(androidx.credentials.CredentialManagerCallback, java.lang.Exception):void (m), WRAPPED] (LINE:68) call: androidx.credentials.playservices.controllers.CreateRestoreCredential.CredentialProviderCreateRestoreCredentialController$invokePlayServices$1$2$$ExternalSyntheticLambda0.<init>(androidx.credentials.CredentialManagerCallback, java.lang.Exception):void type: CONSTRUCTOR)
+                         INTERFACE call: java.util.concurrent.Executor.execute(java.lang.Runnable):void A[MD:(java.lang.Runnable):void (c)] (LINE:68) in method: androidx.credentials.playservices.controllers.CreateRestoreCredential.CredentialProviderCreateRestoreCredentialController$invokePlayServices$1.2.invoke():void, file: classes.dex
+                        	at jadx.core.codegen.InsnGen.makeInsn(InsnGen.java:310)
+                        	at jadx.core.codegen.InsnGen.makeInsn(InsnGen.java:273)
+                        	at jadx.core.codegen.RegionGen.makeSimpleBlock(RegionGen.java:94)
+                        	at jadx.core.dex.nodes.IBlock.generate(IBlock.java:15)
+                        	at jadx.core.codegen.RegionGen.makeRegion(RegionGen.java:66)
+                        	at jadx.core.dex.regions.Region.generate(Region.java:35)
+                        	at jadx.core.codegen.RegionGen.makeRegion(RegionGen.java:66)
+                        	at jadx.core.codegen.MethodGen.addRegionInsns(MethodGen.java:297)
+                        	at jadx.core.codegen.MethodGen.addInstructions(MethodGen.java:276)
+                        	at jadx.core.codegen.ClassGen.addMethodCode(ClassGen.java:406)
+                        	at jadx.core.codegen.ClassGen.addMethod(ClassGen.java:335)
+                        	at jadx.core.codegen.ClassGen.lambda$addInnerClsAndMethods$3(ClassGen.java:301)
+                        	at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.accept(ForEachOps.java:184)
+                        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
+                        	at java.base/java.util.stream.SortedOps$RefSortingSink.end(SortedOps.java:395)
+                        	at java.base/java.util.stream.Sink$ChainedReference.end(Sink.java:261)
+                        Caused by: jadx.core.utils.exceptions.JadxRuntimeException: Expected class to be processed at this point, class: androidx.credentials.playservices.controllers.CreateRestoreCredential.CredentialProviderCreateRestoreCredentialController$invokePlayServices$1$2$$ExternalSyntheticLambda0, state: NOT_LOADED
+                        	at jadx.core.dex.nodes.ClassNode.ensureProcessed(ClassNode.java:305)
+                        	at jadx.core.codegen.InsnGen.inlineAnonymousConstructor(InsnGen.java:807)
+                        	at jadx.core.codegen.InsnGen.makeConstructor(InsnGen.java:730)
+                        	at jadx.core.codegen.InsnGen.makeInsnBody(InsnGen.java:418)
+                        	at jadx.core.codegen.InsnGen.addWrappedArg(InsnGen.java:145)
+                        	at jadx.core.codegen.InsnGen.addArg(InsnGen.java:121)
+                        	at jadx.core.codegen.InsnGen.addArg(InsnGen.java:108)
+                        	at jadx.core.codegen.InsnGen.generateMethodArguments(InsnGen.java:1143)
+                        	at jadx.core.codegen.InsnGen.makeInvoke(InsnGen.java:910)
+                        	at jadx.core.codegen.InsnGen.makeInsnBody(InsnGen.java:422)
+                        	at jadx.core.codegen.InsnGen.makeInsn(InsnGen.java:303)
+                        	... 15 more
+                        */
+                    /*
+                        this = this;
+                        java.util.concurrent.Executor r0 = r4.$executor
+                        androidx.credentials.CredentialManagerCallback<androidx.credentials.CreateCredentialResponse, androidx.credentials.exceptions.CreateCredentialException> r1 = r4.$callback
+                        java.lang.Exception r2 = r4.$e
+                        androidx.credentials.playservices.controllers.CreateRestoreCredential.CredentialProviderCreateRestoreCredentialController$invokePlayServices$1$2$$ExternalSyntheticLambda0 r3 = new androidx.credentials.playservices.controllers.CreateRestoreCredential.CredentialProviderCreateRestoreCredentialController$invokePlayServices$1$2$$ExternalSyntheticLambda0
+                        r3.<init>(r1, r2)
+                        r0.execute(r3)
+                        return
+                    */
+                    throw new UnsupportedOperationException("Method not decompiled: androidx.credentials.playservices.controllers.CreateRestoreCredential.CredentialProviderCreateRestoreCredentialController$invokePlayServices$1.AnonymousClass2.m115invoke():void");
+                }
+
+                /* JADX INFO: Access modifiers changed from: private */
+                public static final void invoke$lambda$0(CredentialManagerCallback credentialManagerCallback, Exception exc) {
+                    credentialManagerCallback.onError(new CreateCredentialUnknownException(exc.getMessage()));
+                }
+            }
+        };
+        createRestoreCredential.addOnSuccessListener(new OnSuccessListener() { // from class: androidx.credentials.playservices.controllers.CreateRestoreCredential.CredentialProviderCreateRestoreCredentialController$$ExternalSyntheticLambda0
+            @Override // com.google.android.gms.tasks.OnSuccessListener
+            public final void onSuccess(Object obj) {
+                Function1.this.invoke(obj);
+            }
+        }).addOnFailureListener(new OnFailureListener() { // from class: androidx.credentials.playservices.controllers.CreateRestoreCredential.CredentialProviderCreateRestoreCredentialController$$ExternalSyntheticLambda1
+            @Override // com.google.android.gms.tasks.OnFailureListener
+            public final void onFailure(Exception exc) {
+                CredentialProviderCreateRestoreCredentialController.invokePlayServices$lambda$1(cancellationSignal, executor, callback, exc);
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* JADX WARN: Type inference failed for: r1v0, types: [T, androidx.credentials.exceptions.CreateCredentialUnknownException] */
+    /* JADX WARN: Type inference failed for: r1v4, types: [T, androidx.credentials.exceptions.CreateCredentialUnknownException] */
+    /* JADX WARN: Type inference failed for: r1v5, types: [T, androidx.credentials.exceptions.restorecredential.CreateRestoreCredentialDomException] */
+    /* JADX WARN: Type inference failed for: r2v5, types: [T, androidx.credentials.exceptions.CreateCredentialUnknownException] */
+    /* JADX WARN: Type inference failed for: r8v6, types: [T, androidx.credentials.exceptions.restorecredential.E2eeUnavailableException] */
+    public static final void invokePlayServices$lambda$1(CancellationSignal cancellationSignal, Executor executor, CredentialManagerCallback credentialManagerCallback, Exception e) {
+        Intrinsics.checkNotNullParameter(e, "e");
+        Ref.ObjectRef objectRef = new Ref.ObjectRef();
+        objectRef.element = new CreateCredentialUnknownException("Create restore credential failed for unknown reason, failure: " + e.getMessage());
+        if (e instanceof ApiException) {
+            ApiException apiException = (ApiException) e;
+            switch (apiException.getStatusCode()) {
+                case RestoreCredentialStatusCodes.RESTORE_CREDENTIAL_INTERNAL_FAILURE /* 40201 */:
+                    objectRef.element = new CreateCredentialUnknownException("The restore credential internal service had a failure, failure: " + e.getMessage());
+                    break;
+                case RestoreCredentialStatusCodes.RESTORE_CREDENTIAL_FIDO_FAILURE /* 40202 */:
+                    objectRef.element = new CreateRestoreCredentialDomException(new DataError(), "The request did not match the fido spec, failure: " + e.getMessage());
+                    break;
+                case RestoreCredentialStatusCodes.RESTORE_CREDENTIAL_E2EE_UNAVAILABLE /* 40203 */:
+                    objectRef.element = new E2eeUnavailableException("E2ee is not available on the device. Check whether the backup and screen lock are enabled.");
+                    break;
+                default:
+                    objectRef.element = new CreateCredentialUnknownException("The restore credential service failed with unsupported status code, failure: " + e.getMessage() + ", status code: " + apiException.getStatusCode());
+                    break;
+            }
+        }
+        CredentialProviderController.cancelOrCallbackExceptionOrResult(cancellationSignal, new CredentialProviderCreateRestoreCredentialController$invokePlayServices$2$1(executor, credentialManagerCallback, objectRef));
+    }
+
+    @Override // androidx.credentials.playservices.controllers.CredentialProviderController
+    public com.google.android.gms.auth.blockstore.restorecredential.CreateRestoreCredentialRequest convertRequestToPlayServices(CreateRestoreCredentialRequest request) {
+        Intrinsics.checkNotNullParameter(request, "request");
+        return new com.google.android.gms.auth.blockstore.restorecredential.CreateRestoreCredentialRequest(request.getCredentialData());
+    }
+
+    @Override // androidx.credentials.playservices.controllers.CredentialProviderController
+    public CreateCredentialResponse convertResponseToCredentialManager(CreateRestoreCredentialResponse response) {
+        Intrinsics.checkNotNullParameter(response, "response");
+        return androidx.credentials.CreateRestoreCredentialResponse.Companion.createFrom(response.getResponseBundle());
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/CredentialProviderBaseController.java

@@ -0,0 +1,149 @@
+package androidx.credentials.playservices.controllers;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.ResultReceiver;
+import androidx.credentials.exceptions.CreateCredentialCancellationException;
+import androidx.credentials.exceptions.CreateCredentialException;
+import androidx.credentials.exceptions.CreateCredentialInterruptedException;
+import androidx.credentials.exceptions.CreateCredentialUnknownException;
+import androidx.credentials.exceptions.GetCredentialCancellationException;
+import androidx.credentials.exceptions.GetCredentialException;
+import androidx.credentials.exceptions.GetCredentialInterruptedException;
+import androidx.credentials.exceptions.GetCredentialUnknownException;
+import androidx.credentials.exceptions.NoCredentialException;
+import java.util.Set;
+import kotlin.collections.SetsKt__SetsKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public class CredentialProviderBaseController {
+    public static final String ACTIVITY_REQUEST_CODE_TAG = "ACTIVITY_REQUEST_CODE";
+    public static final String BEGIN_SIGN_IN_TAG = "BEGIN_SIGN_IN";
+    private static final int CONTROLLER_REQUEST_CODE;
+    public static final String CREATE_CANCELED = "CREATE_CANCELED";
+    public static final String CREATE_INTERRUPTED = "CREATE_INTERRUPTED";
+    public static final String CREATE_PASSWORD_TAG = "CREATE_PASSWORD";
+    public static final String CREATE_PUBLIC_KEY_CREDENTIAL_TAG = "CREATE_PUBLIC_KEY_CREDENTIAL";
+    public static final String CREATE_UNKNOWN = "CREATE_UNKNOWN";
+    public static final Companion Companion = new Companion(null);
+    public static final String EXCEPTION_MESSAGE_TAG = "EXCEPTION_MESSAGE";
+    public static final String EXCEPTION_TYPE_TAG = "EXCEPTION_TYPE";
+    public static final String EXTRA_GET_CREDENTIAL_INTENT = "EXTRA_GET_CREDENTIAL_INTENT";
+    public static final String FAILURE_RESPONSE_TAG = "FAILURE_RESPONSE";
+    public static final String GET_CANCELED = "GET_CANCELED_TAG";
+    public static final String GET_INTERRUPTED = "GET_INTERRUPTED";
+    public static final String GET_NO_CREDENTIALS = "GET_NO_CREDENTIALS";
+    public static final String GET_UNKNOWN = "GET_UNKNOWN";
+    public static final String REQUEST_TAG = "REQUEST_TYPE";
+    public static final String RESULT_DATA_TAG = "RESULT_DATA";
+    public static final String RESULT_RECEIVER_TAG = "RESULT_RECEIVER";
+    public static final String SIGN_IN_INTENT_TAG = "SIGN_IN_INTENT";
+    public static final String TYPE_TAG = "TYPE";
+    private static final Set<Integer> retryables;
+    private final Context context;
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public static /* synthetic */ void getCONTROLLER_REQUEST_CODE$credentials_play_services_auth_release$annotations() {
+        }
+
+        private Companion() {
+        }
+
+        public final Set<Integer> getRetryables() {
+            return CredentialProviderBaseController.retryables;
+        }
+
+        public final int getCONTROLLER_REQUEST_CODE$credentials_play_services_auth_release() {
+            return CredentialProviderBaseController.CONTROLLER_REQUEST_CODE;
+        }
+
+        public final GetCredentialException getCredentialExceptionTypeToException$credentials_play_services_auth_release(String str, String str2) {
+            if (str != null) {
+                int hashCode = str.hashCode();
+                if (hashCode != -1567968963) {
+                    if (hashCode != -154594663) {
+                        if (hashCode == 1996705159 && str.equals(CredentialProviderBaseController.GET_NO_CREDENTIALS)) {
+                            return new NoCredentialException(str2);
+                        }
+                    } else if (str.equals(CredentialProviderBaseController.GET_INTERRUPTED)) {
+                        return new GetCredentialInterruptedException(str2);
+                    }
+                } else if (str.equals(CredentialProviderBaseController.GET_CANCELED)) {
+                    return new GetCredentialCancellationException(str2);
+                }
+            }
+            return new GetCredentialUnknownException(str2);
+        }
+
+        public final void reportError$credentials_play_services_auth_release(ResultReceiver resultReceiver, String errName, String errMsg) {
+            Intrinsics.checkNotNullParameter(resultReceiver, "<this>");
+            Intrinsics.checkNotNullParameter(errName, "errName");
+            Intrinsics.checkNotNullParameter(errMsg, "errMsg");
+            Bundle bundle = new Bundle();
+            bundle.putBoolean(CredentialProviderBaseController.FAILURE_RESPONSE_TAG, true);
+            bundle.putString(CredentialProviderBaseController.EXCEPTION_TYPE_TAG, errName);
+            bundle.putString(CredentialProviderBaseController.EXCEPTION_MESSAGE_TAG, errMsg);
+            resultReceiver.send(Integer.MAX_VALUE, bundle);
+        }
+
+        public final void reportResult$credentials_play_services_auth_release(ResultReceiver resultReceiver, int i, int i2, Intent intent) {
+            Intrinsics.checkNotNullParameter(resultReceiver, "<this>");
+            Bundle bundle = new Bundle();
+            bundle.putBoolean(CredentialProviderBaseController.FAILURE_RESPONSE_TAG, false);
+            bundle.putInt(CredentialProviderBaseController.ACTIVITY_REQUEST_CODE_TAG, i);
+            bundle.putParcelable(CredentialProviderBaseController.RESULT_DATA_TAG, intent);
+            resultReceiver.send(i2, bundle);
+        }
+
+        public final CreateCredentialException createCredentialExceptionTypeToException$credentials_play_services_auth_release(String str, String str2) {
+            if (Intrinsics.areEqual(str, CredentialProviderBaseController.CREATE_CANCELED)) {
+                return new CreateCredentialCancellationException(str2);
+            }
+            if (Intrinsics.areEqual(str, CredentialProviderBaseController.CREATE_INTERRUPTED)) {
+                return new CreateCredentialInterruptedException(str2);
+            }
+            return new CreateCredentialUnknownException(str2);
+        }
+    }
+
+    public CredentialProviderBaseController(Context context) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        this.context = context;
+    }
+
+    static {
+        Set<Integer> of;
+        of = SetsKt__SetsKt.setOf((Object[]) new Integer[]{7, 20});
+        retryables = of;
+        CONTROLLER_REQUEST_CODE = 1;
+    }
+
+    public final <T extends ResultReceiver> ResultReceiver toIpcFriendlyResultReceiver(T t) {
+        Parcel obtain = Parcel.obtain();
+        Intrinsics.checkNotNullExpressionValue(obtain, "obtain(...)");
+        Intrinsics.checkNotNull(t);
+        t.writeToParcel(obtain, 0);
+        obtain.setDataPosition(0);
+        ResultReceiver resultReceiver = (ResultReceiver) ResultReceiver.CREATOR.createFromParcel(obtain);
+        obtain.recycle();
+        return resultReceiver;
+    }
+
+    public final void generateHiddenActivityIntent(ResultReceiver resultReceiver, Intent hiddenIntent, String typeTag) {
+        Intrinsics.checkNotNullParameter(resultReceiver, "resultReceiver");
+        Intrinsics.checkNotNullParameter(hiddenIntent, "hiddenIntent");
+        Intrinsics.checkNotNullParameter(typeTag, "typeTag");
+        hiddenIntent.putExtra(TYPE_TAG, typeTag);
+        hiddenIntent.putExtra(ACTIVITY_REQUEST_CODE_TAG, CONTROLLER_REQUEST_CODE);
+        hiddenIntent.putExtra(RESULT_RECEIVER_TAG, toIpcFriendlyResultReceiver(resultReceiver));
+        hiddenIntent.setFlags(65536);
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/CredentialProviderController$maybeReportErrorFromResultReceiver$1.java

@@ -0,0 +1,41 @@
+package androidx.credentials.playservices.controllers;
+
+import androidx.credentials.CredentialManagerCallback;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderController$maybeReportErrorFromResultReceiver$1 extends Lambda implements Function0 {
+    final /* synthetic */ CredentialManagerCallback<R1, E1> $callback;
+    final /* synthetic */ E1 $exception;
+    final /* synthetic */ Executor $executor;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderController$maybeReportErrorFromResultReceiver$1(Executor executor, CredentialManagerCallback<R1, E1> credentialManagerCallback, E1 e1) {
+        super(0);
+        this.$executor = executor;
+        this.$callback = credentialManagerCallback;
+        this.$exception = e1;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m119invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m119invoke() {
+        Executor executor = this.$executor;
+        final CredentialManagerCallback<R1, E1> credentialManagerCallback = this.$callback;
+        final E1 e1 = this.$exception;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.CredentialProviderController$maybeReportErrorFromResultReceiver$1$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialManagerCallback.this.onError(e1);
+            }
+        });
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/CredentialProviderController.java

@@ -0,0 +1,154 @@
+package androidx.credentials.playservices.controllers;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.os.CancellationSignal;
+import androidx.credentials.CredentialManagerCallback;
+import androidx.credentials.exceptions.CreateCredentialCancellationException;
+import androidx.credentials.exceptions.CreateCredentialUnknownException;
+import androidx.credentials.exceptions.GetCredentialCancellationException;
+import androidx.credentials.exceptions.GetCredentialUnknownException;
+import androidx.credentials.playservices.CredentialProviderPlayServicesImpl;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Ref;
+
+/* loaded from: classes.dex */
+public abstract class CredentialProviderController<T1, T2, R2, R1, E1> extends CredentialProviderBaseController {
+    public static final Companion Companion = new Companion(null);
+    public static final String ERROR_MESSAGE_START_ACTIVITY_FAILED = "Failed to launch the selector UI. Hint: ensure the `context` parameter is an Activity-based context.";
+    private final Context context;
+
+    public static final void cancelOrCallbackExceptionOrResult(CancellationSignal cancellationSignal, Function0 function0) {
+        Companion.cancelOrCallbackExceptionOrResult(cancellationSignal, function0);
+    }
+
+    public static final boolean maybeReportErrorResultCodeCreate(int i, Function2 function2, Function1 function1, CancellationSignal cancellationSignal) {
+        return Companion.maybeReportErrorResultCodeCreate(i, function2, function1, cancellationSignal);
+    }
+
+    public static final boolean maybeReportErrorResultCodeGet(int i, Function2 function2, Function1 function1, CancellationSignal cancellationSignal) {
+        return Companion.maybeReportErrorResultCodeGet(i, function2, function1, cancellationSignal);
+    }
+
+    public abstract T2 convertRequestToPlayServices(T1 t1);
+
+    public abstract R1 convertResponseToCredentialManager(R2 r2);
+
+    public abstract void invokePlayServices(T1 t1, CredentialManagerCallback<R1, E1> credentialManagerCallback, Executor executor, CancellationSignal cancellationSignal);
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderController(Context context) {
+        super(context);
+        Intrinsics.checkNotNullParameter(context, "context");
+        this.context = context;
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public final String generateErrorStringCanceled$credentials_play_services_auth_release() {
+            return "activity is cancelled by the user.";
+        }
+
+        private Companion() {
+        }
+
+        /* JADX WARN: Type inference failed for: r1v0, types: [T, androidx.credentials.exceptions.CreateCredentialUnknownException] */
+        /* JADX WARN: Type inference failed for: r4v4, types: [T, androidx.credentials.exceptions.CreateCredentialCancellationException] */
+        public final boolean maybeReportErrorResultCodeCreate(int i, Function2 cancelOnError, final Function1 onError, CancellationSignal cancellationSignal) {
+            Intrinsics.checkNotNullParameter(cancelOnError, "cancelOnError");
+            Intrinsics.checkNotNullParameter(onError, "onError");
+            if (i == -1) {
+                return false;
+            }
+            final Ref.ObjectRef objectRef = new Ref.ObjectRef();
+            objectRef.element = new CreateCredentialUnknownException(generateErrorStringUnknown$credentials_play_services_auth_release(i));
+            if (i == 0) {
+                objectRef.element = new CreateCredentialCancellationException(generateErrorStringCanceled$credentials_play_services_auth_release());
+            }
+            cancelOnError.invoke(cancellationSignal, new Function0() { // from class: androidx.credentials.playservices.controllers.CredentialProviderController$Companion$maybeReportErrorResultCodeCreate$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() {
+                    m117invoke();
+                    return Unit.INSTANCE;
+                }
+
+                /* renamed from: invoke, reason: collision with other method in class */
+                public final void m117invoke() {
+                    Function1.this.invoke(objectRef.element);
+                }
+            });
+            return true;
+        }
+
+        public final String generateErrorStringUnknown$credentials_play_services_auth_release(int i) {
+            return "activity with result code: " + i + " indicating not RESULT_OK";
+        }
+
+        /* JADX WARN: Type inference failed for: r1v0, types: [T, androidx.credentials.exceptions.GetCredentialUnknownException] */
+        /* JADX WARN: Type inference failed for: r4v4, types: [T, androidx.credentials.exceptions.GetCredentialCancellationException] */
+        public final boolean maybeReportErrorResultCodeGet(int i, Function2 cancelOnError, final Function1 onError, CancellationSignal cancellationSignal) {
+            Intrinsics.checkNotNullParameter(cancelOnError, "cancelOnError");
+            Intrinsics.checkNotNullParameter(onError, "onError");
+            if (i == -1) {
+                return false;
+            }
+            final Ref.ObjectRef objectRef = new Ref.ObjectRef();
+            objectRef.element = new GetCredentialUnknownException(generateErrorStringUnknown$credentials_play_services_auth_release(i));
+            if (i == 0) {
+                objectRef.element = new GetCredentialCancellationException(generateErrorStringCanceled$credentials_play_services_auth_release());
+            }
+            cancelOnError.invoke(cancellationSignal, new Function0() { // from class: androidx.credentials.playservices.controllers.CredentialProviderController$Companion$maybeReportErrorResultCodeGet$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() {
+                    m118invoke();
+                    return Unit.INSTANCE;
+                }
+
+                /* renamed from: invoke, reason: collision with other method in class */
+                public final void m118invoke() {
+                    Function1.this.invoke(objectRef.element);
+                }
+            });
+            return true;
+        }
+
+        public final void cancelOrCallbackExceptionOrResult(CancellationSignal cancellationSignal, Function0 onResultOrException) {
+            Intrinsics.checkNotNullParameter(onResultOrException, "onResultOrException");
+            if (CredentialProviderPlayServicesImpl.Companion.cancellationReviewer$credentials_play_services_auth_release(cancellationSignal)) {
+                return;
+            }
+            onResultOrException.invoke();
+        }
+    }
+
+    public final boolean maybeReportErrorFromResultReceiver(Bundle resultData, Function2 conversionFn, Executor executor, CredentialManagerCallback<R1, E1> callback, CancellationSignal cancellationSignal) {
+        Intrinsics.checkNotNullParameter(resultData, "resultData");
+        Intrinsics.checkNotNullParameter(conversionFn, "conversionFn");
+        Intrinsics.checkNotNullParameter(executor, "executor");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        if (!resultData.getBoolean(CredentialProviderBaseController.FAILURE_RESPONSE_TAG)) {
+            return false;
+        }
+        cancelOrCallbackExceptionOrResult(cancellationSignal, new CredentialProviderController$maybeReportErrorFromResultReceiver$1(executor, callback, conversionFn.invoke(resultData.getString(CredentialProviderBaseController.EXCEPTION_TYPE_TAG), resultData.getString(CredentialProviderBaseController.EXCEPTION_MESSAGE_TAG))));
+        return true;
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/GetRestoreCredential/CredentialProviderGetDigitalCredentialController$handleResponse$2.java

@@ -0,0 +1,42 @@
+package androidx.credentials.playservices.controllers.GetRestoreCredential;
+
+import androidx.credentials.exceptions.GetCredentialException;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderGetDigitalCredentialController$handleResponse$2 extends Lambda implements Function1 {
+    final /* synthetic */ CredentialProviderGetDigitalCredentialController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderGetDigitalCredentialController$handleResponse$2(CredentialProviderGetDigitalCredentialController credentialProviderGetDigitalCredentialController) {
+        super(1);
+        this.this$0 = credentialProviderGetDigitalCredentialController;
+    }
+
+    @Override // kotlin.jvm.functions.Function1
+    public /* bridge */ /* synthetic */ Object invoke(Object obj) {
+        invoke((GetCredentialException) obj);
+        return Unit.INSTANCE;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderGetDigitalCredentialController credentialProviderGetDigitalCredentialController, GetCredentialException getCredentialException) {
+        credentialProviderGetDigitalCredentialController.getCallback().onError(getCredentialException);
+    }
+
+    public final void invoke(final GetCredentialException e) {
+        Intrinsics.checkNotNullParameter(e, "e");
+        Executor executor = this.this$0.getExecutor();
+        final CredentialProviderGetDigitalCredentialController credentialProviderGetDigitalCredentialController = this.this$0;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetDigitalCredentialController$handleResponse$2$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderGetDigitalCredentialController$handleResponse$2.invoke$lambda$0(CredentialProviderGetDigitalCredentialController.this, e);
+            }
+        });
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/GetRestoreCredential/CredentialProviderGetDigitalCredentialController$handleResponse$3.java

@@ -0,0 +1,41 @@
+package androidx.credentials.playservices.controllers.GetRestoreCredential;
+
+import androidx.credentials.exceptions.GetCredentialUnknownException;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderGetDigitalCredentialController$handleResponse$3 extends Lambda implements Function0 {
+    final /* synthetic */ CredentialProviderGetDigitalCredentialController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderGetDigitalCredentialController$handleResponse$3(CredentialProviderGetDigitalCredentialController credentialProviderGetDigitalCredentialController) {
+        super(0);
+        this.this$0 = credentialProviderGetDigitalCredentialController;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m121invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m121invoke() {
+        Executor executor = this.this$0.getExecutor();
+        final CredentialProviderGetDigitalCredentialController credentialProviderGetDigitalCredentialController = this.this$0;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetDigitalCredentialController$handleResponse$3$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderGetDigitalCredentialController$handleResponse$3.invoke$lambda$0(CredentialProviderGetDigitalCredentialController.this);
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderGetDigitalCredentialController credentialProviderGetDigitalCredentialController) {
+        credentialProviderGetDigitalCredentialController.getCallback().onError(new GetCredentialUnknownException("No provider data returned."));
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/GetRestoreCredential/CredentialProviderGetDigitalCredentialController$handleResponse$4.java

@@ -0,0 +1,44 @@
+package androidx.credentials.playservices.controllers.GetRestoreCredential;
+
+import androidx.credentials.GetCredentialResponse;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderGetDigitalCredentialController$handleResponse$4 extends Lambda implements Function0 {
+    final /* synthetic */ GetCredentialResponse $response;
+    final /* synthetic */ CredentialProviderGetDigitalCredentialController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderGetDigitalCredentialController$handleResponse$4(CredentialProviderGetDigitalCredentialController credentialProviderGetDigitalCredentialController, GetCredentialResponse getCredentialResponse) {
+        super(0);
+        this.this$0 = credentialProviderGetDigitalCredentialController;
+        this.$response = getCredentialResponse;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m123invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderGetDigitalCredentialController credentialProviderGetDigitalCredentialController, GetCredentialResponse getCredentialResponse) {
+        credentialProviderGetDigitalCredentialController.getCallback().onResult(getCredentialResponse);
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m123invoke() {
+        Executor executor = this.this$0.getExecutor();
+        final CredentialProviderGetDigitalCredentialController credentialProviderGetDigitalCredentialController = this.this$0;
+        final GetCredentialResponse getCredentialResponse = this.$response;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetDigitalCredentialController$handleResponse$4$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderGetDigitalCredentialController$handleResponse$4.invoke$lambda$0(CredentialProviderGetDigitalCredentialController.this, getCredentialResponse);
+            }
+        });
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/GetRestoreCredential/CredentialProviderGetDigitalCredentialController$handleResponse$5.java

@@ -0,0 +1,51 @@
+package androidx.credentials.playservices.controllers.GetRestoreCredential;
+
+import androidx.credentials.CredentialManagerCallback;
+import androidx.credentials.GetCredentialResponse;
+import androidx.credentials.exceptions.GetCredentialException;
+import androidx.credentials.exceptions.GetCredentialUnknownException;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderGetDigitalCredentialController$handleResponse$5 extends Lambda implements Function0 {
+    final /* synthetic */ GetCredentialException $providerException;
+    final /* synthetic */ CredentialProviderGetDigitalCredentialController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderGetDigitalCredentialController$handleResponse$5(CredentialProviderGetDigitalCredentialController credentialProviderGetDigitalCredentialController, GetCredentialException getCredentialException) {
+        super(0);
+        this.this$0 = credentialProviderGetDigitalCredentialController;
+        this.$providerException = getCredentialException;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m124invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m124invoke() {
+        Executor executor = this.this$0.getExecutor();
+        final CredentialProviderGetDigitalCredentialController credentialProviderGetDigitalCredentialController = this.this$0;
+        final GetCredentialException getCredentialException = this.$providerException;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetDigitalCredentialController$handleResponse$5$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderGetDigitalCredentialController$handleResponse$5.invoke$lambda$0(CredentialProviderGetDigitalCredentialController.this, getCredentialException);
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderGetDigitalCredentialController credentialProviderGetDigitalCredentialController, GetCredentialException getCredentialException) {
+        CredentialManagerCallback<GetCredentialResponse, GetCredentialException> callback = credentialProviderGetDigitalCredentialController.getCallback();
+        if (getCredentialException == null) {
+            getCredentialException = new GetCredentialUnknownException("Unexpected configuration error");
+        }
+        callback.onError(getCredentialException);
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/GetRestoreCredential/CredentialProviderGetDigitalCredentialController$invokePlayServices$2$1.java

@@ -0,0 +1,43 @@
+package androidx.credentials.playservices.controllers.GetRestoreCredential;
+
+import androidx.credentials.CredentialManagerCallback;
+import androidx.credentials.GetCredentialResponse;
+import androidx.credentials.exceptions.GetCredentialException;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderGetDigitalCredentialController$invokePlayServices$2$1 extends Lambda implements Function0 {
+    final /* synthetic */ CredentialManagerCallback<GetCredentialResponse, GetCredentialException> $callback;
+    final /* synthetic */ Executor $executor;
+    final /* synthetic */ GetCredentialException $getException;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderGetDigitalCredentialController$invokePlayServices$2$1(Executor executor, CredentialManagerCallback<GetCredentialResponse, GetCredentialException> credentialManagerCallback, GetCredentialException getCredentialException) {
+        super(0);
+        this.$executor = executor;
+        this.$callback = credentialManagerCallback;
+        this.$getException = getCredentialException;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m125invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m125invoke() {
+        Executor executor = this.$executor;
+        final CredentialManagerCallback<GetCredentialResponse, GetCredentialException> credentialManagerCallback = this.$callback;
+        final GetCredentialException getCredentialException = this.$getException;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetDigitalCredentialController$invokePlayServices$2$1$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialManagerCallback.this.onError(getCredentialException);
+            }
+        });
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/GetRestoreCredential/CredentialProviderGetDigitalCredentialController$resultReceiver$1$onReceiveResult$1.java

@@ -0,0 +1,18 @@
+package androidx.credentials.playservices.controllers.GetRestoreCredential;
+
+import androidx.credentials.exceptions.GetCredentialException;
+import androidx.credentials.playservices.controllers.CredentialProviderBaseController;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.FunctionReferenceImpl;
+
+/* loaded from: classes.dex */
+public /* synthetic */ class CredentialProviderGetDigitalCredentialController$resultReceiver$1$onReceiveResult$1 extends FunctionReferenceImpl implements Function2 {
+    public CredentialProviderGetDigitalCredentialController$resultReceiver$1$onReceiveResult$1(Object obj) {
+        super(2, obj, CredentialProviderBaseController.Companion.class, "getCredentialExceptionTypeToException", "getCredentialExceptionTypeToException$credentials_play_services_auth_release(Ljava/lang/String;Ljava/lang/String;)Landroidx/credentials/exceptions/GetCredentialException;", 0);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final GetCredentialException invoke(String str, String str2) {
+        return ((CredentialProviderBaseController.Companion) this.receiver).getCredentialExceptionTypeToException$credentials_play_services_auth_release(str, str2);
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/GetRestoreCredential/CredentialProviderGetDigitalCredentialController.java

@@ -0,0 +1,267 @@
+package androidx.credentials.playservices.controllers.GetRestoreCredential;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.CancellationSignal;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.ResultReceiver;
+import android.util.Log;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.VisibleForTesting;
+import androidx.credentials.Credential;
+import androidx.credentials.CredentialManagerCallback;
+import androidx.credentials.CredentialOption;
+import androidx.credentials.DigitalCredential;
+import androidx.credentials.GetCredentialRequest;
+import androidx.credentials.GetDigitalCredentialOption;
+import androidx.credentials.exceptions.GetCredentialCancellationException;
+import androidx.credentials.exceptions.GetCredentialException;
+import androidx.credentials.exceptions.GetCredentialInterruptedException;
+import androidx.credentials.exceptions.GetCredentialUnknownException;
+import androidx.credentials.internal.ConversionUtilsKt;
+import androidx.credentials.playservices.CredentialProviderPlayServicesImpl;
+import androidx.credentials.playservices.IdentityCredentialApiHiddenActivity;
+import androidx.credentials.playservices.controllers.CredentialProviderBaseController;
+import androidx.credentials.playservices.controllers.CredentialProviderController;
+import androidx.credentials.provider.PendingIntentHandler;
+import com.google.android.gms.common.api.ApiException;
+import com.google.android.gms.identitycredentials.GetCredentialResponse;
+import com.google.android.gms.identitycredentials.IdentityCredentialManager;
+import com.google.android.gms.identitycredentials.PendingGetCredentialHandle;
+import com.google.android.gms.tasks.OnFailureListener;
+import com.google.android.gms.tasks.OnSuccessListener;
+import com.google.android.gms.tasks.Task;
+import java.util.ArrayList;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+@RequiresApi(23)
+/* loaded from: classes.dex */
+public final class CredentialProviderGetDigitalCredentialController extends CredentialProviderController<GetCredentialRequest, com.google.android.gms.identitycredentials.GetCredentialRequest, GetCredentialResponse, androidx.credentials.GetCredentialResponse, GetCredentialException> {
+    private static final Companion Companion = new Companion(null);
+    private static final String TAG = "DigitalCredentialClient";
+    public CredentialManagerCallback<androidx.credentials.GetCredentialResponse, GetCredentialException> callback;
+    private CancellationSignal cancellationSignal;
+    private final Context context;
+    public Executor executor;
+    private final CredentialProviderGetDigitalCredentialController$resultReceiver$1 resultReceiver;
+
+    @VisibleForTesting
+    public static /* synthetic */ void getCallback$annotations() {
+    }
+
+    @VisibleForTesting
+    private static /* synthetic */ void getCancellationSignal$annotations() {
+    }
+
+    @VisibleForTesting
+    public static /* synthetic */ void getExecutor$annotations() {
+    }
+
+    private static /* synthetic */ void getResultReceiver$annotations() {
+    }
+
+    public final void setCallback(CredentialManagerCallback<androidx.credentials.GetCredentialResponse, GetCredentialException> credentialManagerCallback) {
+        Intrinsics.checkNotNullParameter(credentialManagerCallback, "<set-?>");
+        this.callback = credentialManagerCallback;
+    }
+
+    public final void setExecutor(Executor executor) {
+        Intrinsics.checkNotNullParameter(executor, "<set-?>");
+        this.executor = executor;
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    /* JADX WARN: Type inference failed for: r0v2, types: [androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetDigitalCredentialController$resultReceiver$1] */
+    public CredentialProviderGetDigitalCredentialController(Context context) {
+        super(context);
+        Intrinsics.checkNotNullParameter(context, "context");
+        this.context = context;
+        final Handler handler = new Handler(Looper.getMainLooper());
+        this.resultReceiver = new ResultReceiver(handler) { // from class: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetDigitalCredentialController$resultReceiver$1
+            @Override // android.os.ResultReceiver
+            public void onReceiveResult(int i, Bundle resultData) {
+                CancellationSignal cancellationSignal;
+                boolean maybeReportErrorFromResultReceiver;
+                Intrinsics.checkNotNullParameter(resultData, "resultData");
+                CredentialProviderGetDigitalCredentialController credentialProviderGetDigitalCredentialController = CredentialProviderGetDigitalCredentialController.this;
+                CredentialProviderGetDigitalCredentialController$resultReceiver$1$onReceiveResult$1 credentialProviderGetDigitalCredentialController$resultReceiver$1$onReceiveResult$1 = new CredentialProviderGetDigitalCredentialController$resultReceiver$1$onReceiveResult$1(CredentialProviderBaseController.Companion);
+                Executor executor = CredentialProviderGetDigitalCredentialController.this.getExecutor();
+                CredentialManagerCallback<androidx.credentials.GetCredentialResponse, GetCredentialException> callback = CredentialProviderGetDigitalCredentialController.this.getCallback();
+                cancellationSignal = CredentialProviderGetDigitalCredentialController.this.cancellationSignal;
+                maybeReportErrorFromResultReceiver = credentialProviderGetDigitalCredentialController.maybeReportErrorFromResultReceiver(resultData, credentialProviderGetDigitalCredentialController$resultReceiver$1$onReceiveResult$1, executor, callback, cancellationSignal);
+                if (maybeReportErrorFromResultReceiver) {
+                    return;
+                }
+                CredentialProviderGetDigitalCredentialController.this.handleResponse$credentials_play_services_auth_release(resultData.getInt(CredentialProviderBaseController.ACTIVITY_REQUEST_CODE_TAG), i, (Intent) resultData.getParcelable(CredentialProviderBaseController.RESULT_DATA_TAG));
+            }
+        };
+    }
+
+    public final CredentialManagerCallback<androidx.credentials.GetCredentialResponse, GetCredentialException> getCallback() {
+        CredentialManagerCallback<androidx.credentials.GetCredentialResponse, GetCredentialException> credentialManagerCallback = this.callback;
+        if (credentialManagerCallback != null) {
+            return credentialManagerCallback;
+        }
+        Intrinsics.throwUninitializedPropertyAccessException("callback");
+        return null;
+    }
+
+    public final Executor getExecutor() {
+        Executor executor = this.executor;
+        if (executor != null) {
+            return executor;
+        }
+        Intrinsics.throwUninitializedPropertyAccessException("executor");
+        return null;
+    }
+
+    public final void handleResponse$credentials_play_services_auth_release(int i, int i2, Intent intent) {
+        CredentialProviderBaseController.Companion companion = CredentialProviderBaseController.Companion;
+        if (i != companion.getCONTROLLER_REQUEST_CODE$credentials_play_services_auth_release()) {
+            Log.w(TAG, "Returned request code " + companion.getCONTROLLER_REQUEST_CODE$credentials_play_services_auth_release() + " which  does not match what was given " + i);
+            return;
+        }
+        if (CredentialProviderController.maybeReportErrorResultCodeGet(i2, new Function2() { // from class: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetDigitalCredentialController$handleResponse$1
+            @Override // kotlin.jvm.functions.Function2
+            public /* bridge */ /* synthetic */ Object invoke(Object obj, Object obj2) {
+                invoke((CancellationSignal) obj, (Function0) obj2);
+                return Unit.INSTANCE;
+            }
+
+            public final void invoke(CancellationSignal cancellationSignal, Function0 f) {
+                Intrinsics.checkNotNullParameter(f, "f");
+                CredentialProviderController.Companion companion2 = CredentialProviderController.Companion;
+                CredentialProviderController.cancelOrCallbackExceptionOrResult(cancellationSignal, f);
+            }
+        }, new CredentialProviderGetDigitalCredentialController$handleResponse$2(this), this.cancellationSignal)) {
+            return;
+        }
+        if (intent == null) {
+            CredentialProviderController.cancelOrCallbackExceptionOrResult(this.cancellationSignal, new CredentialProviderGetDigitalCredentialController$handleResponse$3(this));
+            return;
+        }
+        PendingIntentHandler.Companion companion2 = PendingIntentHandler.Companion;
+        androidx.credentials.GetCredentialResponse retrieveGetCredentialResponse = companion2.retrieveGetCredentialResponse(intent);
+        if (retrieveGetCredentialResponse != null) {
+            CredentialProviderController.cancelOrCallbackExceptionOrResult(this.cancellationSignal, new CredentialProviderGetDigitalCredentialController$handleResponse$4(this, retrieveGetCredentialResponse));
+        } else {
+            CredentialProviderController.cancelOrCallbackExceptionOrResult(this.cancellationSignal, new CredentialProviderGetDigitalCredentialController$handleResponse$5(this, companion2.retrieveGetCredentialException(intent)));
+        }
+    }
+
+    @Override // androidx.credentials.playservices.controllers.CredentialProviderController
+    public void invokePlayServices(GetCredentialRequest request, final CredentialManagerCallback<androidx.credentials.GetCredentialResponse, GetCredentialException> callback, final Executor executor, final CancellationSignal cancellationSignal) {
+        Intrinsics.checkNotNullParameter(request, "request");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        Intrinsics.checkNotNullParameter(executor, "executor");
+        this.cancellationSignal = cancellationSignal;
+        setCallback(callback);
+        setExecutor(executor);
+        if (CredentialProviderPlayServicesImpl.Companion.cancellationReviewer$credentials_play_services_auth_release(cancellationSignal)) {
+            return;
+        }
+        Task<PendingGetCredentialHandle> credential = IdentityCredentialManager.Companion.getClient(this.context).getCredential(convertRequestToPlayServices(request));
+        final Function1 function1 = new Function1() { // from class: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetDigitalCredentialController$invokePlayServices$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((PendingGetCredentialHandle) obj);
+                return Unit.INSTANCE;
+            }
+
+            public final void invoke(PendingGetCredentialHandle pendingGetCredentialHandle) {
+                Context context;
+                CredentialProviderGetDigitalCredentialController$resultReceiver$1 credentialProviderGetDigitalCredentialController$resultReceiver$1;
+                Context context2;
+                if (CredentialProviderPlayServicesImpl.Companion.cancellationReviewer$credentials_play_services_auth_release(cancellationSignal)) {
+                    return;
+                }
+                context = this.context;
+                Intent intent = new Intent(context, (Class<?>) IdentityCredentialApiHiddenActivity.class);
+                intent.setFlags(65536);
+                CredentialProviderGetDigitalCredentialController credentialProviderGetDigitalCredentialController = this;
+                credentialProviderGetDigitalCredentialController$resultReceiver$1 = credentialProviderGetDigitalCredentialController.resultReceiver;
+                intent.putExtra(CredentialProviderBaseController.RESULT_RECEIVER_TAG, credentialProviderGetDigitalCredentialController.toIpcFriendlyResultReceiver(credentialProviderGetDigitalCredentialController$resultReceiver$1));
+                intent.putExtra(CredentialProviderBaseController.EXTRA_GET_CREDENTIAL_INTENT, pendingGetCredentialHandle.getPendingIntent());
+                context2 = this.context;
+                context2.startActivity(intent);
+            }
+        };
+        credential.addOnSuccessListener(new OnSuccessListener() { // from class: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetDigitalCredentialController$$ExternalSyntheticLambda0
+            @Override // com.google.android.gms.tasks.OnSuccessListener
+            public final void onSuccess(Object obj) {
+                Function1.this.invoke(obj);
+            }
+        }).addOnFailureListener(new OnFailureListener() { // from class: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetDigitalCredentialController$$ExternalSyntheticLambda1
+            @Override // com.google.android.gms.tasks.OnFailureListener
+            public final void onFailure(Exception exc) {
+                CredentialProviderGetDigitalCredentialController.invokePlayServices$lambda$1(CredentialProviderGetDigitalCredentialController.this, cancellationSignal, executor, callback, exc);
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invokePlayServices$lambda$1(CredentialProviderGetDigitalCredentialController credentialProviderGetDigitalCredentialController, CancellationSignal cancellationSignal, Executor executor, CredentialManagerCallback credentialManagerCallback, Exception e) {
+        Intrinsics.checkNotNullParameter(e, "e");
+        CredentialProviderController.cancelOrCallbackExceptionOrResult(cancellationSignal, new CredentialProviderGetDigitalCredentialController$invokePlayServices$2$1(executor, credentialManagerCallback, credentialProviderGetDigitalCredentialController.fromGmsException(e)));
+    }
+
+    private final GetCredentialException fromGmsException(Throwable th) {
+        GetCredentialException getCredentialUnknownException;
+        if (th instanceof com.google.android.gms.identitycredentials.GetCredentialException) {
+            return ConversionUtilsKt.toJetpackGetException(((com.google.android.gms.identitycredentials.GetCredentialException) th).getType(), th.getMessage());
+        }
+        if (th instanceof ApiException) {
+            int statusCode = ((ApiException) th).getStatusCode();
+            if (statusCode == 16) {
+                getCredentialUnknownException = new GetCredentialCancellationException(th.getMessage());
+            } else if (CredentialProviderBaseController.Companion.getRetryables().contains(Integer.valueOf(statusCode))) {
+                getCredentialUnknownException = new GetCredentialInterruptedException(th.getMessage());
+            } else {
+                getCredentialUnknownException = new GetCredentialUnknownException("Get digital credential failed, failure: " + th);
+            }
+        } else {
+            getCredentialUnknownException = new GetCredentialUnknownException("Get digital credential failed, failure: " + th);
+        }
+        return getCredentialUnknownException;
+    }
+
+    @Override // androidx.credentials.playservices.controllers.CredentialProviderController
+    public com.google.android.gms.identitycredentials.GetCredentialRequest convertRequestToPlayServices(GetCredentialRequest request) {
+        Intrinsics.checkNotNullParameter(request, "request");
+        ArrayList arrayList = new ArrayList();
+        for (CredentialOption credentialOption : request.getCredentialOptions()) {
+            if (credentialOption instanceof GetDigitalCredentialOption) {
+                arrayList.add(new com.google.android.gms.identitycredentials.CredentialOption(credentialOption.getType(), credentialOption.getRequestData(), credentialOption.getCandidateQueryData(), ((GetDigitalCredentialOption) credentialOption).getRequestJson(), "", ""));
+            }
+        }
+        return new com.google.android.gms.identitycredentials.GetCredentialRequest(arrayList, GetCredentialRequest.Companion.getRequestMetadataBundle(request), request.getOrigin(), new ResultReceiver(null));
+    }
+
+    @Override // androidx.credentials.playservices.controllers.CredentialProviderController
+    public androidx.credentials.GetCredentialResponse convertResponseToCredentialManager(GetCredentialResponse response) {
+        Intrinsics.checkNotNullParameter(response, "response");
+        return new androidx.credentials.GetCredentialResponse(Credential.Companion.createFrom(DigitalCredential.TYPE_DIGITAL_CREDENTIAL, response.getCredential().getData()));
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/GetRestoreCredential/CredentialProviderGetRestoreCredentialController$invokePlayServices$2$1.java

@@ -0,0 +1,49 @@
+package androidx.credentials.playservices.controllers.GetRestoreCredential;
+
+import androidx.credentials.CredentialManagerCallback;
+import androidx.credentials.GetCredentialResponse;
+import androidx.credentials.exceptions.GetCredentialException;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Lambda;
+import kotlin.jvm.internal.Ref;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderGetRestoreCredentialController$invokePlayServices$2$1 extends Lambda implements Function0 {
+    final /* synthetic */ CredentialManagerCallback<GetCredentialResponse, GetCredentialException> $callback;
+    final /* synthetic */ Executor $executor;
+    final /* synthetic */ Ref.ObjectRef<GetCredentialException> $getException;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderGetRestoreCredentialController$invokePlayServices$2$1(Executor executor, CredentialManagerCallback<GetCredentialResponse, GetCredentialException> credentialManagerCallback, Ref.ObjectRef<GetCredentialException> objectRef) {
+        super(0);
+        this.$executor = executor;
+        this.$callback = credentialManagerCallback;
+        this.$getException = objectRef;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m131invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialManagerCallback credentialManagerCallback, Ref.ObjectRef objectRef) {
+        credentialManagerCallback.onError(objectRef.element);
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m131invoke() {
+        Executor executor = this.$executor;
+        final CredentialManagerCallback<GetCredentialResponse, GetCredentialException> credentialManagerCallback = this.$callback;
+        final Ref.ObjectRef<GetCredentialException> objectRef = this.$getException;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetRestoreCredentialController$invokePlayServices$2$1$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderGetRestoreCredentialController$invokePlayServices$2$1.invoke$lambda$0(CredentialManagerCallback.this, objectRef);
+            }
+        });
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/GetRestoreCredential/CredentialProviderGetRestoreCredentialController.java

@@ -0,0 +1,301 @@
+package androidx.credentials.playservices.controllers.GetRestoreCredential;
+
+import android.content.Context;
+import android.os.CancellationSignal;
+import androidx.credentials.Credential;
+import androidx.credentials.CredentialManagerCallback;
+import androidx.credentials.CredentialOption;
+import androidx.credentials.GetCredentialRequest;
+import androidx.credentials.GetCredentialResponse;
+import androidx.credentials.GetRestoreCredentialOption;
+import androidx.credentials.exceptions.GetCredentialException;
+import androidx.credentials.exceptions.GetCredentialUnknownException;
+import androidx.credentials.exceptions.NoCredentialException;
+import androidx.credentials.playservices.CredentialProviderPlayServicesImpl;
+import androidx.credentials.playservices.controllers.CredentialProviderController;
+import com.google.android.gms.auth.blockstore.restorecredential.GetRestoreCredentialRequest;
+import com.google.android.gms.auth.blockstore.restorecredential.GetRestoreCredentialResponse;
+import com.google.android.gms.auth.blockstore.restorecredential.RestoreCredential;
+import com.google.android.gms.common.api.ApiException;
+import com.google.android.gms.tasks.OnFailureListener;
+import com.google.android.gms.tasks.OnSuccessListener;
+import com.google.android.gms.tasks.Task;
+import java.util.Iterator;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+import kotlin.jvm.internal.Ref;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderGetRestoreCredentialController extends CredentialProviderController<GetCredentialRequest, GetRestoreCredentialRequest, GetRestoreCredentialResponse, GetCredentialResponse, GetCredentialException> {
+    private final Context context;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderGetRestoreCredentialController(Context context) {
+        super(context);
+        Intrinsics.checkNotNullParameter(context, "context");
+        this.context = context;
+    }
+
+    @Override // androidx.credentials.playservices.controllers.CredentialProviderController
+    public void invokePlayServices(GetCredentialRequest request, final CredentialManagerCallback<GetCredentialResponse, GetCredentialException> callback, final Executor executor, final CancellationSignal cancellationSignal) {
+        Intrinsics.checkNotNullParameter(request, "request");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        Intrinsics.checkNotNullParameter(executor, "executor");
+        if (CredentialProviderPlayServicesImpl.Companion.cancellationReviewer$credentials_play_services_auth_release(cancellationSignal)) {
+            return;
+        }
+        Task<GetRestoreCredentialResponse> restoreCredential = RestoreCredential.getRestoreCredentialClient(this.context).getRestoreCredential(convertRequestToPlayServices(request));
+        final Function1 function1 = new Function1() { // from class: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetRestoreCredentialController$invokePlayServices$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((GetRestoreCredentialResponse) obj);
+                return Unit.INSTANCE;
+            }
+
+            /* renamed from: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetRestoreCredentialController$invokePlayServices$1$1, reason: invalid class name */
+            public static final class AnonymousClass1 extends Lambda implements Function0 {
+                final /* synthetic */ CredentialManagerCallback<GetCredentialResponse, GetCredentialException> $callback;
+                final /* synthetic */ Executor $executor;
+                final /* synthetic */ GetCredentialResponse $response;
+
+                /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+                public AnonymousClass1(Executor executor, CredentialManagerCallback<GetCredentialResponse, GetCredentialException> credentialManagerCallback, GetCredentialResponse getCredentialResponse) {
+                    super(0);
+                    this.$executor = executor;
+                    this.$callback = credentialManagerCallback;
+                    this.$response = getCredentialResponse;
+                }
+
+                @Override // kotlin.jvm.functions.Function0
+                public /* bridge */ /* synthetic */ Object invoke() {
+                    m127invoke();
+                    return Unit.INSTANCE;
+                }
+
+                /* renamed from: invoke, reason: collision with other method in class */
+                public final void m127invoke() {
+                    Executor executor = this.$executor;
+                    final CredentialManagerCallback<GetCredentialResponse, GetCredentialException> credentialManagerCallback = this.$callback;
+                    final GetCredentialResponse getCredentialResponse = this.$response;
+                    executor.execute(
+                    /*  JADX ERROR: Method code generation error
+                        jadx.core.utils.exceptions.CodegenException: Error generate insn: 0x000b: INVOKE 
+                          (r0v0 'executor' java.util.concurrent.Executor)
+                          (wrap:java.lang.Runnable:0x0008: CONSTRUCTOR 
+                          (r1v0 'credentialManagerCallback' androidx.credentials.CredentialManagerCallback<androidx.credentials.GetCredentialResponse, androidx.credentials.exceptions.GetCredentialException> A[DONT_INLINE])
+                          (r2v0 'getCredentialResponse' androidx.credentials.GetCredentialResponse A[DONT_INLINE])
+                         A[MD:(androidx.credentials.CredentialManagerCallback, androidx.credentials.GetCredentialResponse):void (m), WRAPPED] (LINE:65) call: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetRestoreCredentialController$invokePlayServices$1$1$$ExternalSyntheticLambda0.<init>(androidx.credentials.CredentialManagerCallback, androidx.credentials.GetCredentialResponse):void type: CONSTRUCTOR)
+                         INTERFACE call: java.util.concurrent.Executor.execute(java.lang.Runnable):void A[MD:(java.lang.Runnable):void (c)] (LINE:65) in method: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetRestoreCredentialController$invokePlayServices$1.1.invoke():void, file: classes.dex
+                        	at jadx.core.codegen.InsnGen.makeInsn(InsnGen.java:310)
+                        	at jadx.core.codegen.InsnGen.makeInsn(InsnGen.java:273)
+                        	at jadx.core.codegen.RegionGen.makeSimpleBlock(RegionGen.java:94)
+                        	at jadx.core.dex.nodes.IBlock.generate(IBlock.java:15)
+                        	at jadx.core.codegen.RegionGen.makeRegion(RegionGen.java:66)
+                        	at jadx.core.dex.regions.Region.generate(Region.java:35)
+                        	at jadx.core.codegen.RegionGen.makeRegion(RegionGen.java:66)
+                        	at jadx.core.codegen.MethodGen.addRegionInsns(MethodGen.java:297)
+                        	at jadx.core.codegen.MethodGen.addInstructions(MethodGen.java:276)
+                        	at jadx.core.codegen.ClassGen.addMethodCode(ClassGen.java:406)
+                        	at jadx.core.codegen.ClassGen.addMethod(ClassGen.java:335)
+                        	at jadx.core.codegen.ClassGen.lambda$addInnerClsAndMethods$3(ClassGen.java:301)
+                        	at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.accept(ForEachOps.java:184)
+                        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
+                        	at java.base/java.util.stream.SortedOps$RefSortingSink.end(SortedOps.java:395)
+                        	at java.base/java.util.stream.Sink$ChainedReference.end(Sink.java:261)
+                        Caused by: jadx.core.utils.exceptions.JadxRuntimeException: Expected class to be processed at this point, class: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetRestoreCredentialController$invokePlayServices$1$1$$ExternalSyntheticLambda0, state: NOT_LOADED
+                        	at jadx.core.dex.nodes.ClassNode.ensureProcessed(ClassNode.java:305)
+                        	at jadx.core.codegen.InsnGen.inlineAnonymousConstructor(InsnGen.java:807)
+                        	at jadx.core.codegen.InsnGen.makeConstructor(InsnGen.java:730)
+                        	at jadx.core.codegen.InsnGen.makeInsnBody(InsnGen.java:418)
+                        	at jadx.core.codegen.InsnGen.addWrappedArg(InsnGen.java:145)
+                        	at jadx.core.codegen.InsnGen.addArg(InsnGen.java:121)
+                        	at jadx.core.codegen.InsnGen.addArg(InsnGen.java:108)
+                        	at jadx.core.codegen.InsnGen.generateMethodArguments(InsnGen.java:1143)
+                        	at jadx.core.codegen.InsnGen.makeInvoke(InsnGen.java:910)
+                        	at jadx.core.codegen.InsnGen.makeInsnBody(InsnGen.java:422)
+                        	at jadx.core.codegen.InsnGen.makeInsn(InsnGen.java:303)
+                        	... 15 more
+                        */
+                    /*
+                        this = this;
+                        java.util.concurrent.Executor r0 = r4.$executor
+                        androidx.credentials.CredentialManagerCallback<androidx.credentials.GetCredentialResponse, androidx.credentials.exceptions.GetCredentialException> r1 = r4.$callback
+                        androidx.credentials.GetCredentialResponse r2 = r4.$response
+                        androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetRestoreCredentialController$invokePlayServices$1$1$$ExternalSyntheticLambda0 r3 = new androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetRestoreCredentialController$invokePlayServices$1$1$$ExternalSyntheticLambda0
+                        r3.<init>(r1, r2)
+                        r0.execute(r3)
+                        return
+                    */
+                    throw new UnsupportedOperationException("Method not decompiled: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetRestoreCredentialController$invokePlayServices$1.AnonymousClass1.m127invoke():void");
+                }
+            }
+
+            public final void invoke(GetRestoreCredentialResponse getRestoreCredentialResponse) {
+                try {
+                    CredentialProviderGetRestoreCredentialController credentialProviderGetRestoreCredentialController = CredentialProviderGetRestoreCredentialController.this;
+                    Intrinsics.checkNotNull(getRestoreCredentialResponse);
+                    GetCredentialResponse convertResponseToCredentialManager = credentialProviderGetRestoreCredentialController.convertResponseToCredentialManager(getRestoreCredentialResponse);
+                    CredentialProviderController.Companion companion = CredentialProviderController.Companion;
+                    CredentialProviderController.cancelOrCallbackExceptionOrResult(cancellationSignal, new AnonymousClass1(executor, callback, convertResponseToCredentialManager));
+                } catch (Exception e) {
+                    CredentialProviderController.Companion companion2 = CredentialProviderController.Companion;
+                    CredentialProviderController.cancelOrCallbackExceptionOrResult(cancellationSignal, new AnonymousClass2(executor, callback, e));
+                }
+            }
+
+            /* renamed from: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetRestoreCredentialController$invokePlayServices$1$2, reason: invalid class name */
+            public static final class AnonymousClass2 extends Lambda implements Function0 {
+                final /* synthetic */ CredentialManagerCallback<GetCredentialResponse, GetCredentialException> $callback;
+                final /* synthetic */ Exception $e;
+                final /* synthetic */ Executor $executor;
+
+                /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+                public AnonymousClass2(Executor executor, CredentialManagerCallback<GetCredentialResponse, GetCredentialException> credentialManagerCallback, Exception exc) {
+                    super(0);
+                    this.$executor = executor;
+                    this.$callback = credentialManagerCallback;
+                    this.$e = exc;
+                }
+
+                @Override // kotlin.jvm.functions.Function0
+                public /* bridge */ /* synthetic */ Object invoke() {
+                    m129invoke();
+                    return Unit.INSTANCE;
+                }
+
+                /* renamed from: invoke, reason: collision with other method in class */
+                public final void m129invoke() {
+                    Executor executor = this.$executor;
+                    final CredentialManagerCallback<GetCredentialResponse, GetCredentialException> credentialManagerCallback = this.$callback;
+                    final Exception exc = this.$e;
+                    executor.execute(
+                    /*  JADX ERROR: Method code generation error
+                        jadx.core.utils.exceptions.CodegenException: Error generate insn: 0x000b: INVOKE 
+                          (r0v0 'executor' java.util.concurrent.Executor)
+                          (wrap:java.lang.Runnable:0x0008: CONSTRUCTOR 
+                          (r1v0 'credentialManagerCallback' androidx.credentials.CredentialManagerCallback<androidx.credentials.GetCredentialResponse, androidx.credentials.exceptions.GetCredentialException> A[DONT_INLINE])
+                          (r2v0 'exc' java.lang.Exception A[DONT_INLINE])
+                         A[MD:(androidx.credentials.CredentialManagerCallback, java.lang.Exception):void (m), WRAPPED] (LINE:69) call: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetRestoreCredentialController$invokePlayServices$1$2$$ExternalSyntheticLambda0.<init>(androidx.credentials.CredentialManagerCallback, java.lang.Exception):void type: CONSTRUCTOR)
+                         INTERFACE call: java.util.concurrent.Executor.execute(java.lang.Runnable):void A[MD:(java.lang.Runnable):void (c)] (LINE:69) in method: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetRestoreCredentialController$invokePlayServices$1.2.invoke():void, file: classes.dex
+                        	at jadx.core.codegen.InsnGen.makeInsn(InsnGen.java:310)
+                        	at jadx.core.codegen.InsnGen.makeInsn(InsnGen.java:273)
+                        	at jadx.core.codegen.RegionGen.makeSimpleBlock(RegionGen.java:94)
+                        	at jadx.core.dex.nodes.IBlock.generate(IBlock.java:15)
+                        	at jadx.core.codegen.RegionGen.makeRegion(RegionGen.java:66)
+                        	at jadx.core.dex.regions.Region.generate(Region.java:35)
+                        	at jadx.core.codegen.RegionGen.makeRegion(RegionGen.java:66)
+                        	at jadx.core.codegen.MethodGen.addRegionInsns(MethodGen.java:297)
+                        	at jadx.core.codegen.MethodGen.addInstructions(MethodGen.java:276)
+                        	at jadx.core.codegen.ClassGen.addMethodCode(ClassGen.java:406)
+                        	at jadx.core.codegen.ClassGen.addMethod(ClassGen.java:335)
+                        	at jadx.core.codegen.ClassGen.lambda$addInnerClsAndMethods$3(ClassGen.java:301)
+                        	at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.accept(ForEachOps.java:184)
+                        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
+                        	at java.base/java.util.stream.SortedOps$RefSortingSink.end(SortedOps.java:395)
+                        	at java.base/java.util.stream.Sink$ChainedReference.end(Sink.java:261)
+                        Caused by: jadx.core.utils.exceptions.JadxRuntimeException: Expected class to be processed at this point, class: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetRestoreCredentialController$invokePlayServices$1$2$$ExternalSyntheticLambda0, state: NOT_LOADED
+                        	at jadx.core.dex.nodes.ClassNode.ensureProcessed(ClassNode.java:305)
+                        	at jadx.core.codegen.InsnGen.inlineAnonymousConstructor(InsnGen.java:807)
+                        	at jadx.core.codegen.InsnGen.makeConstructor(InsnGen.java:730)
+                        	at jadx.core.codegen.InsnGen.makeInsnBody(InsnGen.java:418)
+                        	at jadx.core.codegen.InsnGen.addWrappedArg(InsnGen.java:145)
+                        	at jadx.core.codegen.InsnGen.addArg(InsnGen.java:121)
+                        	at jadx.core.codegen.InsnGen.addArg(InsnGen.java:108)
+                        	at jadx.core.codegen.InsnGen.generateMethodArguments(InsnGen.java:1143)
+                        	at jadx.core.codegen.InsnGen.makeInvoke(InsnGen.java:910)
+                        	at jadx.core.codegen.InsnGen.makeInsnBody(InsnGen.java:422)
+                        	at jadx.core.codegen.InsnGen.makeInsn(InsnGen.java:303)
+                        	... 15 more
+                        */
+                    /*
+                        this = this;
+                        java.util.concurrent.Executor r0 = r4.$executor
+                        androidx.credentials.CredentialManagerCallback<androidx.credentials.GetCredentialResponse, androidx.credentials.exceptions.GetCredentialException> r1 = r4.$callback
+                        java.lang.Exception r2 = r4.$e
+                        androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetRestoreCredentialController$invokePlayServices$1$2$$ExternalSyntheticLambda0 r3 = new androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetRestoreCredentialController$invokePlayServices$1$2$$ExternalSyntheticLambda0
+                        r3.<init>(r1, r2)
+                        r0.execute(r3)
+                        return
+                    */
+                    throw new UnsupportedOperationException("Method not decompiled: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetRestoreCredentialController$invokePlayServices$1.AnonymousClass2.m129invoke():void");
+                }
+
+                /* JADX INFO: Access modifiers changed from: private */
+                public static final void invoke$lambda$0(CredentialManagerCallback credentialManagerCallback, Exception exc) {
+                    credentialManagerCallback.onError(exc instanceof NoCredentialException ? (GetCredentialException) exc : new GetCredentialUnknownException(exc.getMessage()));
+                }
+            }
+        };
+        restoreCredential.addOnSuccessListener(new OnSuccessListener() { // from class: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetRestoreCredentialController$$ExternalSyntheticLambda0
+            @Override // com.google.android.gms.tasks.OnSuccessListener
+            public final void onSuccess(Object obj) {
+                Function1.this.invoke(obj);
+            }
+        }).addOnFailureListener(new OnFailureListener() { // from class: androidx.credentials.playservices.controllers.GetRestoreCredential.CredentialProviderGetRestoreCredentialController$$ExternalSyntheticLambda1
+            @Override // com.google.android.gms.tasks.OnFailureListener
+            public final void onFailure(Exception exc) {
+                CredentialProviderGetRestoreCredentialController.invokePlayServices$lambda$1(cancellationSignal, executor, callback, exc);
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* JADX WARN: Type inference failed for: r1v0, types: [T, androidx.credentials.exceptions.GetCredentialUnknownException] */
+    /* JADX WARN: Type inference failed for: r1v4, types: [T, androidx.credentials.exceptions.GetCredentialUnknownException] */
+    /* JADX WARN: Type inference failed for: r2v3, types: [T, androidx.credentials.exceptions.GetCredentialUnknownException] */
+    public static final void invokePlayServices$lambda$1(CancellationSignal cancellationSignal, Executor executor, CredentialManagerCallback credentialManagerCallback, Exception e) {
+        Intrinsics.checkNotNullParameter(e, "e");
+        Ref.ObjectRef objectRef = new Ref.ObjectRef();
+        objectRef.element = new GetCredentialUnknownException("Get restore credential failed for unknown reason, failure: " + e.getMessage());
+        if (e instanceof ApiException) {
+            ApiException apiException = (ApiException) e;
+            if (apiException.getStatusCode() == 40201) {
+                objectRef.element = new GetCredentialUnknownException("The restore credential internal service had a failure, failure: " + e.getMessage());
+            } else {
+                objectRef.element = new GetCredentialUnknownException("The restore credential service failed with unsupported status code, failure: " + e.getMessage() + ", status code: " + apiException.getStatusCode());
+            }
+        }
+        CredentialProviderController.cancelOrCallbackExceptionOrResult(cancellationSignal, new CredentialProviderGetRestoreCredentialController$invokePlayServices$2$1(executor, credentialManagerCallback, objectRef));
+    }
+
+    @Override // androidx.credentials.playservices.controllers.CredentialProviderController
+    public GetRestoreCredentialRequest convertRequestToPlayServices(GetCredentialRequest request) {
+        GetRestoreCredentialOption getRestoreCredentialOption;
+        GetRestoreCredentialOption getRestoreCredentialOption2;
+        Intrinsics.checkNotNullParameter(request, "request");
+        Iterator<CredentialOption> it = request.getCredentialOptions().iterator();
+        while (true) {
+            getRestoreCredentialOption = null;
+            if (!it.hasNext()) {
+                getRestoreCredentialOption2 = null;
+                break;
+            }
+            CredentialOption next = it.next();
+            if (next instanceof GetRestoreCredentialOption) {
+                getRestoreCredentialOption2 = (GetRestoreCredentialOption) next;
+                break;
+            }
+        }
+        if (getRestoreCredentialOption2 == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("credentialOption");
+        } else {
+            getRestoreCredentialOption = getRestoreCredentialOption2;
+        }
+        return new GetRestoreCredentialRequest(getRestoreCredentialOption.getRequestData());
+    }
+
+    @Override // androidx.credentials.playservices.controllers.CredentialProviderController
+    public GetCredentialResponse convertResponseToCredentialManager(GetRestoreCredentialResponse response) {
+        Intrinsics.checkNotNullParameter(response, "response");
+        return new GetCredentialResponse(Credential.Companion.createFrom(androidx.credentials.RestoreCredential.TYPE_RESTORE_CREDENTIAL, response.getResponseBundle()));
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/GetSignInIntent/CredentialProviderGetSignInIntentController$handleResponse$2.java

@@ -0,0 +1,42 @@
+package androidx.credentials.playservices.controllers.GetSignInIntent;
+
+import androidx.credentials.exceptions.GetCredentialException;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderGetSignInIntentController$handleResponse$2 extends Lambda implements Function1 {
+    final /* synthetic */ CredentialProviderGetSignInIntentController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderGetSignInIntentController$handleResponse$2(CredentialProviderGetSignInIntentController credentialProviderGetSignInIntentController) {
+        super(1);
+        this.this$0 = credentialProviderGetSignInIntentController;
+    }
+
+    @Override // kotlin.jvm.functions.Function1
+    public /* bridge */ /* synthetic */ Object invoke(Object obj) {
+        invoke((GetCredentialException) obj);
+        return Unit.INSTANCE;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderGetSignInIntentController credentialProviderGetSignInIntentController, GetCredentialException getCredentialException) {
+        credentialProviderGetSignInIntentController.getCallback().onError(getCredentialException);
+    }
+
+    public final void invoke(final GetCredentialException e) {
+        Intrinsics.checkNotNullParameter(e, "e");
+        Executor executor = this.this$0.getExecutor();
+        final CredentialProviderGetSignInIntentController credentialProviderGetSignInIntentController = this.this$0;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.GetSignInIntent.CredentialProviderGetSignInIntentController$handleResponse$2$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderGetSignInIntentController$handleResponse$2.invoke$lambda$0(CredentialProviderGetSignInIntentController.this, e);
+            }
+        });
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/GetSignInIntent/CredentialProviderGetSignInIntentController$handleResponse$3.java

@@ -0,0 +1,44 @@
+package androidx.credentials.playservices.controllers.GetSignInIntent;
+
+import androidx.credentials.GetCredentialResponse;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderGetSignInIntentController$handleResponse$3 extends Lambda implements Function0 {
+    final /* synthetic */ GetCredentialResponse $response;
+    final /* synthetic */ CredentialProviderGetSignInIntentController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderGetSignInIntentController$handleResponse$3(CredentialProviderGetSignInIntentController credentialProviderGetSignInIntentController, GetCredentialResponse getCredentialResponse) {
+        super(0);
+        this.this$0 = credentialProviderGetSignInIntentController;
+        this.$response = getCredentialResponse;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m134invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderGetSignInIntentController credentialProviderGetSignInIntentController, GetCredentialResponse getCredentialResponse) {
+        credentialProviderGetSignInIntentController.getCallback().onResult(getCredentialResponse);
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m134invoke() {
+        Executor executor = this.this$0.getExecutor();
+        final CredentialProviderGetSignInIntentController credentialProviderGetSignInIntentController = this.this$0;
+        final GetCredentialResponse getCredentialResponse = this.$response;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.GetSignInIntent.CredentialProviderGetSignInIntentController$handleResponse$3$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderGetSignInIntentController$handleResponse$3.invoke$lambda$0(CredentialProviderGetSignInIntentController.this, getCredentialResponse);
+            }
+        });
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/GetSignInIntent/CredentialProviderGetSignInIntentController$handleResponse$4.java

@@ -0,0 +1,46 @@
+package androidx.credentials.playservices.controllers.GetSignInIntent;
+
+import androidx.credentials.exceptions.GetCredentialException;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Lambda;
+import kotlin.jvm.internal.Ref;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderGetSignInIntentController$handleResponse$4 extends Lambda implements Function0 {
+    final /* synthetic */ Ref.ObjectRef<GetCredentialException> $exception;
+    final /* synthetic */ CredentialProviderGetSignInIntentController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderGetSignInIntentController$handleResponse$4(CredentialProviderGetSignInIntentController credentialProviderGetSignInIntentController, Ref.ObjectRef<GetCredentialException> objectRef) {
+        super(0);
+        this.this$0 = credentialProviderGetSignInIntentController;
+        this.$exception = objectRef;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m135invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* JADX WARN: Multi-variable type inference failed */
+    public static final void invoke$lambda$0(CredentialProviderGetSignInIntentController credentialProviderGetSignInIntentController, Ref.ObjectRef objectRef) {
+        credentialProviderGetSignInIntentController.getCallback().onError(objectRef.element);
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m135invoke() {
+        Executor executor = this.this$0.getExecutor();
+        final CredentialProviderGetSignInIntentController credentialProviderGetSignInIntentController = this.this$0;
+        final Ref.ObjectRef<GetCredentialException> objectRef = this.$exception;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.GetSignInIntent.CredentialProviderGetSignInIntentController$handleResponse$4$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderGetSignInIntentController$handleResponse$4.invoke$lambda$0(CredentialProviderGetSignInIntentController.this, objectRef);
+            }
+        });
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/GetSignInIntent/CredentialProviderGetSignInIntentController$handleResponse$5.java

@@ -0,0 +1,44 @@
+package androidx.credentials.playservices.controllers.GetSignInIntent;
+
+import androidx.credentials.exceptions.GetCredentialException;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderGetSignInIntentController$handleResponse$5 extends Lambda implements Function0 {
+    final /* synthetic */ GetCredentialException $e;
+    final /* synthetic */ CredentialProviderGetSignInIntentController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderGetSignInIntentController$handleResponse$5(CredentialProviderGetSignInIntentController credentialProviderGetSignInIntentController, GetCredentialException getCredentialException) {
+        super(0);
+        this.this$0 = credentialProviderGetSignInIntentController;
+        this.$e = getCredentialException;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m136invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderGetSignInIntentController credentialProviderGetSignInIntentController, GetCredentialException getCredentialException) {
+        credentialProviderGetSignInIntentController.getCallback().onError(getCredentialException);
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m136invoke() {
+        Executor executor = this.this$0.getExecutor();
+        final CredentialProviderGetSignInIntentController credentialProviderGetSignInIntentController = this.this$0;
+        final GetCredentialException getCredentialException = this.$e;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.GetSignInIntent.CredentialProviderGetSignInIntentController$handleResponse$5$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderGetSignInIntentController$handleResponse$5.invoke$lambda$0(CredentialProviderGetSignInIntentController.this, getCredentialException);
+            }
+        });
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/GetSignInIntent/CredentialProviderGetSignInIntentController$handleResponse$6.java

@@ -0,0 +1,44 @@
+package androidx.credentials.playservices.controllers.GetSignInIntent;
+
+import androidx.credentials.exceptions.GetCredentialUnknownException;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderGetSignInIntentController$handleResponse$6 extends Lambda implements Function0 {
+    final /* synthetic */ GetCredentialUnknownException $e;
+    final /* synthetic */ CredentialProviderGetSignInIntentController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderGetSignInIntentController$handleResponse$6(CredentialProviderGetSignInIntentController credentialProviderGetSignInIntentController, GetCredentialUnknownException getCredentialUnknownException) {
+        super(0);
+        this.this$0 = credentialProviderGetSignInIntentController;
+        this.$e = getCredentialUnknownException;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m137invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderGetSignInIntentController credentialProviderGetSignInIntentController, GetCredentialUnknownException getCredentialUnknownException) {
+        credentialProviderGetSignInIntentController.getCallback().onError(getCredentialUnknownException);
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m137invoke() {
+        Executor executor = this.this$0.getExecutor();
+        final CredentialProviderGetSignInIntentController credentialProviderGetSignInIntentController = this.this$0;
+        final GetCredentialUnknownException getCredentialUnknownException = this.$e;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.GetSignInIntent.CredentialProviderGetSignInIntentController$handleResponse$6$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderGetSignInIntentController$handleResponse$6.invoke$lambda$0(CredentialProviderGetSignInIntentController.this, getCredentialUnknownException);
+            }
+        });
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/GetSignInIntent/CredentialProviderGetSignInIntentController$invokePlayServices$1.java

@@ -0,0 +1,44 @@
+package androidx.credentials.playservices.controllers.GetSignInIntent;
+
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderGetSignInIntentController$invokePlayServices$1 extends Lambda implements Function0 {
+    final /* synthetic */ Exception $e;
+    final /* synthetic */ CredentialProviderGetSignInIntentController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderGetSignInIntentController$invokePlayServices$1(CredentialProviderGetSignInIntentController credentialProviderGetSignInIntentController, Exception exc) {
+        super(0);
+        this.this$0 = credentialProviderGetSignInIntentController;
+        this.$e = exc;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m138invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* JADX WARN: Multi-variable type inference failed */
+    public static final void invoke$lambda$0(CredentialProviderGetSignInIntentController credentialProviderGetSignInIntentController, Exception exc) {
+        credentialProviderGetSignInIntentController.getCallback().onError(exc);
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m138invoke() {
+        Executor executor = this.this$0.getExecutor();
+        final CredentialProviderGetSignInIntentController credentialProviderGetSignInIntentController = this.this$0;
+        final Exception exc = this.$e;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.GetSignInIntent.CredentialProviderGetSignInIntentController$invokePlayServices$1$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderGetSignInIntentController$invokePlayServices$1.invoke$lambda$0(CredentialProviderGetSignInIntentController.this, exc);
+            }
+        });
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/GetSignInIntent/CredentialProviderGetSignInIntentController$invokePlayServices$2.java

@@ -0,0 +1,42 @@
+package androidx.credentials.playservices.controllers.GetSignInIntent;
+
+import androidx.credentials.exceptions.GetCredentialUnknownException;
+import androidx.credentials.playservices.controllers.CredentialProviderController;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderGetSignInIntentController$invokePlayServices$2 extends Lambda implements Function0 {
+    final /* synthetic */ CredentialProviderGetSignInIntentController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CredentialProviderGetSignInIntentController$invokePlayServices$2(CredentialProviderGetSignInIntentController credentialProviderGetSignInIntentController) {
+        super(0);
+        this.this$0 = credentialProviderGetSignInIntentController;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public /* bridge */ /* synthetic */ Object invoke() {
+        m139invoke();
+        return Unit.INSTANCE;
+    }
+
+    /* renamed from: invoke, reason: collision with other method in class */
+    public final void m139invoke() {
+        Executor executor = this.this$0.getExecutor();
+        final CredentialProviderGetSignInIntentController credentialProviderGetSignInIntentController = this.this$0;
+        executor.execute(new Runnable() { // from class: androidx.credentials.playservices.controllers.GetSignInIntent.CredentialProviderGetSignInIntentController$invokePlayServices$2$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CredentialProviderGetSignInIntentController$invokePlayServices$2.invoke$lambda$0(CredentialProviderGetSignInIntentController.this);
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void invoke$lambda$0(CredentialProviderGetSignInIntentController credentialProviderGetSignInIntentController) {
+        credentialProviderGetSignInIntentController.getCallback().onError(new GetCredentialUnknownException(CredentialProviderController.ERROR_MESSAGE_START_ACTIVITY_FAILED));
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/GetSignInIntent/CredentialProviderGetSignInIntentController$resultReceiver$1$onReceiveResult$1.java

@@ -0,0 +1,18 @@
+package androidx.credentials.playservices.controllers.GetSignInIntent;
+
+import androidx.credentials.exceptions.GetCredentialException;
+import androidx.credentials.playservices.controllers.CredentialProviderBaseController;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.FunctionReferenceImpl;
+
+/* loaded from: classes.dex */
+public /* synthetic */ class CredentialProviderGetSignInIntentController$resultReceiver$1$onReceiveResult$1 extends FunctionReferenceImpl implements Function2 {
+    public CredentialProviderGetSignInIntentController$resultReceiver$1$onReceiveResult$1(Object obj) {
+        super(2, obj, CredentialProviderBaseController.Companion.class, "getCredentialExceptionTypeToException", "getCredentialExceptionTypeToException$credentials_play_services_auth_release(Ljava/lang/String;Ljava/lang/String;)Landroidx/credentials/exceptions/GetCredentialException;", 0);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final GetCredentialException invoke(String str, String str2) {
+        return ((CredentialProviderBaseController.Companion) this.receiver).getCredentialExceptionTypeToException$credentials_play_services_auth_release(str, str2);
+    }
+}

decompiled/sources/androidx/credentials/playservices/controllers/GetSignInIntent/CredentialProviderGetSignInIntentController.java

@@ -0,0 +1,266 @@
+package androidx.credentials.playservices.controllers.GetSignInIntent;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.CancellationSignal;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.ResultReceiver;
+import android.util.Log;
+import androidx.annotation.VisibleForTesting;
+import androidx.credentials.CredentialManagerCallback;
+import androidx.credentials.CredentialOption;
+import androidx.credentials.GetCredentialRequest;
+import androidx.credentials.GetCredentialResponse;
+import androidx.credentials.exceptions.GetCredentialCancellationException;
+import androidx.credentials.exceptions.GetCredentialException;
+import androidx.credentials.exceptions.GetCredentialInterruptedException;
+import androidx.credentials.exceptions.GetCredentialUnknownException;
+import androidx.credentials.exceptions.GetCredentialUnsupportedException;
+import androidx.credentials.playservices.CredentialProviderPlayServicesImpl;
+import androidx.credentials.playservices.HiddenActivity;
+import androidx.credentials.playservices.controllers.CredentialProviderBaseController;
+import androidx.credentials.playservices.controllers.CredentialProviderController;
+import com.google.android.gms.auth.api.identity.GetSignInIntentRequest;
+import com.google.android.gms.auth.api.identity.Identity;
+import com.google.android.gms.auth.api.identity.SignInCredential;
+import com.google.android.gms.common.api.ApiException;
+import com.google.android.libraries.identity.googleid.GetSignInWithGoogleOption;
+import com.google.android.libraries.identity.googleid.GoogleIdTokenCredential;
+import java.util.concurrent.Executor;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Ref;
+
+/* loaded from: classes.dex */
+public final class CredentialProviderGetSignInIntentController extends CredentialProviderController<GetCredentialRequest, GetSignInIntentRequest, SignInCredential, GetCredentialResponse, GetCredentialException> {
+    public static final Companion Companion = new Companion(null);
+    private static final String TAG = "GetSignInIntent";
+    public CredentialManagerCallback<GetCredentialResponse, GetCredentialException> callback;
+    private CancellationSignal cancellationSignal;
+    private final Context context;
+    public Executor executor;
+    private final CredentialProviderGetSignInIntentController$resultReceiver$1 resultReceiver;
+
+    @VisibleForTesting
+    public static /* synthetic */ void getCallback$annotations() {
+    }
+
+    @VisibleForTesting
+    private static /* synthetic */ void getCancellationSignal$annotations() {
+    }
+
+    @VisibleForTesting
+    public static /* synthetic */ void getExecutor$annotations() {
+    }
+
+    public static final CredentialProviderGetSignInIntentController getInstance(Context context) {
+        return Companion.getInstance(context);
+    }
+
+    public final void setCallback(CredentialManagerCallback<GetCredentialResponse, GetCredentialException> credentialManagerCallback) {
+        Intrinsics.checkNotNullParameter(credentialManagerCallback, "<set-?>");
+        this.callback = credentialManagerCallback;
+    }
+
+    public final void setExecutor(Executor executor) {
+        Intrinsics.checkNotNullParameter(executor, "<set-?>");
+        this.executor = executor;
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    /* JADX WARN: Type inference failed for: r0v2, types: [androidx.credentials.playservices.controllers.GetSignInIntent.CredentialProviderGetSignInIntentController$resultReceiver$1] */
+    public CredentialProviderGetSignInIntentController(Context context) {
+        super(context);
+        Intrinsics.checkNotNullParameter(context, "context");
+        this.context = context;
+        final Handler handler = new Handler(Looper.getMainLooper());
+        this.resultReceiver = new ResultReceiver(handler) { // from class: androidx.credentials.playservices.controllers.GetSignInIntent.CredentialProviderGetSignInIntentController$resultReceiver$1
+            @Override // android.os.ResultReceiver
+            public void onReceiveResult(int i, Bundle resultData) {
+                CancellationSignal cancellationSignal;
+                boolean maybeReportErrorFromResultReceiver;
+                Intrinsics.checkNotNullParameter(resultData, "resultData");
+                CredentialProviderGetSignInIntentController credentialProviderGetSignInIntentController = CredentialProviderGetSignInIntentController.this;
+                CredentialProviderGetSignInIntentController$resultReceiver$1$onReceiveResult$1 credentialProviderGetSignInIntentController$resultReceiver$1$onReceiveResult$1 = new CredentialProviderGetSignInIntentController$resultReceiver$1$onReceiveResult$1(CredentialProviderBaseController.Companion);
+                Executor executor = CredentialProviderGetSignInIntentController.this.getExecutor();
+                CredentialManagerCallback<GetCredentialResponse, GetCredentialException> callback = CredentialProviderGetSignInIntentController.this.getCallback();
+                cancellationSignal = CredentialProviderGetSignInIntentController.this.cancellationSignal;
+                maybeReportErrorFromResultReceiver = credentialProviderGetSignInIntentController.maybeReportErrorFromResultReceiver(resultData, credentialProviderGetSignInIntentController$resultReceiver$1$onReceiveResult$1, executor, callback, cancellationSignal);
+                if (maybeReportErrorFromResultReceiver) {
+                    return;
+                }
+                CredentialProviderGetSignInIntentController.this.handleResponse$credentials_play_services_auth_release(resultData.getInt(CredentialProviderBaseController.ACTIVITY_REQUEST_CODE_TAG), i, (Intent) resultData.getParcelable(CredentialProviderBaseController.RESULT_DATA_TAG));
+            }
+        };
+    }
+
+    public final CredentialManagerCallback<GetCredentialResponse, GetCredentialException> getCallback() {
+        CredentialManagerCallback<GetCredentialResponse, GetCredentialException> credentialManagerCallback = this.callback;
+        if (credentialManagerCallback != null) {
+            return credentialManagerCallback;
+        }
+        Intrinsics.throwUninitializedPropertyAccessException("callback");
+        return null;
+    }
+
+    public final Executor getExecutor() {
+        Executor executor = this.executor;
+        if (executor != null) {
+            return executor;
+        }
+        Intrinsics.throwUninitializedPropertyAccessException("executor");
+        return null;
+    }
+
+    @Override // androidx.credentials.playservices.controllers.CredentialProviderController
+    public void invokePlayServices(GetCredentialRequest request, CredentialManagerCallback<GetCredentialResponse, GetCredentialException> callback, Executor executor, CancellationSignal cancellationSignal) {
+        Intrinsics.checkNotNullParameter(request, "request");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        Intrinsics.checkNotNullParameter(executor, "executor");
+        this.cancellationSignal = cancellationSignal;
+        setCallback(callback);
+        setExecutor(executor);
+        if (CredentialProviderPlayServicesImpl.Companion.cancellationReviewer$credentials_play_services_auth_release(cancellationSignal)) {
+            return;
+        }
+        try {
+            GetSignInIntentRequest convertRequestToPlayServices = convertRequestToPlayServices(request);
+            Intent intent = new Intent(this.context, (Class<?>) HiddenActivity.class);
+            intent.putExtra(CredentialProviderBaseController.REQUEST_TAG, convertRequestToPlayServices);
+            generateHiddenActivityIntent(this.resultReceiver, intent, CredentialProviderBaseController.SIGN_IN_INTENT_TAG);
+            this.context.startActivity(intent);
+        } catch (Exception e) {
+            if (e instanceof GetCredentialUnsupportedException) {
+                CredentialProviderController.cancelOrCallbackExceptionOrResult(cancellationSignal, new CredentialProviderGetSignInIntentController$invokePlayServices$1(this, e));
+            } else {
+                CredentialProviderController.cancelOrCallbackExceptionOrResult(cancellationSignal, new CredentialProviderGetSignInIntentController$invokePlayServices$2(this));
+            }
+        }
+    }
+
+    @Override // androidx.credentials.playservices.controllers.CredentialProviderController
+    @VisibleForTesting
+    public GetSignInIntentRequest convertRequestToPlayServices(GetCredentialRequest request) {
+        Intrinsics.checkNotNullParameter(request, "request");
+        if (request.getCredentialOptions().size() != 1) {
+            throw new GetCredentialUnsupportedException("GetSignInWithGoogleOption cannot be combined with other options.");
+        }
+        CredentialOption credentialOption = request.getCredentialOptions().get(0);
+        Intrinsics.checkNotNull(credentialOption, "null cannot be cast to non-null type com.google.android.libraries.identity.googleid.GetSignInWithGoogleOption");
+        GetSignInWithGoogleOption getSignInWithGoogleOption = (GetSignInWithGoogleOption) credentialOption;
+        GetSignInIntentRequest build = GetSignInIntentRequest.builder().setServerClientId(getSignInWithGoogleOption.getServerClientId()).filterByHostedDomain(getSignInWithGoogleOption.getHostedDomainFilter()).setNonce(getSignInWithGoogleOption.getNonce()).build();
+        Intrinsics.checkNotNullExpressionValue(build, "build(...)");
+        return build;
+    }
+
+    @Override // androidx.credentials.playservices.controllers.CredentialProviderController
+    public GetCredentialResponse convertResponseToCredentialManager(SignInCredential response) {
+        GoogleIdTokenCredential googleIdTokenCredential;
+        Intrinsics.checkNotNullParameter(response, "response");
+        if (response.getGoogleIdToken() != null) {
+            googleIdTokenCredential = createGoogleIdCredential(response);
+        } else {
+            Log.w(TAG, "Credential returned but no google Id found");
+            googleIdTokenCredential = null;
+        }
+        if (googleIdTokenCredential == null) {
+            throw new GetCredentialUnknownException("When attempting to convert get response, null credential found");
+        }
+        return new GetCredentialResponse(googleIdTokenCredential);
+    }
+
+    @VisibleForTesting
+    public final GoogleIdTokenCredential createGoogleIdCredential(SignInCredential response) {
+        Intrinsics.checkNotNullParameter(response, "response");
+        GoogleIdTokenCredential.Builder builder = new GoogleIdTokenCredential.Builder();
+        String id = response.getId();
+        Intrinsics.checkNotNullExpressionValue(id, "getId(...)");
+        GoogleIdTokenCredential.Builder id2 = builder.setId(id);
+        try {
+            String googleIdToken = response.getGoogleIdToken();
+            Intrinsics.checkNotNull(googleIdToken);
+            id2.setIdToken(googleIdToken);
+            if (response.getDisplayName() != null) {
+                id2.setDisplayName(response.getDisplayName());
+            }
+            if (response.getGivenName() != null) {
+                id2.setGivenName(response.getGivenName());
+            }
+            if (response.getFamilyName() != null) {
+                id2.setFamilyName(response.getFamilyName());
+            }
+            if (response.getPhoneNumber() != null) {
+                id2.setPhoneNumber(response.getPhoneNumber());
+            }
+            if (response.getProfilePictureUri() != null) {
+                id2.setProfilePictureUri(response.getProfilePictureUri());
+            }
+            return id2.build();
+        } catch (Exception unused) {
+            throw new GetCredentialUnknownException("When attempting to convert get response, null Google ID Token found");
+        }
+    }
+
+    /* JADX WARN: Type inference failed for: r5v2, types: [T, androidx.credentials.exceptions.GetCredentialUnknownException] */
+    /* JADX WARN: Type inference failed for: r5v7, types: [T, androidx.credentials.exceptions.GetCredentialInterruptedException] */
+    /* JADX WARN: Type inference failed for: r5v9, types: [T, androidx.credentials.exceptions.GetCredentialCancellationException] */
+    public final void handleResponse$credentials_play_services_auth_release(int i, int i2, Intent intent) {
+        CredentialProviderBaseController.Companion companion = CredentialProviderBaseController.Companion;
+        if (i != companion.getCONTROLLER_REQUEST_CODE$credentials_play_services_auth_release()) {
+            Log.w(TAG, "Returned request code " + companion.getCONTROLLER_REQUEST_CODE$credentials_play_services_auth_release() + " which  does not match what was given " + i);
+            return;
+        }
+        if (CredentialProviderController.maybeReportErrorResultCodeGet(i2, new Function2() { // from class: androidx.credentials.playservices.controllers.GetSignInIntent.CredentialProviderGetSignInIntentController$handleResponse$1
+            @Override // kotlin.jvm.functions.Function2
+            public /* bridge */ /* synthetic */ Object invoke(Object obj, Object obj2) {
+                invoke((CancellationSignal) obj, (Function0) obj2);
+                return Unit.INSTANCE;
+            }
+
+            public final void invoke(CancellationSignal cancellationSignal, Function0 f) {
+                Intrinsics.checkNotNullParameter(f, "f");
+                CredentialProviderController.Companion companion2 = CredentialProviderController.Companion;
+                CredentialProviderController.cancelOrCallbackExceptionOrResult(cancellationSignal, f);
+            }
+        }, new CredentialProviderGetSignInIntentController$handleResponse$2(this), this.cancellationSignal)) {
+            return;
+        }
+        try {
+            SignInCredential signInCredentialFromIntent = Identity.getSignInClient(this.context).getSignInCredentialFromIntent(intent);
+            Intrinsics.checkNotNullExpressionValue(signInCredentialFromIntent, "getSignInCredentialFromIntent(...)");
+            CredentialProviderController.cancelOrCallbackExceptionOrResult(this.cancellationSignal, new CredentialProviderGetSignInIntentController$handleResponse$3(this, convertResponseToCredentialManager(signInCredentialFromIntent)));
+        } catch (GetCredentialException e) {
+            CredentialProviderController.cancelOrCallbackExceptionOrResult(this.cancellationSignal, new CredentialProviderGetSignInIntentController$handleResponse$5(this, e));
+        } catch (ApiException e2) {
+            Ref.ObjectRef objectRef = new Ref.ObjectRef();
+            objectRef.element = new GetCredentialUnknownException(e2.getMessage());
+            if (e2.getStatusCode() == 16) {
+                objectRef.element = new GetCredentialCancellationException(e2.getMessage());
+            } else if (CredentialProviderBaseController.Companion.getRetryables().contains(Integer.valueOf(e2.getStatusCode()))) {
+                objectRef.element = new GetCredentialInterruptedException(e2.getMessage());
+            }
+            CredentialProviderController.cancelOrCallbackExceptionOrResult(this.cancellationSignal, new CredentialProviderGetSignInIntentController$handleResponse$4(this, objectRef));
+        } catch (Throwable th) {
+            CredentialProviderController.cancelOrCallbackExceptionOrResult(this.cancellationSignal, new CredentialProviderGetSignInIntentController$handleResponse$6(this, new GetCredentialUnknownException(th.getMessage())));
+        }
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final CredentialProviderGetSignInIntentController getInstance(Context context) {
+            Intrinsics.checkNotNullParameter(context, "context");
+            return new CredentialProviderGetSignInIntentController(context);
+        }
+    }
+}