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/CredentialProviderFrameworkImpl.java

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