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/com/facebook/internal/FacebookDialogBase.java

@@ -0,0 +1,361 @@
+package com.facebook.internal;
+
+import android.app.Activity;
+import android.content.ComponentCallbacks2;
+import android.content.Context;
+import android.content.Intent;
+import android.util.Log;
+import androidx.activity.result.ActivityResultRegistry;
+import androidx.activity.result.ActivityResultRegistryOwner;
+import androidx.activity.result.contract.ActivityResultContract;
+import androidx.annotation.VisibleForTesting;
+import com.facebook.CallbackManager;
+import com.facebook.FacebookCallback;
+import com.facebook.FacebookDialog;
+import com.facebook.FacebookException;
+import com.facebook.FacebookSdk;
+import java.util.Iterator;
+import java.util.List;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes2.dex */
+public abstract class FacebookDialogBase<CONTENT, RESULT> implements FacebookDialog<CONTENT, RESULT> {
+    private static final String TAG = "FacebookDialog";
+    private final Activity activity;
+    private CallbackManager callbackManager;
+    private final FragmentWrapper fragmentWrapper;
+    private List<? extends FacebookDialogBase<CONTENT, RESULT>.ModeHandler> modeHandlers;
+    private int requestCodeField;
+    public static final Companion Companion = new Companion(null);
+    public static final Object BASE_AUTOMATIC_MODE = new Object();
+
+    public abstract AppCall createBaseAppCall();
+
+    @VisibleForTesting(otherwise = 2)
+    public final CallbackManager getCallbackManager$facebook_common_release() {
+        return this.callbackManager;
+    }
+
+    public abstract List<FacebookDialogBase<CONTENT, RESULT>.ModeHandler> getOrderedModeHandlers();
+
+    public final int getRequestCode() {
+        return this.requestCodeField;
+    }
+
+    public abstract void registerCallbackImpl(CallbackManagerImpl callbackManagerImpl, FacebookCallback<RESULT> facebookCallback);
+
+    public final void setCallbackManager(CallbackManager callbackManager) {
+        this.callbackManager = callbackManager;
+    }
+
+    public final void setCallbackManager$facebook_common_release(CallbackManager callbackManager) {
+        this.callbackManager = callbackManager;
+    }
+
+    public FacebookDialogBase(Activity activity, int i) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+        this.activity = activity;
+        this.fragmentWrapper = null;
+        this.requestCodeField = i;
+        this.callbackManager = null;
+    }
+
+    public FacebookDialogBase(FragmentWrapper fragmentWrapper, int i) {
+        Intrinsics.checkNotNullParameter(fragmentWrapper, "fragmentWrapper");
+        this.fragmentWrapper = fragmentWrapper;
+        this.activity = null;
+        this.requestCodeField = i;
+        if (fragmentWrapper.getActivity() == null) {
+            throw new IllegalArgumentException("Cannot use a fragment that is not attached to an activity".toString());
+        }
+    }
+
+    public FacebookDialogBase(int i) {
+        this.requestCodeField = i;
+        this.activity = null;
+        this.fragmentWrapper = null;
+    }
+
+    @Override // com.facebook.FacebookDialog
+    public void registerCallback(CallbackManager callbackManager, FacebookCallback<RESULT> callback) {
+        Intrinsics.checkNotNullParameter(callbackManager, "callbackManager");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        if (!(callbackManager instanceof CallbackManagerImpl)) {
+            throw new FacebookException("Unexpected CallbackManager, please use the provided Factory.");
+        }
+        memorizeCallbackManager(callbackManager);
+        registerCallbackImpl((CallbackManagerImpl) callbackManager, callback);
+    }
+
+    @Override // com.facebook.FacebookDialog
+    public void registerCallback(CallbackManager callbackManager, FacebookCallback<RESULT> callback, int i) {
+        Intrinsics.checkNotNullParameter(callbackManager, "callbackManager");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        memorizeCallbackManager(callbackManager);
+        setRequestCode(i);
+        registerCallback(callbackManager, callback);
+    }
+
+    public final void setRequestCode(int i) {
+        if (!FacebookSdk.isFacebookRequestCode(i)) {
+            this.requestCodeField = i;
+            return;
+        }
+        throw new IllegalArgumentException(("Request code " + i + " cannot be within the range reserved by the Facebook SDK.").toString());
+    }
+
+    @Override // com.facebook.FacebookDialog
+    public boolean canShow(CONTENT content) {
+        return canShowImpl(content, BASE_AUTOMATIC_MODE);
+    }
+
+    public boolean canShowImpl(CONTENT content, Object mode) {
+        Intrinsics.checkNotNullParameter(mode, "mode");
+        boolean z = mode == BASE_AUTOMATIC_MODE;
+        for (FacebookDialogBase<CONTENT, RESULT>.ModeHandler modeHandler : cachedModeHandlers()) {
+            if (!z) {
+                Utility utility = Utility.INSTANCE;
+                if (!Utility.areObjectsEqual(modeHandler.getMode(), mode)) {
+                    continue;
+                }
+            }
+            if (modeHandler.canShow(content, false)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override // com.facebook.FacebookDialog
+    public void show(CONTENT content) {
+        showImpl(content, BASE_AUTOMATIC_MODE);
+    }
+
+    public final ActivityResultContract<CONTENT, CallbackManager.ActivityResultParameters> createActivityResultContractForShowingDialog(final CallbackManager callbackManager, final Object mode) {
+        Intrinsics.checkNotNullParameter(mode, "mode");
+        return new ActivityResultContract<CONTENT, CallbackManager.ActivityResultParameters>(this) { // from class: com.facebook.internal.FacebookDialogBase$createActivityResultContractForShowingDialog$1
+            final /* synthetic */ FacebookDialogBase<CONTENT, RESULT> this$0;
+
+            {
+                this.this$0 = this;
+            }
+
+            @Override // androidx.activity.result.contract.ActivityResultContract
+            public Intent createIntent(Context context, CONTENT content) {
+                AppCall createAppCallForMode;
+                Intrinsics.checkNotNullParameter(context, "context");
+                createAppCallForMode = this.this$0.createAppCallForMode(content, mode);
+                Intent requestIntent = createAppCallForMode == null ? null : createAppCallForMode.getRequestIntent();
+                if (requestIntent != null) {
+                    createAppCallForMode.setPending();
+                    return requestIntent;
+                }
+                throw new FacebookException("Content " + content + " is not supported");
+            }
+
+            /* JADX WARN: Can't rename method to resolve collision */
+            @Override // androidx.activity.result.contract.ActivityResultContract
+            public CallbackManager.ActivityResultParameters parseResult(int i, Intent intent) {
+                CallbackManager callbackManager2 = callbackManager;
+                if (callbackManager2 != null) {
+                    callbackManager2.onActivityResult(this.this$0.getRequestCode(), i, intent);
+                }
+                return new CallbackManager.ActivityResultParameters(this.this$0.getRequestCode(), i, intent);
+            }
+        };
+    }
+
+    @Override // com.facebook.FacebookDialog
+    public ActivityResultContract<CONTENT, CallbackManager.ActivityResultParameters> createActivityResultContractForShowingDialog(CallbackManager callbackManager) {
+        return createActivityResultContractForShowingDialog(callbackManager, BASE_AUTOMATIC_MODE);
+    }
+
+    public void showImpl(CONTENT content, Object mode) {
+        Intrinsics.checkNotNullParameter(mode, "mode");
+        AppCall createAppCallForMode = createAppCallForMode(content, mode);
+        if (createAppCallForMode != null) {
+            if (getActivityContext() instanceof ActivityResultRegistryOwner) {
+                ComponentCallbacks2 activityContext = getActivityContext();
+                if (activityContext == null) {
+                    throw new NullPointerException("null cannot be cast to non-null type androidx.activity.result.ActivityResultRegistryOwner");
+                }
+                DialogPresenter dialogPresenter = DialogPresenter.INSTANCE;
+                ActivityResultRegistry activityResultRegistry = ((ActivityResultRegistryOwner) activityContext).getActivityResultRegistry();
+                Intrinsics.checkNotNullExpressionValue(activityResultRegistry, "registryOwner.activityResultRegistry");
+                DialogPresenter.present(createAppCallForMode, activityResultRegistry, this.callbackManager);
+                createAppCallForMode.setPending();
+                return;
+            }
+            FragmentWrapper fragmentWrapper = this.fragmentWrapper;
+            if (fragmentWrapper != null) {
+                DialogPresenter.present(createAppCallForMode, fragmentWrapper);
+                return;
+            }
+            Activity activity = this.activity;
+            if (activity != null) {
+                DialogPresenter.present(createAppCallForMode, activity);
+                return;
+            }
+            return;
+        }
+        Log.e(TAG, "No code path should ever result in a null appCall");
+        if (!(!FacebookSdk.isDebugEnabled())) {
+            throw new IllegalStateException("No code path should ever result in a null appCall".toString());
+        }
+    }
+
+    public final Activity getActivityContext() {
+        Activity activity = this.activity;
+        if (activity != null) {
+            return activity;
+        }
+        FragmentWrapper fragmentWrapper = this.fragmentWrapper;
+        if (fragmentWrapper == null) {
+            return null;
+        }
+        return fragmentWrapper.getActivity();
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Removed duplicated region for block: B:6:0x0033  */
+    /* JADX WARN: Removed duplicated region for block: B:9:? A[RETURN, SYNTHETIC] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final void startActivityForResult(android.content.Intent r4, int r5) {
+        /*
+            r3 = this;
+            java.lang.String r0 = "intent"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r4, r0)
+            android.app.Activity r0 = r3.getActivityContext()
+            boolean r1 = r0 instanceof androidx.activity.result.ActivityResultRegistryOwner
+            if (r1 == 0) goto L20
+            com.facebook.internal.DialogPresenter r1 = com.facebook.internal.DialogPresenter.INSTANCE
+            androidx.activity.result.ActivityResultRegistryOwner r0 = (androidx.activity.result.ActivityResultRegistryOwner) r0
+            androidx.activity.result.ActivityResultRegistry r0 = r0.getActivityResultRegistry()
+            java.lang.String r1 = "activity as ActivityResultRegistryOwner).activityResultRegistry"
+            kotlin.jvm.internal.Intrinsics.checkNotNullExpressionValue(r0, r1)
+            com.facebook.CallbackManager r1 = r3.callbackManager
+            com.facebook.internal.DialogPresenter.startActivityForResultWithAndroidX(r0, r1, r4, r5)
+            goto L2d
+        L20:
+            if (r0 == 0) goto L26
+            r0.startActivityForResult(r4, r5)
+            goto L2d
+        L26:
+            com.facebook.internal.FragmentWrapper r0 = r3.fragmentWrapper
+            if (r0 == 0) goto L2f
+            r0.startActivityForResult(r4, r5)
+        L2d:
+            r4 = 0
+            goto L31
+        L2f:
+            java.lang.String r4 = "Failed to find Activity or Fragment to startActivityForResult "
+        L31:
+            if (r4 == 0) goto L48
+            com.facebook.internal.Logger$Companion r5 = com.facebook.internal.Logger.Companion
+            com.facebook.LoggingBehavior r0 = com.facebook.LoggingBehavior.DEVELOPER_ERRORS
+            java.lang.Class r1 = r3.getClass()
+            java.lang.String r1 = r1.getName()
+            java.lang.String r2 = "this.javaClass.name"
+            kotlin.jvm.internal.Intrinsics.checkNotNullExpressionValue(r1, r2)
+            r2 = 6
+            r5.log(r0, r2, r1, r4)
+        L48:
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.facebook.internal.FacebookDialogBase.startActivityForResult(android.content.Intent, int):void");
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final AppCall createAppCallForMode(CONTENT content, Object obj) {
+        AppCall appCall;
+        boolean z = obj == BASE_AUTOMATIC_MODE;
+        Iterator<FacebookDialogBase<CONTENT, RESULT>.ModeHandler> it = cachedModeHandlers().iterator();
+        while (true) {
+            if (!it.hasNext()) {
+                appCall = null;
+                break;
+            }
+            FacebookDialogBase<CONTENT, RESULT>.ModeHandler next = it.next();
+            if (!z) {
+                Utility utility = Utility.INSTANCE;
+                if (!Utility.areObjectsEqual(next.getMode(), obj)) {
+                    continue;
+                }
+            }
+            if (next.canShow(content, true)) {
+                try {
+                    appCall = next.createAppCall(content);
+                    break;
+                } catch (FacebookException e) {
+                    AppCall createBaseAppCall = createBaseAppCall();
+                    DialogPresenter dialogPresenter = DialogPresenter.INSTANCE;
+                    DialogPresenter.setupAppCallForValidationError(createBaseAppCall, e);
+                    appCall = createBaseAppCall;
+                }
+            }
+        }
+        if (appCall != null) {
+            return appCall;
+        }
+        AppCall createBaseAppCall2 = createBaseAppCall();
+        DialogPresenter.setupAppCallForCannotShowError(createBaseAppCall2);
+        return createBaseAppCall2;
+    }
+
+    private final void memorizeCallbackManager(CallbackManager callbackManager) {
+        CallbackManager callbackManager2 = this.callbackManager;
+        if (callbackManager2 == null) {
+            this.callbackManager = callbackManager;
+        } else if (callbackManager2 != callbackManager) {
+            Log.w(TAG, "You're registering a callback on a Facebook dialog with two different callback managers. It's almost wrong and may cause unexpected results. Only the first callback manager will be used for handling activity result with androidx.");
+        }
+    }
+
+    private final List<FacebookDialogBase<CONTENT, RESULT>.ModeHandler> cachedModeHandlers() {
+        if (this.modeHandlers == null) {
+            this.modeHandlers = getOrderedModeHandlers();
+        }
+        List<? extends FacebookDialogBase<CONTENT, RESULT>.ModeHandler> list = this.modeHandlers;
+        if (list != null) {
+            return list;
+        }
+        throw new NullPointerException("null cannot be cast to non-null type kotlin.collections.List<com.facebook.internal.FacebookDialogBase.ModeHandler<CONTENT of com.facebook.internal.FacebookDialogBase, RESULT of com.facebook.internal.FacebookDialogBase>>");
+    }
+
+    public abstract class ModeHandler {
+        private Object mode;
+        final /* synthetic */ FacebookDialogBase<CONTENT, RESULT> this$0;
+
+        public abstract boolean canShow(CONTENT content, boolean z);
+
+        public abstract AppCall createAppCall(CONTENT content);
+
+        public Object getMode() {
+            return this.mode;
+        }
+
+        public void setMode(Object obj) {
+            Intrinsics.checkNotNullParameter(obj, "<set-?>");
+            this.mode = obj;
+        }
+
+        public ModeHandler(FacebookDialogBase this$0) {
+            Intrinsics.checkNotNullParameter(this$0, "this$0");
+            this.this$0 = this$0;
+            this.mode = FacebookDialogBase.BASE_AUTOMATIC_MODE;
+        }
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+    }
+}