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/com/facebook/share/widget/GameRequestDialog.java

@@ -0,0 +1,169 @@
+package com.facebook.share.widget;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import androidx.fragment.app.Fragment;
+import com.facebook.AccessToken;
+import com.facebook.FacebookCallback;
+import com.facebook.FacebookSdk;
+import com.facebook.internal.AppCall;
+import com.facebook.internal.CallbackManagerImpl;
+import com.facebook.internal.CustomTabUtils;
+import com.facebook.internal.DialogPresenter;
+import com.facebook.internal.FacebookDialogBase;
+import com.facebook.internal.FragmentWrapper;
+import com.facebook.internal.ServerProtocol;
+import com.facebook.internal.Validate;
+import com.facebook.share.internal.GameRequestValidation;
+import com.facebook.share.internal.ResultProcessor;
+import com.facebook.share.internal.ShareConstants;
+import com.facebook.share.internal.ShareInternalUtility;
+import com.facebook.share.internal.WebDialogParameters;
+import com.facebook.share.model.GameRequestContent;
+import java.util.ArrayList;
+import java.util.List;
+
+@Deprecated
+/* loaded from: classes2.dex */
+public class GameRequestDialog extends FacebookDialogBase<GameRequestContent, Result> {
+    private static final int DEFAULT_REQUEST_CODE = CallbackManagerImpl.RequestCodeOffset.GameRequest.toRequestCode();
+    private static final String GAME_REQUEST_DIALOG = "apprequests";
+
+    public static boolean canShow() {
+        return true;
+    }
+
+    public static final class Result {
+        String requestId;
+        List<String> to;
+
+        public String getRequestId() {
+            return this.requestId;
+        }
+
+        public List<String> getRequestRecipients() {
+            return this.to;
+        }
+
+        private Result(Bundle bundle) {
+            this.requestId = bundle.getString("request");
+            this.to = new ArrayList();
+            while (bundle.containsKey(String.format(ShareConstants.WEB_DIALOG_RESULT_PARAM_TO_ARRAY_MEMBER, Integer.valueOf(this.to.size())))) {
+                List<String> list = this.to;
+                list.add(bundle.getString(String.format(ShareConstants.WEB_DIALOG_RESULT_PARAM_TO_ARRAY_MEMBER, Integer.valueOf(list.size()))));
+            }
+        }
+    }
+
+    public static void show(Activity activity, GameRequestContent gameRequestContent) {
+        new GameRequestDialog(activity).show(gameRequestContent);
+    }
+
+    public static void show(Fragment fragment, GameRequestContent gameRequestContent) {
+        show(new FragmentWrapper(fragment), gameRequestContent);
+    }
+
+    public static void show(android.app.Fragment fragment, GameRequestContent gameRequestContent) {
+        show(new FragmentWrapper(fragment), gameRequestContent);
+    }
+
+    private static void show(FragmentWrapper fragmentWrapper, GameRequestContent gameRequestContent) {
+        new GameRequestDialog(fragmentWrapper).show(gameRequestContent);
+    }
+
+    public GameRequestDialog(Activity activity) {
+        super(activity, DEFAULT_REQUEST_CODE);
+    }
+
+    public GameRequestDialog(Fragment fragment) {
+        this(new FragmentWrapper(fragment));
+    }
+
+    public GameRequestDialog(android.app.Fragment fragment) {
+        this(new FragmentWrapper(fragment));
+    }
+
+    private GameRequestDialog(FragmentWrapper fragmentWrapper) {
+        super(fragmentWrapper, DEFAULT_REQUEST_CODE);
+    }
+
+    @Override // com.facebook.internal.FacebookDialogBase
+    public void registerCallbackImpl(CallbackManagerImpl callbackManagerImpl, final FacebookCallback<Result> facebookCallback) {
+        final ResultProcessor resultProcessor = facebookCallback == null ? null : new ResultProcessor(facebookCallback) { // from class: com.facebook.share.widget.GameRequestDialog.1
+            @Override // com.facebook.share.internal.ResultProcessor
+            public void onSuccess(AppCall appCall, Bundle bundle) {
+                if (bundle != null) {
+                    facebookCallback.onSuccess(new Result(bundle));
+                } else {
+                    onCancel(appCall);
+                }
+            }
+        };
+        callbackManagerImpl.registerCallback(getRequestCode(), new CallbackManagerImpl.Callback() { // from class: com.facebook.share.widget.GameRequestDialog.2
+            @Override // com.facebook.internal.CallbackManagerImpl.Callback
+            public boolean onActivityResult(int i, Intent intent) {
+                return ShareInternalUtility.handleActivityResult(GameRequestDialog.this.getRequestCode(), i, intent, resultProcessor);
+            }
+        });
+    }
+
+    @Override // com.facebook.internal.FacebookDialogBase
+    public AppCall createBaseAppCall() {
+        return new AppCall(getRequestCode());
+    }
+
+    @Override // com.facebook.internal.FacebookDialogBase
+    public List<FacebookDialogBase<GameRequestContent, Result>.ModeHandler> getOrderedModeHandlers() {
+        ArrayList arrayList = new ArrayList();
+        arrayList.add(new ChromeCustomTabHandler());
+        arrayList.add(new WebHandler());
+        return arrayList;
+    }
+
+    public class ChromeCustomTabHandler extends FacebookDialogBase<GameRequestContent, Result>.ModeHandler {
+        private ChromeCustomTabHandler() {
+            super(GameRequestDialog.this);
+        }
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public boolean canShow(GameRequestContent gameRequestContent, boolean z) {
+            return CustomTabUtils.getChromePackage() != null && Validate.hasCustomTabRedirectActivity(GameRequestDialog.this.getActivityContext(), CustomTabUtils.getDefaultRedirectURI());
+        }
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public AppCall createAppCall(GameRequestContent gameRequestContent) {
+            GameRequestValidation.validate(gameRequestContent);
+            AppCall createBaseAppCall = GameRequestDialog.this.createBaseAppCall();
+            Bundle create = WebDialogParameters.create(gameRequestContent);
+            AccessToken currentAccessToken = AccessToken.getCurrentAccessToken();
+            if (currentAccessToken != null) {
+                create.putString("app_id", currentAccessToken.getApplicationId());
+            } else {
+                create.putString("app_id", FacebookSdk.getApplicationId());
+            }
+            create.putString(ServerProtocol.DIALOG_PARAM_REDIRECT_URI, CustomTabUtils.getDefaultRedirectURI());
+            DialogPresenter.setupAppCallForCustomTabDialog(createBaseAppCall, GameRequestDialog.GAME_REQUEST_DIALOG, create);
+            return createBaseAppCall;
+        }
+    }
+
+    public class WebHandler extends FacebookDialogBase<GameRequestContent, Result>.ModeHandler {
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public boolean canShow(GameRequestContent gameRequestContent, boolean z) {
+            return true;
+        }
+
+        private WebHandler() {
+            super(GameRequestDialog.this);
+        }
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public AppCall createAppCall(GameRequestContent gameRequestContent) {
+            GameRequestValidation.validate(gameRequestContent);
+            AppCall createBaseAppCall = GameRequestDialog.this.createBaseAppCall();
+            DialogPresenter.setupAppCallForWebDialog(createBaseAppCall, GameRequestDialog.GAME_REQUEST_DIALOG, WebDialogParameters.create(gameRequestContent));
+            return createBaseAppCall;
+        }
+    }
+}

decompiled/sources/com/facebook/share/widget/MessageDialog.java

@@ -0,0 +1,211 @@
+package com.facebook.share.widget;
+
+import android.app.Activity;
+import android.content.Context;
+import android.os.Bundle;
+import androidx.fragment.app.Fragment;
+import com.facebook.FacebookCallback;
+import com.facebook.appevents.InternalAppEventsLogger;
+import com.facebook.internal.AnalyticsEvents;
+import com.facebook.internal.AppCall;
+import com.facebook.internal.CallbackManagerImpl;
+import com.facebook.internal.DialogFeature;
+import com.facebook.internal.DialogPresenter;
+import com.facebook.internal.FacebookDialogBase;
+import com.facebook.internal.FragmentWrapper;
+import com.facebook.share.Sharer;
+import com.facebook.share.internal.LegacyNativeDialogParameters;
+import com.facebook.share.internal.MessageDialogFeature;
+import com.facebook.share.internal.NativeDialogParameters;
+import com.facebook.share.internal.ShareContentValidation;
+import com.facebook.share.internal.ShareInternalUtility;
+import com.facebook.share.model.ShareContent;
+import com.facebook.share.model.ShareLinkContent;
+import java.util.ArrayList;
+import java.util.List;
+
+/* loaded from: classes2.dex */
+public final class MessageDialog extends ShareDialog implements Sharer {
+    private static final int DEFAULT_REQUEST_CODE = CallbackManagerImpl.RequestCodeOffset.Message.toRequestCode();
+    private boolean shouldFailOnDataError;
+
+    @Override // com.facebook.share.widget.ShareDialog, com.facebook.share.Sharer
+    public boolean getShouldFailOnDataError() {
+        return this.shouldFailOnDataError;
+    }
+
+    @Override // com.facebook.share.widget.ShareDialog, com.facebook.share.Sharer
+    public void setShouldFailOnDataError(boolean z) {
+        this.shouldFailOnDataError = z;
+    }
+
+    public static void show(Activity activity, ShareContent shareContent) {
+        new MessageDialog(activity).show(shareContent);
+    }
+
+    public static void show(Fragment fragment, ShareContent shareContent) {
+        show(new FragmentWrapper(fragment), shareContent);
+    }
+
+    public static void show(android.app.Fragment fragment, ShareContent shareContent) {
+        show(new FragmentWrapper(fragment), shareContent);
+    }
+
+    private static void show(FragmentWrapper fragmentWrapper, ShareContent shareContent) {
+        new MessageDialog(fragmentWrapper).show(shareContent);
+    }
+
+    public static boolean canShow(Class<? extends ShareContent<?, ?>> cls) {
+        DialogFeature feature = getFeature(cls);
+        return feature != null && DialogPresenter.canPresentNativeDialogWithFeature(feature);
+    }
+
+    /* JADX WARN: Illegal instructions before constructor call */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public MessageDialog(android.app.Activity r2) {
+        /*
+            r1 = this;
+            int r0 = com.facebook.share.widget.MessageDialog.DEFAULT_REQUEST_CODE
+            r1.<init>(r2, r0)
+            r2 = 0
+            r1.shouldFailOnDataError = r2
+            com.facebook.share.internal.ShareInternalUtility.registerStaticShareCallback(r0)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.facebook.share.widget.MessageDialog.<init>(android.app.Activity):void");
+    }
+
+    public MessageDialog(Fragment fragment) {
+        this(new FragmentWrapper(fragment));
+    }
+
+    public MessageDialog(android.app.Fragment fragment) {
+        this(new FragmentWrapper(fragment));
+    }
+
+    /* JADX WARN: Illegal instructions before constructor call */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private MessageDialog(com.facebook.internal.FragmentWrapper r2) {
+        /*
+            r1 = this;
+            int r0 = com.facebook.share.widget.MessageDialog.DEFAULT_REQUEST_CODE
+            r1.<init>(r2, r0)
+            r2 = 0
+            r1.shouldFailOnDataError = r2
+            com.facebook.share.internal.ShareInternalUtility.registerStaticShareCallback(r0)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.facebook.share.widget.MessageDialog.<init>(com.facebook.internal.FragmentWrapper):void");
+    }
+
+    public MessageDialog(Activity activity, int i) {
+        super(activity, i);
+        this.shouldFailOnDataError = false;
+        ShareInternalUtility.registerStaticShareCallback(i);
+    }
+
+    public MessageDialog(Fragment fragment, int i) {
+        this(new FragmentWrapper(fragment), i);
+    }
+
+    public MessageDialog(android.app.Fragment fragment, int i) {
+        this(new FragmentWrapper(fragment), i);
+    }
+
+    private MessageDialog(FragmentWrapper fragmentWrapper, int i) {
+        super(fragmentWrapper, i);
+        this.shouldFailOnDataError = false;
+        ShareInternalUtility.registerStaticShareCallback(i);
+    }
+
+    @Override // com.facebook.share.widget.ShareDialog, com.facebook.internal.FacebookDialogBase
+    public void registerCallbackImpl(CallbackManagerImpl callbackManagerImpl, FacebookCallback<Sharer.Result> facebookCallback) {
+        ShareInternalUtility.registerSharerCallback(getRequestCode(), callbackManagerImpl, facebookCallback);
+    }
+
+    @Override // com.facebook.share.widget.ShareDialog, com.facebook.internal.FacebookDialogBase
+    public AppCall createBaseAppCall() {
+        return new AppCall(getRequestCode());
+    }
+
+    @Override // com.facebook.share.widget.ShareDialog, com.facebook.internal.FacebookDialogBase
+    public List<FacebookDialogBase<ShareContent<?, ?>, Sharer.Result>.ModeHandler> getOrderedModeHandlers() {
+        ArrayList arrayList = new ArrayList();
+        arrayList.add(new NativeHandler());
+        return arrayList;
+    }
+
+    public class NativeHandler extends FacebookDialogBase<ShareContent<?, ?>, Sharer.Result>.ModeHandler {
+        private NativeHandler() {
+            super(MessageDialog.this);
+        }
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public /* bridge */ /* synthetic */ boolean canShow(ShareContent<?, ?> shareContent, boolean z) {
+            return canShow2((ShareContent) shareContent, z);
+        }
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public /* bridge */ /* synthetic */ AppCall createAppCall(ShareContent<?, ?> shareContent) {
+            return createAppCall2((ShareContent) shareContent);
+        }
+
+        /* renamed from: canShow, reason: avoid collision after fix types in other method */
+        public boolean canShow2(ShareContent shareContent, boolean z) {
+            return shareContent != null && MessageDialog.canShow((Class<? extends ShareContent<?, ?>>) shareContent.getClass());
+        }
+
+        /* renamed from: createAppCall, reason: avoid collision after fix types in other method */
+        public AppCall createAppCall2(final ShareContent shareContent) {
+            ShareContentValidation.validateForMessage(shareContent);
+            final AppCall createBaseAppCall = MessageDialog.this.createBaseAppCall();
+            final boolean shouldFailOnDataError = MessageDialog.this.getShouldFailOnDataError();
+            MessageDialog.logDialogShare(MessageDialog.this.getActivityContext(), shareContent, createBaseAppCall);
+            DialogPresenter.setupAppCallForNativeDialog(createBaseAppCall, new DialogPresenter.ParameterProvider() { // from class: com.facebook.share.widget.MessageDialog.NativeHandler.1
+                @Override // com.facebook.internal.DialogPresenter.ParameterProvider
+                public Bundle getParameters() {
+                    return NativeDialogParameters.create(createBaseAppCall.getCallId(), (ShareContent<?, ?>) shareContent, shouldFailOnDataError);
+                }
+
+                @Override // com.facebook.internal.DialogPresenter.ParameterProvider
+                public Bundle getLegacyParameters() {
+                    return LegacyNativeDialogParameters.create(createBaseAppCall.getCallId(), (ShareContent<?, ?>) shareContent, shouldFailOnDataError);
+                }
+            }, MessageDialog.getFeature(shareContent.getClass()));
+            return createBaseAppCall;
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static DialogFeature getFeature(Class<? extends ShareContent> cls) {
+        if (ShareLinkContent.class.isAssignableFrom(cls)) {
+            return MessageDialogFeature.MESSAGE_DIALOG;
+        }
+        return null;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static void logDialogShare(Context context, ShareContent shareContent, AppCall appCall) {
+        String str;
+        DialogFeature feature = getFeature(shareContent.getClass());
+        if (feature == MessageDialogFeature.MESSAGE_DIALOG) {
+            str = "status";
+        } else if (feature == MessageDialogFeature.MESSENGER_GENERIC_TEMPLATE) {
+            str = AnalyticsEvents.PARAMETER_SHARE_MESSENGER_GENERIC_TEMPLATE;
+        } else {
+            str = feature == MessageDialogFeature.MESSENGER_MEDIA_TEMPLATE ? AnalyticsEvents.PARAMETER_SHARE_MESSENGER_MEDIA_TEMPLATE : "unknown";
+        }
+        InternalAppEventsLogger internalAppEventsLogger = new InternalAppEventsLogger(context);
+        Bundle bundle = new Bundle();
+        bundle.putString(AnalyticsEvents.PARAMETER_SHARE_DIALOG_CONTENT_TYPE, str);
+        bundle.putString(AnalyticsEvents.PARAMETER_SHARE_DIALOG_CONTENT_UUID, appCall.getCallId().toString());
+        bundle.putString(AnalyticsEvents.PARAMETER_SHARE_DIALOG_CONTENT_PAGE_ID, shareContent.getPageId());
+        internalAppEventsLogger.logEventImplicitly(AnalyticsEvents.EVENT_SHARE_MESSENGER_DIALOG_SHOW, bundle);
+    }
+}

decompiled/sources/com/facebook/share/widget/SendButton.java

@@ -0,0 +1,46 @@
+package com.facebook.share.widget;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import com.facebook.internal.AnalyticsEvents;
+import com.facebook.internal.CallbackManagerImpl;
+import com.facebook.share.R;
+
+/* loaded from: classes2.dex */
+public final class SendButton extends ShareButtonBase {
+    @Override // com.facebook.FacebookButtonBase
+    public int getDefaultStyleResource() {
+        return R.style.com_facebook_button_send;
+    }
+
+    public SendButton(Context context) {
+        super(context, null, 0, AnalyticsEvents.EVENT_SEND_BUTTON_CREATE, AnalyticsEvents.EVENT_SEND_BUTTON_DID_TAP);
+    }
+
+    public SendButton(Context context, AttributeSet attributeSet) {
+        super(context, attributeSet, 0, AnalyticsEvents.EVENT_SEND_BUTTON_CREATE, AnalyticsEvents.EVENT_SEND_BUTTON_DID_TAP);
+    }
+
+    public SendButton(Context context, AttributeSet attributeSet, int i) {
+        super(context, attributeSet, i, AnalyticsEvents.EVENT_SEND_BUTTON_CREATE, AnalyticsEvents.EVENT_SEND_BUTTON_DID_TAP);
+    }
+
+    @Override // com.facebook.FacebookButtonBase
+    public int getDefaultRequestCode() {
+        return CallbackManagerImpl.RequestCodeOffset.Message.toRequestCode();
+    }
+
+    @Override // com.facebook.share.widget.ShareButtonBase
+    public ShareDialog getDialog() {
+        MessageDialog messageDialog;
+        if (getFragment() != null) {
+            messageDialog = new MessageDialog(getFragment(), getRequestCode());
+        } else if (getNativeFragment() != null) {
+            messageDialog = new MessageDialog(getNativeFragment(), getRequestCode());
+        } else {
+            messageDialog = new MessageDialog(getActivity(), getRequestCode());
+        }
+        messageDialog.setCallbackManager(getCallbackManager());
+        return messageDialog;
+    }
+}

decompiled/sources/com/facebook/share/widget/ShareButton.java

@@ -0,0 +1,54 @@
+package com.facebook.share.widget;
+
+import android.content.Context;
+import android.graphics.drawable.Drawable;
+import android.util.AttributeSet;
+import androidx.appcompat.content.res.AppCompatResources;
+import com.facebook.internal.AnalyticsEvents;
+import com.facebook.internal.CallbackManagerImpl;
+import com.facebook.share.R;
+
+/* loaded from: classes2.dex */
+public final class ShareButton extends ShareButtonBase {
+    @Override // com.facebook.FacebookButtonBase
+    public int getDefaultStyleResource() {
+        return R.style.com_facebook_button_share;
+    }
+
+    public ShareButton(Context context) {
+        super(context, null, 0, AnalyticsEvents.EVENT_SHARE_BUTTON_CREATE, AnalyticsEvents.EVENT_SHARE_BUTTON_DID_TAP);
+    }
+
+    public ShareButton(Context context, AttributeSet attributeSet) {
+        super(context, attributeSet, 0, AnalyticsEvents.EVENT_SHARE_BUTTON_CREATE, AnalyticsEvents.EVENT_SHARE_BUTTON_DID_TAP);
+    }
+
+    public ShareButton(Context context, AttributeSet attributeSet, int i) {
+        super(context, attributeSet, i, AnalyticsEvents.EVENT_SHARE_BUTTON_CREATE, AnalyticsEvents.EVENT_SHARE_BUTTON_DID_TAP);
+    }
+
+    @Override // com.facebook.FacebookButtonBase
+    public int getDefaultRequestCode() {
+        return CallbackManagerImpl.RequestCodeOffset.Share.toRequestCode();
+    }
+
+    @Override // com.facebook.share.widget.ShareButtonBase
+    public ShareDialog getDialog() {
+        ShareDialog shareDialog;
+        if (getFragment() != null) {
+            shareDialog = new ShareDialog(getFragment(), getRequestCode());
+        } else if (getNativeFragment() != null) {
+            shareDialog = new ShareDialog(getNativeFragment(), getRequestCode());
+        } else {
+            shareDialog = new ShareDialog(getActivity(), getRequestCode());
+        }
+        shareDialog.setCallbackManager(getCallbackManager());
+        return shareDialog;
+    }
+
+    @Override // com.facebook.share.widget.ShareButtonBase, com.facebook.FacebookButtonBase
+    public void configureButton(Context context, AttributeSet attributeSet, int i, int i2) {
+        super.configureButton(context, attributeSet, i, i2);
+        setCompoundDrawablesWithIntrinsicBounds(AppCompatResources.getDrawable(getContext(), com.facebook.common.R.drawable.com_facebook_button_icon), (Drawable) null, (Drawable) null, (Drawable) null);
+    }
+}

decompiled/sources/com/facebook/share/widget/ShareButtonBase.java

@@ -0,0 +1,118 @@
+package com.facebook.share.widget;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.View;
+import com.facebook.CallbackManager;
+import com.facebook.FacebookButtonBase;
+import com.facebook.FacebookCallback;
+import com.facebook.FacebookSdk;
+import com.facebook.internal.instrument.crashshield.CrashShieldHandler;
+import com.facebook.share.Sharer;
+import com.facebook.share.internal.ShareInternalUtility;
+import com.facebook.share.model.ShareContent;
+
+/* loaded from: classes2.dex */
+public abstract class ShareButtonBase extends FacebookButtonBase {
+    private CallbackManager callbackManager;
+    private boolean enabledExplicitlySet;
+    private int requestCode;
+    private ShareContent shareContent;
+
+    public CallbackManager getCallbackManager() {
+        return this.callbackManager;
+    }
+
+    public abstract ShareDialog getDialog();
+
+    @Override // com.facebook.FacebookButtonBase
+    public int getRequestCode() {
+        return this.requestCode;
+    }
+
+    public ShareContent getShareContent() {
+        return this.shareContent;
+    }
+
+    public ShareButtonBase(Context context, AttributeSet attributeSet, int i, String str, String str2) {
+        super(context, attributeSet, i, 0, str, str2);
+        this.requestCode = 0;
+        this.enabledExplicitlySet = false;
+        this.requestCode = isInEditMode() ? 0 : getDefaultRequestCode();
+        internalSetEnabled(false);
+    }
+
+    public void setShareContent(ShareContent shareContent) {
+        this.shareContent = shareContent;
+        if (this.enabledExplicitlySet) {
+            return;
+        }
+        internalSetEnabled(canShare());
+    }
+
+    @Override // android.widget.TextView, android.view.View
+    public void setEnabled(boolean z) {
+        super.setEnabled(z);
+        this.enabledExplicitlySet = true;
+    }
+
+    public void setRequestCode(int i) {
+        if (!FacebookSdk.isFacebookRequestCode(i)) {
+            this.requestCode = i;
+            return;
+        }
+        throw new IllegalArgumentException("Request code " + i + " cannot be within the range reserved by the Facebook SDK.");
+    }
+
+    public void registerCallback(CallbackManager callbackManager, FacebookCallback<Sharer.Result> facebookCallback) {
+        memorizeCallbackManager(callbackManager);
+        ShareInternalUtility.registerSharerCallback(getRequestCode(), callbackManager, facebookCallback);
+    }
+
+    public void registerCallback(CallbackManager callbackManager, FacebookCallback<Sharer.Result> facebookCallback, int i) {
+        setRequestCode(i);
+        registerCallback(callbackManager, facebookCallback);
+    }
+
+    @Override // com.facebook.FacebookButtonBase
+    public void configureButton(Context context, AttributeSet attributeSet, int i, int i2) {
+        super.configureButton(context, attributeSet, i, i2);
+        setInternalOnClickListener(getShareOnClickListener());
+    }
+
+    public boolean canShare() {
+        return getDialog().canShow((ShareDialog) getShareContent());
+    }
+
+    public View.OnClickListener getShareOnClickListener() {
+        return new View.OnClickListener() { // from class: com.facebook.share.widget.ShareButtonBase.1
+            @Override // android.view.View.OnClickListener
+            public void onClick(View view) {
+                if (CrashShieldHandler.isObjectCrashing(this)) {
+                    return;
+                }
+                try {
+                    ShareButtonBase.this.callExternalOnClickListener(view);
+                    ShareButtonBase.this.getDialog().show(ShareButtonBase.this.getShareContent());
+                } catch (Throwable th) {
+                    CrashShieldHandler.handleThrowable(th, this);
+                }
+            }
+        };
+    }
+
+    private void internalSetEnabled(boolean z) {
+        setEnabled(z);
+        this.enabledExplicitlySet = false;
+    }
+
+    private void memorizeCallbackManager(CallbackManager callbackManager) {
+        CallbackManager callbackManager2 = this.callbackManager;
+        if (callbackManager2 == null) {
+            this.callbackManager = callbackManager;
+        } else if (callbackManager2 != callbackManager) {
+            Log.w(ShareButtonBase.class.toString(), "You're registering a callback on a Facebook Share Button 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.");
+        }
+    }
+}

decompiled/sources/com/facebook/share/widget/ShareDialog.java

@@ -0,0 +1,652 @@
+package com.facebook.share.widget;
+
+import android.app.Activity;
+import android.app.Fragment;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.net.Uri;
+import android.os.Bundle;
+import com.facebook.AccessToken;
+import com.facebook.FacebookCallback;
+import com.facebook.FacebookSdk;
+import com.facebook.appevents.InternalAppEventsLogger;
+import com.facebook.internal.AnalyticsEvents;
+import com.facebook.internal.AppCall;
+import com.facebook.internal.CallbackManagerImpl;
+import com.facebook.internal.DialogFeature;
+import com.facebook.internal.DialogPresenter;
+import com.facebook.internal.FacebookDialogBase;
+import com.facebook.internal.FragmentWrapper;
+import com.facebook.internal.NativeAppCallAttachmentStore;
+import com.facebook.share.Sharer;
+import com.facebook.share.internal.CameraEffectFeature;
+import com.facebook.share.internal.LegacyNativeDialogParameters;
+import com.facebook.share.internal.NativeDialogParameters;
+import com.facebook.share.internal.ShareContentValidation;
+import com.facebook.share.internal.ShareDialogFeature;
+import com.facebook.share.internal.ShareFeedContent;
+import com.facebook.share.internal.ShareInternalUtility;
+import com.facebook.share.internal.ShareStoryFeature;
+import com.facebook.share.internal.WebDialogParameters;
+import com.facebook.share.model.ShareCameraEffectContent;
+import com.facebook.share.model.ShareContent;
+import com.facebook.share.model.ShareLinkContent;
+import com.facebook.share.model.ShareMediaContent;
+import com.facebook.share.model.SharePhoto;
+import com.facebook.share.model.SharePhotoContent;
+import com.facebook.share.model.ShareStoryContent;
+import com.facebook.share.model.ShareVideoContent;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.UUID;
+import kotlin.collections.CollectionsKt__CollectionsKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes2.dex */
+public class ShareDialog extends FacebookDialogBase<ShareContent<?, ?>, Sharer.Result> implements Sharer {
+    private static final String FEED_DIALOG = "feed";
+    private static final String WEB_OG_SHARE_DIALOG = "share_open_graph";
+    public static final String WEB_SHARE_DIALOG = "share";
+    private boolean isAutomaticMode;
+    private final List<FacebookDialogBase<ShareContent<?, ?>, Sharer.Result>.ModeHandler> orderedModeHandlers;
+    private boolean shouldFailOnDataError;
+    public static final Companion Companion = new Companion(null);
+    private static final String TAG = ShareDialog.class.getSimpleName();
+    private static final int DEFAULT_REQUEST_CODE = CallbackManagerImpl.RequestCodeOffset.Share.toRequestCode();
+
+    public /* synthetic */ class WhenMappings {
+        public static final /* synthetic */ int[] $EnumSwitchMapping$0;
+
+        static {
+            int[] iArr = new int[Mode.valuesCustom().length];
+            iArr[Mode.AUTOMATIC.ordinal()] = 1;
+            iArr[Mode.WEB.ordinal()] = 2;
+            iArr[Mode.NATIVE.ordinal()] = 3;
+            $EnumSwitchMapping$0 = iArr;
+        }
+    }
+
+    public static boolean canShow(Class<? extends ShareContent<?, ?>> cls) {
+        return Companion.canShow(cls);
+    }
+
+    public static void show(Activity activity, ShareContent<?, ?> shareContent) {
+        Companion.show(activity, shareContent);
+    }
+
+    public static void show(Fragment fragment, ShareContent<?, ?> shareContent) {
+        Companion.show(fragment, shareContent);
+    }
+
+    public static void show(androidx.fragment.app.Fragment fragment, ShareContent<?, ?> shareContent) {
+        Companion.show(fragment, shareContent);
+    }
+
+    @Override // com.facebook.internal.FacebookDialogBase
+    public List<FacebookDialogBase<ShareContent<?, ?>, Sharer.Result>.ModeHandler> getOrderedModeHandlers() {
+        return this.orderedModeHandlers;
+    }
+
+    public boolean getShouldFailOnDataError() {
+        return this.shouldFailOnDataError;
+    }
+
+    public void setShouldFailOnDataError(boolean z) {
+        this.shouldFailOnDataError = z;
+    }
+
+    public enum Mode {
+        AUTOMATIC,
+        NATIVE,
+        WEB,
+        FEED;
+
+        /* renamed from: values, reason: to resolve conflict with enum method */
+        public static Mode[] valuesCustom() {
+            Mode[] valuesCustom = values();
+            return (Mode[]) Arrays.copyOf(valuesCustom, valuesCustom.length);
+        }
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public ShareDialog(Activity activity) {
+        this(activity, DEFAULT_REQUEST_CODE);
+        Intrinsics.checkNotNullParameter(activity, "activity");
+    }
+
+    public ShareDialog(int i) {
+        super(i);
+        ArrayList arrayListOf;
+        this.isAutomaticMode = true;
+        arrayListOf = CollectionsKt__CollectionsKt.arrayListOf(new NativeHandler(this), new FeedHandler(this), new WebShareHandler(this), new CameraEffectHandler(this), new ShareStoryHandler(this));
+        this.orderedModeHandlers = arrayListOf;
+        ShareInternalUtility.registerStaticShareCallback(i);
+    }
+
+    public /* synthetic */ ShareDialog(int i, int i2, DefaultConstructorMarker defaultConstructorMarker) {
+        this((i2 & 1) != 0 ? DEFAULT_REQUEST_CODE : i);
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public ShareDialog(androidx.fragment.app.Fragment fragment) {
+        this(new FragmentWrapper(fragment), 0, 2, null);
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public ShareDialog(Fragment fragment) {
+        this(new FragmentWrapper(fragment), 0, 2, null);
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public ShareDialog(Activity activity, int i) {
+        super(activity, i);
+        ArrayList arrayListOf;
+        Intrinsics.checkNotNullParameter(activity, "activity");
+        this.isAutomaticMode = true;
+        arrayListOf = CollectionsKt__CollectionsKt.arrayListOf(new NativeHandler(this), new FeedHandler(this), new WebShareHandler(this), new CameraEffectHandler(this), new ShareStoryHandler(this));
+        this.orderedModeHandlers = arrayListOf;
+        ShareInternalUtility.registerStaticShareCallback(i);
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public ShareDialog(androidx.fragment.app.Fragment fragment, int i) {
+        this(new FragmentWrapper(fragment), i);
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public ShareDialog(Fragment fragment, int i) {
+        this(new FragmentWrapper(fragment), i);
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+    }
+
+    public /* synthetic */ ShareDialog(FragmentWrapper fragmentWrapper, int i, int i2, DefaultConstructorMarker defaultConstructorMarker) {
+        this(fragmentWrapper, (i2 & 2) != 0 ? DEFAULT_REQUEST_CODE : i);
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public ShareDialog(FragmentWrapper fragmentWrapper, int i) {
+        super(fragmentWrapper, i);
+        ArrayList arrayListOf;
+        Intrinsics.checkNotNullParameter(fragmentWrapper, "fragmentWrapper");
+        this.isAutomaticMode = true;
+        arrayListOf = CollectionsKt__CollectionsKt.arrayListOf(new NativeHandler(this), new FeedHandler(this), new WebShareHandler(this), new CameraEffectHandler(this), new ShareStoryHandler(this));
+        this.orderedModeHandlers = arrayListOf;
+        ShareInternalUtility.registerStaticShareCallback(i);
+    }
+
+    @Override // com.facebook.internal.FacebookDialogBase
+    public void registerCallbackImpl(CallbackManagerImpl callbackManager, FacebookCallback<Sharer.Result> callback) {
+        Intrinsics.checkNotNullParameter(callbackManager, "callbackManager");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        ShareInternalUtility shareInternalUtility = ShareInternalUtility.INSTANCE;
+        ShareInternalUtility.registerSharerCallback(getRequestCode(), callbackManager, callback);
+    }
+
+    public boolean canShow(ShareContent<?, ?> content, Mode mode) {
+        Intrinsics.checkNotNullParameter(content, "content");
+        Intrinsics.checkNotNullParameter(mode, "mode");
+        Object obj = mode;
+        if (mode == Mode.AUTOMATIC) {
+            obj = FacebookDialogBase.BASE_AUTOMATIC_MODE;
+        }
+        return canShowImpl(content, obj);
+    }
+
+    public void show(ShareContent<?, ?> content, Mode mode) {
+        Intrinsics.checkNotNullParameter(content, "content");
+        Intrinsics.checkNotNullParameter(mode, "mode");
+        boolean z = mode == Mode.AUTOMATIC;
+        this.isAutomaticMode = z;
+        Object obj = mode;
+        if (z) {
+            obj = FacebookDialogBase.BASE_AUTOMATIC_MODE;
+        }
+        showImpl(content, obj);
+    }
+
+    @Override // com.facebook.internal.FacebookDialogBase
+    public AppCall createBaseAppCall() {
+        return new AppCall(getRequestCode(), null, 2, null);
+    }
+
+    public final class NativeHandler extends FacebookDialogBase<ShareContent<?, ?>, Sharer.Result>.ModeHandler {
+        private Object mode;
+        final /* synthetic */ ShareDialog this$0;
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public Object getMode() {
+            return this.mode;
+        }
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public void setMode(Object obj) {
+            Intrinsics.checkNotNullParameter(obj, "<set-?>");
+            this.mode = obj;
+        }
+
+        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+        public NativeHandler(ShareDialog this$0) {
+            super(this$0);
+            Intrinsics.checkNotNullParameter(this$0, "this$0");
+            this.this$0 = this$0;
+            this.mode = Mode.NATIVE;
+        }
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public boolean canShow(ShareContent<?, ?> content, boolean z) {
+            boolean z2;
+            String quote;
+            Intrinsics.checkNotNullParameter(content, "content");
+            if ((content instanceof ShareCameraEffectContent) || (content instanceof ShareStoryContent)) {
+                return false;
+            }
+            if (!z) {
+                if (content.getShareHashtag() != null) {
+                    DialogPresenter dialogPresenter = DialogPresenter.INSTANCE;
+                    z2 = DialogPresenter.canPresentNativeDialogWithFeature(ShareDialogFeature.HASHTAG);
+                } else {
+                    z2 = true;
+                }
+                if (!(content instanceof ShareLinkContent) || (quote = ((ShareLinkContent) content).getQuote()) == null || quote.length() == 0) {
+                    if (!z2) {
+                        return false;
+                    }
+                } else {
+                    if (!z2) {
+                        return false;
+                    }
+                    DialogPresenter dialogPresenter2 = DialogPresenter.INSTANCE;
+                    if (!DialogPresenter.canPresentNativeDialogWithFeature(ShareDialogFeature.LINK_SHARE_QUOTES)) {
+                        return false;
+                    }
+                }
+            }
+            return ShareDialog.Companion.canShowNative(content.getClass());
+        }
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public AppCall createAppCall(final ShareContent<?, ?> content) {
+            Intrinsics.checkNotNullParameter(content, "content");
+            ShareDialog shareDialog = this.this$0;
+            shareDialog.logDialogShare(shareDialog.getActivityContext(), content, Mode.NATIVE);
+            ShareContentValidation.validateForNativeShare(content);
+            final AppCall createBaseAppCall = this.this$0.createBaseAppCall();
+            final boolean shouldFailOnDataError = this.this$0.getShouldFailOnDataError();
+            DialogFeature feature = ShareDialog.Companion.getFeature(content.getClass());
+            if (feature == null) {
+                return null;
+            }
+            DialogPresenter dialogPresenter = DialogPresenter.INSTANCE;
+            DialogPresenter.setupAppCallForNativeDialog(createBaseAppCall, new DialogPresenter.ParameterProvider() { // from class: com.facebook.share.widget.ShareDialog$NativeHandler$createAppCall$1
+                @Override // com.facebook.internal.DialogPresenter.ParameterProvider
+                public Bundle getParameters() {
+                    NativeDialogParameters nativeDialogParameters = NativeDialogParameters.INSTANCE;
+                    return NativeDialogParameters.create(AppCall.this.getCallId(), content, shouldFailOnDataError);
+                }
+
+                @Override // com.facebook.internal.DialogPresenter.ParameterProvider
+                public Bundle getLegacyParameters() {
+                    LegacyNativeDialogParameters legacyNativeDialogParameters = LegacyNativeDialogParameters.INSTANCE;
+                    return LegacyNativeDialogParameters.create(AppCall.this.getCallId(), content, shouldFailOnDataError);
+                }
+            }, feature);
+            return createBaseAppCall;
+        }
+    }
+
+    public final class WebShareHandler extends FacebookDialogBase<ShareContent<?, ?>, Sharer.Result>.ModeHandler {
+        private Object mode;
+        final /* synthetic */ ShareDialog this$0;
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public Object getMode() {
+            return this.mode;
+        }
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public void setMode(Object obj) {
+            Intrinsics.checkNotNullParameter(obj, "<set-?>");
+            this.mode = obj;
+        }
+
+        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+        public WebShareHandler(ShareDialog this$0) {
+            super(this$0);
+            Intrinsics.checkNotNullParameter(this$0, "this$0");
+            this.this$0 = this$0;
+            this.mode = Mode.WEB;
+        }
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public boolean canShow(ShareContent<?, ?> content, boolean z) {
+            Intrinsics.checkNotNullParameter(content, "content");
+            return ShareDialog.Companion.canShowWebCheck(content);
+        }
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public AppCall createAppCall(ShareContent<?, ?> content) {
+            Bundle create;
+            Intrinsics.checkNotNullParameter(content, "content");
+            ShareDialog shareDialog = this.this$0;
+            shareDialog.logDialogShare(shareDialog.getActivityContext(), content, Mode.WEB);
+            AppCall createBaseAppCall = this.this$0.createBaseAppCall();
+            ShareContentValidation.validateForWebShare(content);
+            if (content instanceof ShareLinkContent) {
+                WebDialogParameters webDialogParameters = WebDialogParameters.INSTANCE;
+                create = WebDialogParameters.create((ShareLinkContent) content);
+            } else {
+                if (!(content instanceof SharePhotoContent)) {
+                    return null;
+                }
+                create = WebDialogParameters.create(createAndMapAttachments((SharePhotoContent) content, createBaseAppCall.getCallId()));
+            }
+            DialogPresenter dialogPresenter = DialogPresenter.INSTANCE;
+            DialogPresenter.setupAppCallForWebDialog(createBaseAppCall, getActionName(content), create);
+            return createBaseAppCall;
+        }
+
+        private final String getActionName(ShareContent<?, ?> shareContent) {
+            if ((shareContent instanceof ShareLinkContent) || (shareContent instanceof SharePhotoContent)) {
+                return "share";
+            }
+            return null;
+        }
+
+        private final SharePhotoContent createAndMapAttachments(SharePhotoContent sharePhotoContent, UUID uuid) {
+            SharePhotoContent.Builder readFrom = new SharePhotoContent.Builder().readFrom(sharePhotoContent);
+            ArrayList arrayList = new ArrayList();
+            ArrayList arrayList2 = new ArrayList();
+            int size = sharePhotoContent.getPhotos().size() - 1;
+            if (size >= 0) {
+                int i = 0;
+                while (true) {
+                    int i2 = i + 1;
+                    SharePhoto sharePhoto = sharePhotoContent.getPhotos().get(i);
+                    Bitmap bitmap = sharePhoto.getBitmap();
+                    if (bitmap != null) {
+                        NativeAppCallAttachmentStore.Attachment createAttachment = NativeAppCallAttachmentStore.createAttachment(uuid, bitmap);
+                        sharePhoto = new SharePhoto.Builder().readFrom(sharePhoto).setImageUrl(Uri.parse(createAttachment.getAttachmentUrl())).setBitmap(null).build();
+                        arrayList2.add(createAttachment);
+                    }
+                    arrayList.add(sharePhoto);
+                    if (i2 > size) {
+                        break;
+                    }
+                    i = i2;
+                }
+            }
+            readFrom.setPhotos(arrayList);
+            NativeAppCallAttachmentStore.addAttachments(arrayList2);
+            return readFrom.build();
+        }
+    }
+
+    public final class FeedHandler extends FacebookDialogBase<ShareContent<?, ?>, Sharer.Result>.ModeHandler {
+        private Object mode;
+        final /* synthetic */ ShareDialog this$0;
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public Object getMode() {
+            return this.mode;
+        }
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public void setMode(Object obj) {
+            Intrinsics.checkNotNullParameter(obj, "<set-?>");
+            this.mode = obj;
+        }
+
+        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+        public FeedHandler(ShareDialog this$0) {
+            super(this$0);
+            Intrinsics.checkNotNullParameter(this$0, "this$0");
+            this.this$0 = this$0;
+            this.mode = Mode.FEED;
+        }
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public boolean canShow(ShareContent<?, ?> content, boolean z) {
+            Intrinsics.checkNotNullParameter(content, "content");
+            return (content instanceof ShareLinkContent) || (content instanceof ShareFeedContent);
+        }
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public AppCall createAppCall(ShareContent<?, ?> content) {
+            Bundle createForFeed;
+            Intrinsics.checkNotNullParameter(content, "content");
+            ShareDialog shareDialog = this.this$0;
+            shareDialog.logDialogShare(shareDialog.getActivityContext(), content, Mode.FEED);
+            AppCall createBaseAppCall = this.this$0.createBaseAppCall();
+            if (content instanceof ShareLinkContent) {
+                ShareContentValidation.validateForWebShare(content);
+                WebDialogParameters webDialogParameters = WebDialogParameters.INSTANCE;
+                createForFeed = WebDialogParameters.createForFeed((ShareLinkContent) content);
+            } else {
+                if (!(content instanceof ShareFeedContent)) {
+                    return null;
+                }
+                WebDialogParameters webDialogParameters2 = WebDialogParameters.INSTANCE;
+                createForFeed = WebDialogParameters.createForFeed((ShareFeedContent) content);
+            }
+            DialogPresenter.setupAppCallForWebDialog(createBaseAppCall, ShareDialog.FEED_DIALOG, createForFeed);
+            return createBaseAppCall;
+        }
+    }
+
+    public final class CameraEffectHandler extends FacebookDialogBase<ShareContent<?, ?>, Sharer.Result>.ModeHandler {
+        private Object mode;
+        final /* synthetic */ ShareDialog this$0;
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public Object getMode() {
+            return this.mode;
+        }
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public void setMode(Object obj) {
+            Intrinsics.checkNotNullParameter(obj, "<set-?>");
+            this.mode = obj;
+        }
+
+        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+        public CameraEffectHandler(ShareDialog this$0) {
+            super(this$0);
+            Intrinsics.checkNotNullParameter(this$0, "this$0");
+            this.this$0 = this$0;
+            this.mode = Mode.NATIVE;
+        }
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public boolean canShow(ShareContent<?, ?> content, boolean z) {
+            Intrinsics.checkNotNullParameter(content, "content");
+            return (content instanceof ShareCameraEffectContent) && ShareDialog.Companion.canShowNative(content.getClass());
+        }
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public AppCall createAppCall(final ShareContent<?, ?> content) {
+            Intrinsics.checkNotNullParameter(content, "content");
+            ShareContentValidation.validateForNativeShare(content);
+            final AppCall createBaseAppCall = this.this$0.createBaseAppCall();
+            final boolean shouldFailOnDataError = this.this$0.getShouldFailOnDataError();
+            DialogFeature feature = ShareDialog.Companion.getFeature(content.getClass());
+            if (feature == null) {
+                return null;
+            }
+            DialogPresenter dialogPresenter = DialogPresenter.INSTANCE;
+            DialogPresenter.setupAppCallForNativeDialog(createBaseAppCall, new DialogPresenter.ParameterProvider() { // from class: com.facebook.share.widget.ShareDialog$CameraEffectHandler$createAppCall$1
+                @Override // com.facebook.internal.DialogPresenter.ParameterProvider
+                public Bundle getParameters() {
+                    NativeDialogParameters nativeDialogParameters = NativeDialogParameters.INSTANCE;
+                    return NativeDialogParameters.create(AppCall.this.getCallId(), content, shouldFailOnDataError);
+                }
+
+                @Override // com.facebook.internal.DialogPresenter.ParameterProvider
+                public Bundle getLegacyParameters() {
+                    LegacyNativeDialogParameters legacyNativeDialogParameters = LegacyNativeDialogParameters.INSTANCE;
+                    return LegacyNativeDialogParameters.create(AppCall.this.getCallId(), content, shouldFailOnDataError);
+                }
+            }, feature);
+            return createBaseAppCall;
+        }
+    }
+
+    public final class ShareStoryHandler extends FacebookDialogBase<ShareContent<?, ?>, Sharer.Result>.ModeHandler {
+        private Object mode;
+        final /* synthetic */ ShareDialog this$0;
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public Object getMode() {
+            return this.mode;
+        }
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public void setMode(Object obj) {
+            Intrinsics.checkNotNullParameter(obj, "<set-?>");
+            this.mode = obj;
+        }
+
+        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+        public ShareStoryHandler(ShareDialog this$0) {
+            super(this$0);
+            Intrinsics.checkNotNullParameter(this$0, "this$0");
+            this.this$0 = this$0;
+            this.mode = Mode.NATIVE;
+        }
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public boolean canShow(ShareContent<?, ?> content, boolean z) {
+            Intrinsics.checkNotNullParameter(content, "content");
+            return (content instanceof ShareStoryContent) && ShareDialog.Companion.canShowNative(content.getClass());
+        }
+
+        @Override // com.facebook.internal.FacebookDialogBase.ModeHandler
+        public AppCall createAppCall(final ShareContent<?, ?> content) {
+            Intrinsics.checkNotNullParameter(content, "content");
+            ShareContentValidation.validateForStoryShare(content);
+            final AppCall createBaseAppCall = this.this$0.createBaseAppCall();
+            final boolean shouldFailOnDataError = this.this$0.getShouldFailOnDataError();
+            DialogFeature feature = ShareDialog.Companion.getFeature(content.getClass());
+            if (feature == null) {
+                return null;
+            }
+            DialogPresenter dialogPresenter = DialogPresenter.INSTANCE;
+            DialogPresenter.setupAppCallForNativeDialog(createBaseAppCall, new DialogPresenter.ParameterProvider() { // from class: com.facebook.share.widget.ShareDialog$ShareStoryHandler$createAppCall$1
+                @Override // com.facebook.internal.DialogPresenter.ParameterProvider
+                public Bundle getParameters() {
+                    NativeDialogParameters nativeDialogParameters = NativeDialogParameters.INSTANCE;
+                    return NativeDialogParameters.create(AppCall.this.getCallId(), content, shouldFailOnDataError);
+                }
+
+                @Override // com.facebook.internal.DialogPresenter.ParameterProvider
+                public Bundle getLegacyParameters() {
+                    LegacyNativeDialogParameters legacyNativeDialogParameters = LegacyNativeDialogParameters.INSTANCE;
+                    return LegacyNativeDialogParameters.create(AppCall.this.getCallId(), content, shouldFailOnDataError);
+                }
+            }, feature);
+            return createBaseAppCall;
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final void logDialogShare(Context context, ShareContent<?, ?> shareContent, Mode mode) {
+        if (this.isAutomaticMode) {
+            mode = Mode.AUTOMATIC;
+        }
+        int i = WhenMappings.$EnumSwitchMapping$0[mode.ordinal()];
+        String str = "unknown";
+        String str2 = i != 1 ? i != 2 ? i != 3 ? "unknown" : "native" : AnalyticsEvents.PARAMETER_SHARE_DIALOG_SHOW_WEB : AnalyticsEvents.PARAMETER_SHARE_DIALOG_SHOW_AUTOMATIC;
+        DialogFeature feature = Companion.getFeature(shareContent.getClass());
+        if (feature == ShareDialogFeature.SHARE_DIALOG) {
+            str = "status";
+        } else if (feature == ShareDialogFeature.PHOTOS) {
+            str = AnalyticsEvents.PARAMETER_SHARE_DIALOG_CONTENT_PHOTO;
+        } else if (feature == ShareDialogFeature.VIDEO) {
+            str = "video";
+        }
+        InternalAppEventsLogger createInstance = InternalAppEventsLogger.Companion.createInstance(context, FacebookSdk.getApplicationId());
+        Bundle bundle = new Bundle();
+        bundle.putString("fb_share_dialog_show", str2);
+        bundle.putString(AnalyticsEvents.PARAMETER_SHARE_DIALOG_CONTENT_TYPE, str);
+        createInstance.logEventImplicitly("fb_share_dialog_show", bundle);
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public void show(Activity activity, ShareContent<?, ?> shareContent) {
+            Intrinsics.checkNotNullParameter(activity, "activity");
+            Intrinsics.checkNotNullParameter(shareContent, "shareContent");
+            new ShareDialog(activity).show(shareContent);
+        }
+
+        public void show(androidx.fragment.app.Fragment fragment, ShareContent<?, ?> shareContent) {
+            Intrinsics.checkNotNullParameter(fragment, "fragment");
+            Intrinsics.checkNotNullParameter(shareContent, "shareContent");
+            show(new FragmentWrapper(fragment), shareContent);
+        }
+
+        public void show(Fragment fragment, ShareContent<?, ?> shareContent) {
+            Intrinsics.checkNotNullParameter(fragment, "fragment");
+            Intrinsics.checkNotNullParameter(shareContent, "shareContent");
+            show(new FragmentWrapper(fragment), shareContent);
+        }
+
+        private final void show(FragmentWrapper fragmentWrapper, ShareContent<?, ?> shareContent) {
+            new ShareDialog(fragmentWrapper, 0, 2, null).show(shareContent);
+        }
+
+        public boolean canShow(Class<? extends ShareContent<?, ?>> contentType) {
+            Intrinsics.checkNotNullParameter(contentType, "contentType");
+            return canShowWebTypeCheck(contentType) || canShowNative(contentType);
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public final boolean canShowNative(Class<? extends ShareContent<?, ?>> cls) {
+            DialogFeature feature = getFeature(cls);
+            return feature != null && DialogPresenter.canPresentNativeDialogWithFeature(feature);
+        }
+
+        private final boolean canShowWebTypeCheck(Class<? extends ShareContent<?, ?>> cls) {
+            return ShareLinkContent.class.isAssignableFrom(cls) || (SharePhotoContent.class.isAssignableFrom(cls) && AccessToken.Companion.isCurrentAccessTokenActive());
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        /* JADX WARN: Multi-variable type inference failed */
+        public final boolean canShowWebCheck(ShareContent<?, ?> shareContent) {
+            return canShowWebTypeCheck(shareContent.getClass());
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public final DialogFeature getFeature(Class<? extends ShareContent<?, ?>> cls) {
+            if (ShareLinkContent.class.isAssignableFrom(cls)) {
+                return ShareDialogFeature.SHARE_DIALOG;
+            }
+            if (SharePhotoContent.class.isAssignableFrom(cls)) {
+                return ShareDialogFeature.PHOTOS;
+            }
+            if (ShareVideoContent.class.isAssignableFrom(cls)) {
+                return ShareDialogFeature.VIDEO;
+            }
+            if (ShareMediaContent.class.isAssignableFrom(cls)) {
+                return ShareDialogFeature.MULTIMEDIA;
+            }
+            if (ShareCameraEffectContent.class.isAssignableFrom(cls)) {
+                return CameraEffectFeature.SHARE_CAMERA_EFFECT;
+            }
+            if (ShareStoryContent.class.isAssignableFrom(cls)) {
+                return ShareStoryFeature.SHARE_STORY_ASSET;
+            }
+            return null;
+        }
+    }
+}