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/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()));
+    }
+}