Add Discord community version (64-bit only)

- Added realracing3-community.apk (71.57 MB)
- Removed 32-bit support (armeabi-v7a)
- Only includes arm64-v8a libraries
- Decompiled source code included
- Added README-community.md with analysis

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