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/share/internal/CameraEffectFeature.java

@@ -0,0 +1,32 @@
+package com.facebook.share.internal;
+
+import com.facebook.internal.DialogFeature;
+import com.facebook.internal.NativeProtocol;
+import java.util.Arrays;
+
+/* loaded from: classes2.dex */
+public enum CameraEffectFeature implements DialogFeature {
+    SHARE_CAMERA_EFFECT(NativeProtocol.PROTOCOL_VERSION_20170417);
+
+    private final int minVersion;
+
+    @Override // com.facebook.internal.DialogFeature
+    public String getAction() {
+        return NativeProtocol.ACTION_CAMERA_EFFECT;
+    }
+
+    @Override // com.facebook.internal.DialogFeature
+    public int getMinVersion() {
+        return this.minVersion;
+    }
+
+    CameraEffectFeature(int i) {
+        this.minVersion = i;
+    }
+
+    /* renamed from: values, reason: to resolve conflict with enum method */
+    public static CameraEffectFeature[] valuesCustom() {
+        CameraEffectFeature[] valuesCustom = values();
+        return (CameraEffectFeature[]) Arrays.copyOf(valuesCustom, valuesCustom.length);
+    }
+}

decompiled-community/sources/com/facebook/share/internal/CameraEffectJSONUtility.java

@@ -0,0 +1,158 @@
+package com.facebook.share.internal;
+
+import com.facebook.share.model.CameraEffectArguments;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import kotlin.TuplesKt;
+import kotlin.collections.MapsKt__MapsKt;
+import kotlin.jvm.internal.Intrinsics;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes2.dex */
+public final class CameraEffectJSONUtility {
+    public static final CameraEffectJSONUtility INSTANCE = new CameraEffectJSONUtility();
+    private static final HashMap<Class<?>, Setter> SETTERS;
+
+    public interface Setter {
+        void setOnArgumentsBuilder(CameraEffectArguments.Builder builder, String str, Object obj) throws JSONException;
+
+        void setOnJSON(JSONObject jSONObject, String str, Object obj) throws JSONException;
+    }
+
+    private CameraEffectJSONUtility() {
+    }
+
+    static {
+        HashMap<Class<?>, Setter> hashMapOf;
+        hashMapOf = MapsKt__MapsKt.hashMapOf(TuplesKt.to(String.class, new Setter() { // from class: com.facebook.share.internal.CameraEffectJSONUtility$SETTERS$1
+            @Override // com.facebook.share.internal.CameraEffectJSONUtility.Setter
+            public void setOnArgumentsBuilder(CameraEffectArguments.Builder builder, String key, Object obj) throws JSONException {
+                Intrinsics.checkNotNullParameter(builder, "builder");
+                Intrinsics.checkNotNullParameter(key, "key");
+                if (obj == null) {
+                    throw new NullPointerException("null cannot be cast to non-null type kotlin.String");
+                }
+                builder.putArgument(key, (String) obj);
+            }
+
+            @Override // com.facebook.share.internal.CameraEffectJSONUtility.Setter
+            public void setOnJSON(JSONObject json, String key, Object obj) throws JSONException {
+                Intrinsics.checkNotNullParameter(json, "json");
+                Intrinsics.checkNotNullParameter(key, "key");
+                json.put(key, obj);
+            }
+        }), TuplesKt.to(String[].class, new Setter() { // from class: com.facebook.share.internal.CameraEffectJSONUtility$SETTERS$2
+            @Override // com.facebook.share.internal.CameraEffectJSONUtility.Setter
+            public void setOnArgumentsBuilder(CameraEffectArguments.Builder builder, String key, Object obj) throws JSONException {
+                Intrinsics.checkNotNullParameter(builder, "builder");
+                Intrinsics.checkNotNullParameter(key, "key");
+                throw new IllegalArgumentException("Unexpected type from JSON");
+            }
+
+            @Override // com.facebook.share.internal.CameraEffectJSONUtility.Setter
+            public void setOnJSON(JSONObject json, String key, Object obj) throws JSONException {
+                Intrinsics.checkNotNullParameter(json, "json");
+                Intrinsics.checkNotNullParameter(key, "key");
+                JSONArray jSONArray = new JSONArray();
+                if (obj != null) {
+                    String[] strArr = (String[]) obj;
+                    int length = strArr.length;
+                    int i = 0;
+                    while (i < length) {
+                        String str = strArr[i];
+                        i++;
+                        jSONArray.put(str);
+                    }
+                    json.put(key, jSONArray);
+                    return;
+                }
+                throw new NullPointerException("null cannot be cast to non-null type kotlin.Array<kotlin.String?>");
+            }
+        }), TuplesKt.to(JSONArray.class, new Setter() { // from class: com.facebook.share.internal.CameraEffectJSONUtility$SETTERS$3
+            @Override // com.facebook.share.internal.CameraEffectJSONUtility.Setter
+            public void setOnArgumentsBuilder(CameraEffectArguments.Builder builder, String key, Object obj) throws JSONException {
+                Intrinsics.checkNotNullParameter(builder, "builder");
+                Intrinsics.checkNotNullParameter(key, "key");
+                if (obj != null) {
+                    JSONArray jSONArray = (JSONArray) obj;
+                    ArrayList arrayList = new ArrayList();
+                    int length = jSONArray.length();
+                    if (length > 0) {
+                        int i = 0;
+                        while (true) {
+                            int i2 = i + 1;
+                            Object obj2 = jSONArray.get(i);
+                            if (obj2 instanceof String) {
+                                arrayList.add(obj2);
+                                if (i2 >= length) {
+                                    break;
+                                } else {
+                                    i = i2;
+                                }
+                            } else {
+                                throw new IllegalArgumentException(Intrinsics.stringPlus("Unexpected type in an array: ", obj2.getClass()));
+                            }
+                        }
+                    }
+                    Object[] array = arrayList.toArray(new String[0]);
+                    if (array == null) {
+                        throw new NullPointerException("null cannot be cast to non-null type kotlin.Array<T>");
+                    }
+                    builder.putArgument(key, (String[]) array);
+                    return;
+                }
+                throw new NullPointerException("null cannot be cast to non-null type org.json.JSONArray");
+            }
+
+            @Override // com.facebook.share.internal.CameraEffectJSONUtility.Setter
+            public void setOnJSON(JSONObject json, String key, Object obj) throws JSONException {
+                Intrinsics.checkNotNullParameter(json, "json");
+                Intrinsics.checkNotNullParameter(key, "key");
+                throw new IllegalArgumentException("JSONArray's are not supported in bundles.");
+            }
+        }));
+        SETTERS = hashMapOf;
+    }
+
+    public static final JSONObject convertToJSON(CameraEffectArguments cameraEffectArguments) throws JSONException {
+        if (cameraEffectArguments == null) {
+            return null;
+        }
+        JSONObject jSONObject = new JSONObject();
+        for (String str : cameraEffectArguments.keySet()) {
+            Object obj = cameraEffectArguments.get(str);
+            if (obj != null) {
+                Setter setter = SETTERS.get(obj.getClass());
+                if (setter == null) {
+                    throw new IllegalArgumentException(Intrinsics.stringPlus("Unsupported type: ", obj.getClass()));
+                }
+                setter.setOnJSON(jSONObject, str, obj);
+            }
+        }
+        return jSONObject;
+    }
+
+    public static final CameraEffectArguments convertToCameraEffectArguments(JSONObject jSONObject) throws JSONException {
+        if (jSONObject == null) {
+            return null;
+        }
+        CameraEffectArguments.Builder builder = new CameraEffectArguments.Builder();
+        Iterator<String> keys = jSONObject.keys();
+        while (keys.hasNext()) {
+            String key = keys.next();
+            Object obj = jSONObject.get(key);
+            if (obj != JSONObject.NULL) {
+                Setter setter = SETTERS.get(obj.getClass());
+                if (setter == null) {
+                    throw new IllegalArgumentException(Intrinsics.stringPlus("Unsupported type: ", obj.getClass()));
+                }
+                Intrinsics.checkNotNullExpressionValue(key, "key");
+                setter.setOnArgumentsBuilder(builder, key, obj);
+            }
+        }
+        return builder.build();
+    }
+}

decompiled-community/sources/com/facebook/share/internal/GameRequestValidation.java

@@ -0,0 +1,24 @@
+package com.facebook.share.internal;
+
+import com.facebook.internal.Validate;
+import com.facebook.share.model.GameRequestContent;
+
+/* loaded from: classes2.dex */
+public class GameRequestValidation {
+    public static void validate(GameRequestContent gameRequestContent) {
+        Validate.notNull(gameRequestContent.getMessage(), "message");
+        if ((gameRequestContent.getObjectId() != null) ^ (gameRequestContent.getActionType() == GameRequestContent.ActionType.ASKFOR || gameRequestContent.getActionType() == GameRequestContent.ActionType.SEND)) {
+            throw new IllegalArgumentException("Object id should be provided if and only if action type is send or askfor");
+        }
+        int i = gameRequestContent.getRecipients() != null ? 1 : 0;
+        if (gameRequestContent.getSuggestions() != null) {
+            i++;
+        }
+        if (gameRequestContent.getFilters() != null) {
+            i++;
+        }
+        if (i > 1) {
+            throw new IllegalArgumentException("Parameters to, filters and suggestions are mutually exclusive");
+        }
+    }
+}

decompiled-community/sources/com/facebook/share/internal/LegacyNativeDialogParameters.java

@@ -0,0 +1,64 @@
+package com.facebook.share.internal;
+
+import android.os.Bundle;
+import com.facebook.internal.Utility;
+import com.facebook.share.model.ShareContent;
+import com.facebook.share.model.ShareLinkContent;
+import com.facebook.share.model.SharePhotoContent;
+import com.facebook.share.model.ShareVideoContent;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import kotlin.collections.CollectionsKt__CollectionsKt;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes2.dex */
+public final class LegacyNativeDialogParameters {
+    public static final LegacyNativeDialogParameters INSTANCE = new LegacyNativeDialogParameters();
+
+    private LegacyNativeDialogParameters() {
+    }
+
+    public static final Bundle create(UUID callId, ShareContent<?, ?> shareContent, boolean z) {
+        Intrinsics.checkNotNullParameter(callId, "callId");
+        Intrinsics.checkNotNullParameter(shareContent, "shareContent");
+        if (shareContent instanceof ShareLinkContent) {
+            return INSTANCE.create((ShareLinkContent) shareContent, z);
+        }
+        if (shareContent instanceof SharePhotoContent) {
+            ShareInternalUtility shareInternalUtility = ShareInternalUtility.INSTANCE;
+            SharePhotoContent sharePhotoContent = (SharePhotoContent) shareContent;
+            List<String> photoUrls = ShareInternalUtility.getPhotoUrls(sharePhotoContent, callId);
+            if (photoUrls == null) {
+                photoUrls = CollectionsKt__CollectionsKt.emptyList();
+            }
+            return INSTANCE.create(sharePhotoContent, photoUrls, z);
+        }
+        boolean z2 = shareContent instanceof ShareVideoContent;
+        return null;
+    }
+
+    private final Bundle create(ShareLinkContent shareLinkContent, boolean z) {
+        return createBaseParameters(shareLinkContent, z);
+    }
+
+    private final Bundle create(SharePhotoContent sharePhotoContent, List<String> list, boolean z) {
+        Bundle createBaseParameters = createBaseParameters(sharePhotoContent, z);
+        createBaseParameters.putStringArrayList(ShareConstants.LEGACY_PHOTOS, new ArrayList<>(list));
+        return createBaseParameters;
+    }
+
+    private final Bundle createBaseParameters(ShareContent<?, ?> shareContent, boolean z) {
+        Bundle bundle = new Bundle();
+        Utility utility = Utility.INSTANCE;
+        Utility.putUri(bundle, ShareConstants.LEGACY_LINK, shareContent.getContentUrl());
+        Utility.putNonEmptyString(bundle, ShareConstants.LEGACY_PLACE_TAG, shareContent.getPlaceId());
+        Utility.putNonEmptyString(bundle, ShareConstants.LEGACY_REF, shareContent.getRef());
+        bundle.putBoolean(ShareConstants.LEGACY_DATA_FAILURES_FATAL, z);
+        List<String> peopleIds = shareContent.getPeopleIds();
+        if (peopleIds != null && !peopleIds.isEmpty()) {
+            bundle.putStringArrayList(ShareConstants.LEGACY_FRIEND_TAGS, new ArrayList<>(peopleIds));
+        }
+        return bundle;
+    }
+}

decompiled-community/sources/com/facebook/share/internal/MessageDialogFeature.java

@@ -0,0 +1,30 @@
+package com.facebook.share.internal;
+
+import com.facebook.internal.DialogFeature;
+import com.facebook.internal.NativeProtocol;
+
+/* loaded from: classes2.dex */
+public enum MessageDialogFeature implements DialogFeature {
+    MESSAGE_DIALOG(NativeProtocol.PROTOCOL_VERSION_20140204),
+    PHOTOS(NativeProtocol.PROTOCOL_VERSION_20140324),
+    VIDEO(NativeProtocol.PROTOCOL_VERSION_20141218),
+    MESSENGER_GENERIC_TEMPLATE(NativeProtocol.PROTOCOL_VERSION_20171115),
+    MESSENGER_OPEN_GRAPH_MUSIC_TEMPLATE(NativeProtocol.PROTOCOL_VERSION_20171115),
+    MESSENGER_MEDIA_TEMPLATE(NativeProtocol.PROTOCOL_VERSION_20171115);
+
+    private int minVersion;
+
+    @Override // com.facebook.internal.DialogFeature
+    public String getAction() {
+        return NativeProtocol.ACTION_MESSAGE_DIALOG;
+    }
+
+    @Override // com.facebook.internal.DialogFeature
+    public int getMinVersion() {
+        return this.minVersion;
+    }
+
+    MessageDialogFeature(int i) {
+        this.minVersion = i;
+    }
+}

decompiled-community/sources/com/facebook/share/internal/NativeDialogParameters.java

@@ -0,0 +1,154 @@
+package com.facebook.share.internal;
+
+import android.os.Bundle;
+import com.facebook.FacebookException;
+import com.facebook.internal.Utility;
+import com.facebook.share.model.ShareCameraEffectContent;
+import com.facebook.share.model.ShareContent;
+import com.facebook.share.model.ShareHashtag;
+import com.facebook.share.model.ShareLinkContent;
+import com.facebook.share.model.ShareMediaContent;
+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.List;
+import java.util.UUID;
+import kotlin.collections.CollectionsKt__CollectionsKt;
+import kotlin.jvm.internal.Intrinsics;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes2.dex */
+public final class NativeDialogParameters {
+    public static final NativeDialogParameters INSTANCE = new NativeDialogParameters();
+
+    private NativeDialogParameters() {
+    }
+
+    public static final Bundle create(UUID callId, ShareContent<?, ?> shareContent, boolean z) {
+        Intrinsics.checkNotNullParameter(callId, "callId");
+        Intrinsics.checkNotNullParameter(shareContent, "shareContent");
+        if (shareContent instanceof ShareLinkContent) {
+            return INSTANCE.create((ShareLinkContent) shareContent, z);
+        }
+        if (shareContent instanceof SharePhotoContent) {
+            ShareInternalUtility shareInternalUtility = ShareInternalUtility.INSTANCE;
+            SharePhotoContent sharePhotoContent = (SharePhotoContent) shareContent;
+            List<String> photoUrls = ShareInternalUtility.getPhotoUrls(sharePhotoContent, callId);
+            if (photoUrls == null) {
+                photoUrls = CollectionsKt__CollectionsKt.emptyList();
+            }
+            return INSTANCE.create(sharePhotoContent, photoUrls, z);
+        }
+        if (shareContent instanceof ShareVideoContent) {
+            ShareInternalUtility shareInternalUtility2 = ShareInternalUtility.INSTANCE;
+            ShareVideoContent shareVideoContent = (ShareVideoContent) shareContent;
+            return INSTANCE.create(shareVideoContent, ShareInternalUtility.getVideoUrl(shareVideoContent, callId), z);
+        }
+        if (shareContent instanceof ShareMediaContent) {
+            ShareInternalUtility shareInternalUtility3 = ShareInternalUtility.INSTANCE;
+            ShareMediaContent shareMediaContent = (ShareMediaContent) shareContent;
+            List<Bundle> mediaInfos = ShareInternalUtility.getMediaInfos(shareMediaContent, callId);
+            if (mediaInfos == null) {
+                mediaInfos = CollectionsKt__CollectionsKt.emptyList();
+            }
+            return INSTANCE.create(shareMediaContent, mediaInfos, z);
+        }
+        if (shareContent instanceof ShareCameraEffectContent) {
+            ShareInternalUtility shareInternalUtility4 = ShareInternalUtility.INSTANCE;
+            ShareCameraEffectContent shareCameraEffectContent = (ShareCameraEffectContent) shareContent;
+            return INSTANCE.create(shareCameraEffectContent, ShareInternalUtility.getTextureUrlBundle(shareCameraEffectContent, callId), z);
+        }
+        if (!(shareContent instanceof ShareStoryContent)) {
+            return null;
+        }
+        ShareInternalUtility shareInternalUtility5 = ShareInternalUtility.INSTANCE;
+        ShareStoryContent shareStoryContent = (ShareStoryContent) shareContent;
+        return INSTANCE.create(shareStoryContent, ShareInternalUtility.getBackgroundAssetMediaInfo(shareStoryContent, callId), ShareInternalUtility.getStickerUrl(shareStoryContent, callId), z);
+    }
+
+    private final Bundle create(ShareCameraEffectContent shareCameraEffectContent, Bundle bundle, boolean z) {
+        Bundle createBaseParameters = createBaseParameters(shareCameraEffectContent, z);
+        Utility utility = Utility.INSTANCE;
+        Utility.putNonEmptyString(createBaseParameters, ShareConstants.EFFECT_ID, shareCameraEffectContent.getEffectId());
+        if (bundle != null) {
+            createBaseParameters.putBundle(ShareConstants.EFFECT_TEXTURES, bundle);
+        }
+        try {
+            CameraEffectJSONUtility cameraEffectJSONUtility = CameraEffectJSONUtility.INSTANCE;
+            JSONObject convertToJSON = CameraEffectJSONUtility.convertToJSON(shareCameraEffectContent.getArguments());
+            if (convertToJSON != null) {
+                Utility.putNonEmptyString(createBaseParameters, ShareConstants.EFFECT_ARGS, convertToJSON.toString());
+            }
+            return createBaseParameters;
+        } catch (JSONException e) {
+            throw new FacebookException(Intrinsics.stringPlus("Unable to create a JSON Object from the provided CameraEffectArguments: ", e.getMessage()));
+        }
+    }
+
+    private final Bundle create(ShareLinkContent shareLinkContent, boolean z) {
+        Bundle createBaseParameters = createBaseParameters(shareLinkContent, z);
+        Utility utility = Utility.INSTANCE;
+        Utility.putNonEmptyString(createBaseParameters, ShareConstants.QUOTE, shareLinkContent.getQuote());
+        Utility.putUri(createBaseParameters, ShareConstants.MESSENGER_URL, shareLinkContent.getContentUrl());
+        Utility.putUri(createBaseParameters, ShareConstants.TARGET_DISPLAY, shareLinkContent.getContentUrl());
+        return createBaseParameters;
+    }
+
+    private final Bundle create(SharePhotoContent sharePhotoContent, List<String> list, boolean z) {
+        Bundle createBaseParameters = createBaseParameters(sharePhotoContent, z);
+        createBaseParameters.putStringArrayList(ShareConstants.PHOTOS, new ArrayList<>(list));
+        return createBaseParameters;
+    }
+
+    private final Bundle create(ShareVideoContent shareVideoContent, String str, boolean z) {
+        Bundle createBaseParameters = createBaseParameters(shareVideoContent, z);
+        Utility utility = Utility.INSTANCE;
+        Utility.putNonEmptyString(createBaseParameters, ShareConstants.TITLE, shareVideoContent.getContentTitle());
+        Utility.putNonEmptyString(createBaseParameters, ShareConstants.DESCRIPTION, shareVideoContent.getContentDescription());
+        Utility.putNonEmptyString(createBaseParameters, ShareConstants.VIDEO_URL, str);
+        return createBaseParameters;
+    }
+
+    private final Bundle create(ShareMediaContent shareMediaContent, List<Bundle> list, boolean z) {
+        Bundle createBaseParameters = createBaseParameters(shareMediaContent, z);
+        createBaseParameters.putParcelableArrayList(ShareConstants.MEDIA, new ArrayList<>(list));
+        return createBaseParameters;
+    }
+
+    private final Bundle create(ShareStoryContent shareStoryContent, Bundle bundle, Bundle bundle2, boolean z) {
+        Bundle createBaseParameters = createBaseParameters(shareStoryContent, z);
+        if (bundle != null) {
+            createBaseParameters.putParcelable(ShareConstants.STORY_BG_ASSET, bundle);
+        }
+        if (bundle2 != null) {
+            createBaseParameters.putParcelable(ShareConstants.STORY_INTERACTIVE_ASSET_URI, bundle2);
+        }
+        List<String> backgroundColorList = shareStoryContent.getBackgroundColorList();
+        if (backgroundColorList != null && !backgroundColorList.isEmpty()) {
+            createBaseParameters.putStringArrayList(ShareConstants.STORY_INTERACTIVE_COLOR_LIST, new ArrayList<>(backgroundColorList));
+        }
+        Utility utility = Utility.INSTANCE;
+        Utility.putNonEmptyString(createBaseParameters, ShareConstants.STORY_DEEP_LINK_URL, shareStoryContent.getAttributionLink());
+        return createBaseParameters;
+    }
+
+    private final Bundle createBaseParameters(ShareContent<?, ?> shareContent, boolean z) {
+        Bundle bundle = new Bundle();
+        Utility utility = Utility.INSTANCE;
+        Utility.putUri(bundle, ShareConstants.CONTENT_URL, shareContent.getContentUrl());
+        Utility.putNonEmptyString(bundle, ShareConstants.PLACE_ID, shareContent.getPlaceId());
+        Utility.putNonEmptyString(bundle, ShareConstants.PAGE_ID, shareContent.getPageId());
+        Utility.putNonEmptyString(bundle, ShareConstants.REF, shareContent.getRef());
+        Utility.putNonEmptyString(bundle, ShareConstants.REF, shareContent.getRef());
+        bundle.putBoolean(ShareConstants.DATA_FAILURES_FATAL, z);
+        List<String> peopleIds = shareContent.getPeopleIds();
+        if (peopleIds != null && !peopleIds.isEmpty()) {
+            bundle.putStringArrayList(ShareConstants.PEOPLE_IDS, new ArrayList<>(peopleIds));
+        }
+        ShareHashtag shareHashtag = shareContent.getShareHashtag();
+        Utility.putNonEmptyString(bundle, ShareConstants.HASHTAG, shareHashtag == null ? null : shareHashtag.getHashtag());
+        return bundle;
+    }
+}

decompiled-community/sources/com/facebook/share/internal/ResultProcessor.java

@@ -0,0 +1,37 @@
+package com.facebook.share.internal;
+
+import android.os.Bundle;
+import com.facebook.FacebookCallback;
+import com.facebook.FacebookException;
+import com.facebook.internal.AppCall;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes2.dex */
+public abstract class ResultProcessor {
+    private final FacebookCallback<?> appCallback;
+
+    public abstract void onSuccess(AppCall appCall, Bundle bundle);
+
+    public ResultProcessor(FacebookCallback<?> facebookCallback) {
+        this.appCallback = facebookCallback;
+    }
+
+    public void onCancel(AppCall appCall) {
+        Intrinsics.checkNotNullParameter(appCall, "appCall");
+        FacebookCallback<?> facebookCallback = this.appCallback;
+        if (facebookCallback == null) {
+            return;
+        }
+        facebookCallback.onCancel();
+    }
+
+    public void onError(AppCall appCall, FacebookException error) {
+        Intrinsics.checkNotNullParameter(appCall, "appCall");
+        Intrinsics.checkNotNullParameter(error, "error");
+        FacebookCallback<?> facebookCallback = this.appCallback;
+        if (facebookCallback == null) {
+            return;
+        }
+        facebookCallback.onError(error);
+    }
+}

decompiled-community/sources/com/facebook/share/internal/ShareConstants.java

@@ -0,0 +1,107 @@
+package com.facebook.share.internal;
+
+/* loaded from: classes2.dex */
+public final class ShareConstants {
+    public static final String ACTION = "ACTION";
+    public static final String ACTION_TYPE = "ACTION_TYPE";
+    public static final String APPLINK_URL = "app_link_url";
+    public static final String ATTACHMENT_ID = "ATTACHMENT_ID";
+    public static final String BUTTON_TITLE = "BUTTON_TITLE";
+    public static final String BUTTON_URL = "BUTTON_URL";
+    public static final String CONTENT_URL = "LINK";
+    public static final String DATA_FAILURES_FATAL = "DATA_FAILURES_FATAL";
+    public static final String DEEPLINK_CONTEXT = "deeplink_context";
+    public static final String DESCRIPTION = "DESCRIPTION";
+    public static final String DESTINATION = "destination";
+    public static final String EFFECT_ARGS = "effect_arguments";
+    public static final String EFFECT_ID = "effect_id";
+    public static final String EFFECT_TEXTURES = "effect_textures";
+    public static final String EXTRA_LIKE_COUNT_STRING_WITHOUT_LIKE = "com.facebook.platform.extra.LIKE_COUNT_STRING_WITHOUT_LIKE";
+    public static final String EXTRA_LIKE_COUNT_STRING_WITH_LIKE = "com.facebook.platform.extra.LIKE_COUNT_STRING_WITH_LIKE";
+    public static final String EXTRA_OBJECT_ID = "com.facebook.platform.extra.OBJECT_ID";
+    public static final String EXTRA_OBJECT_IS_LIKED = "com.facebook.platform.extra.OBJECT_IS_LIKED";
+    public static final String EXTRA_RESULT_POST_ID = "com.facebook.platform.extra.POST_ID";
+    public static final String EXTRA_SOCIAL_SENTENCE_WITHOUT_LIKE = "com.facebook.platform.extra.SOCIAL_SENTENCE_WITHOUT_LIKE";
+    public static final String EXTRA_SOCIAL_SENTENCE_WITH_LIKE = "com.facebook.platform.extra.SOCIAL_SENTENCE_WITH_LIKE";
+    public static final String EXTRA_UNLIKE_TOKEN = "com.facebook.platform.extra.UNLIKE_TOKEN";
+    public static final String FEED_CAPTION_PARAM = "caption";
+    public static final String FEED_DESCRIPTION_PARAM = "description";
+    public static final String FEED_LINK_PARAM = "link";
+    public static final String FEED_NAME_PARAM = "name";
+    public static final String FEED_PICTURE_PARAM = "picture";
+    public static final String FEED_SOURCE_PARAM = "source";
+    public static final String FEED_TO_PARAM = "to";
+    public static final String HASHTAG = "HASHTAG";
+    public static final String IMAGE_URL = "IMAGE";
+    public static final ShareConstants INSTANCE = new ShareConstants();
+    public static final String ITEM_URL = "ITEM_URL";
+    public static final String LEGACY_ACTION = "com.facebook.platform.extra.ACTION";
+    public static final String LEGACY_ACTION_TYPE = "com.facebook.platform.extra.ACTION_TYPE";
+    public static final String LEGACY_DATA_FAILURES_FATAL = "com.facebook.platform.extra.DATA_FAILURES_FATAL";
+    public static final String LEGACY_DESCRIPTION = "com.facebook.platform.extra.DESCRIPTION";
+    public static final String LEGACY_FRIEND_TAGS = "com.facebook.platform.extra.FRIENDS";
+    public static final String LEGACY_IMAGE = "com.facebook.platform.extra.IMAGE";
+    public static final String LEGACY_LINK = "com.facebook.platform.extra.LINK";
+    public static final String LEGACY_PHOTOS = "com.facebook.platform.extra.PHOTOS";
+    public static final String LEGACY_PLACE_TAG = "com.facebook.platform.extra.PLACE";
+    public static final String LEGACY_PREVIEW_PROPERTY_NAME = "com.facebook.platform.extra.PREVIEW_PROPERTY_NAME";
+    public static final String LEGACY_REF = "com.facebook.platform.extra.REF";
+    public static final String LEGACY_TITLE = "com.facebook.platform.extra.TITLE";
+    public static final int MAXIMUM_MEDIA_COUNT = 6;
+    public static final int MAXIMUM_PHOTO_COUNT = 6;
+    public static final String MEDIA = "MEDIA";
+    public static final String MEDIA_EXTENSION = "extension";
+    public static final String MEDIA_TYPE = "type";
+    public static final String MEDIA_URI = "uri";
+    public static final String MESSENGER_PLATFORM_CONTENT = "MESSENGER_PLATFORM_CONTENT";
+    public static final String MESSENGER_URL = "MESSENGER_LINK";
+    public static final String MY_VIDEOS = "me/videos";
+    public static final String OBJECT_ID = "object_id";
+    public static final String OBJECT_TYPE = "object_type";
+    public static final String OPEN_GRAPH_URL = "OPEN_GRAPH_URL";
+    public static final String PAGE_ID = "PAGE";
+    public static final String PEOPLE_IDS = "FRIENDS";
+    public static final String PHOTOS = "PHOTOS";
+    public static final String PLACE_ID = "PLACE";
+    public static final String PREVIEW_IMAGE_URL = "preview_image_url";
+    public static final String PREVIEW_PROPERTY_NAME = "PREVIEW_PROPERTY_NAME";
+    public static final String PREVIEW_TYPE = "PREVIEW_TYPE";
+    public static final String PROMO_CODE = "promo_code";
+    public static final String PROMO_TEXT = "promo_text";
+    public static final String QUOTE = "QUOTE";
+    public static final String REF = "REF";
+    public static final String RESULT_POST_ID = "postId";
+    public static final String STORY_BG_ASSET = "bg_asset";
+    public static final String STORY_DEEP_LINK_URL = "content_url";
+    public static final String STORY_INTERACTIVE_ASSET_URI = "interactive_asset_uri";
+    public static final String STORY_INTERACTIVE_COLOR_LIST = "top_background_color_list";
+    public static final String SUBTITLE = "SUBTITLE";
+    public static final String TARGET_DISPLAY = "TARGET_DISPLAY";
+    public static final String TITLE = "TITLE";
+    public static final String VIDEO_URL = "VIDEO";
+    public static final String WEB_DIALOG_PARAM_ACTION_PROPERTIES = "action_properties";
+    public static final String WEB_DIALOG_PARAM_ACTION_TYPE = "action_type";
+    public static final String WEB_DIALOG_PARAM_DATA = "data";
+    public static final String WEB_DIALOG_PARAM_DESCRIPTION = "description";
+    public static final String WEB_DIALOG_PARAM_FILTERS = "filters";
+    public static final String WEB_DIALOG_PARAM_HASHTAG = "hashtag";
+    public static final String WEB_DIALOG_PARAM_HREF = "href";
+    public static final String WEB_DIALOG_PARAM_ID = "id";
+    public static final String WEB_DIALOG_PARAM_LINK = "link";
+    public static final String WEB_DIALOG_PARAM_MEDIA = "media";
+    public static final String WEB_DIALOG_PARAM_MESSAGE = "message";
+    public static final String WEB_DIALOG_PARAM_NAME = "name";
+    public static final String WEB_DIALOG_PARAM_OBJECT_ID = "object_id";
+    public static final String WEB_DIALOG_PARAM_PICTURE = "picture";
+    public static final String WEB_DIALOG_PARAM_PRIVACY = "privacy";
+    public static final String WEB_DIALOG_PARAM_QUOTE = "quote";
+    public static final String WEB_DIALOG_PARAM_SUGGESTIONS = "suggestions";
+    public static final String WEB_DIALOG_PARAM_TITLE = "title";
+    public static final String WEB_DIALOG_PARAM_TO = "to";
+    public static final String WEB_DIALOG_RESULT_PARAM_POST_ID = "post_id";
+    public static final String WEB_DIALOG_RESULT_PARAM_REQUEST_ID = "request";
+    public static final String WEB_DIALOG_RESULT_PARAM_TO_ARRAY_MEMBER = "to[%d]";
+
+    private ShareConstants() {
+    }
+}

decompiled-community/sources/com/facebook/share/internal/ShareContentValidation.java

@@ -0,0 +1,355 @@
+package com.facebook.share.internal;
+
+import android.graphics.Bitmap;
+import android.net.Uri;
+import com.facebook.FacebookException;
+import com.facebook.FacebookSdk;
+import com.facebook.internal.Utility;
+import com.facebook.internal.Validate;
+import com.facebook.share.model.ShareCameraEffectContent;
+import com.facebook.share.model.ShareContent;
+import com.facebook.share.model.ShareLinkContent;
+import com.facebook.share.model.ShareMedia;
+import com.facebook.share.model.ShareMediaContent;
+import com.facebook.share.model.ShareMessengerActionButton;
+import com.facebook.share.model.ShareMessengerURLActionButton;
+import com.facebook.share.model.SharePhoto;
+import com.facebook.share.model.SharePhotoContent;
+import com.facebook.share.model.ShareStoryContent;
+import com.facebook.share.model.ShareVideo;
+import com.facebook.share.model.ShareVideoContent;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.StringCompanionObject;
+
+/* loaded from: classes2.dex */
+public final class ShareContentValidation {
+    public static final ShareContentValidation INSTANCE = new ShareContentValidation();
+    private static final Validator webShareValidator = new WebShareValidator();
+    private static final Validator defaultValidator = new Validator();
+    private static final Validator apiValidator = new ApiValidator();
+    private static final Validator storyValidator = new StoryShareValidator();
+
+    private ShareContentValidation() {
+    }
+
+    public static final void validateForMessage(ShareContent<?, ?> shareContent) {
+        INSTANCE.validate(shareContent, defaultValidator);
+    }
+
+    public static final void validateForNativeShare(ShareContent<?, ?> shareContent) {
+        INSTANCE.validate(shareContent, defaultValidator);
+    }
+
+    public static final void validateForWebShare(ShareContent<?, ?> shareContent) {
+        INSTANCE.validate(shareContent, webShareValidator);
+    }
+
+    public static final void validateForApiShare(ShareContent<?, ?> shareContent) {
+        INSTANCE.validate(shareContent, apiValidator);
+    }
+
+    public static final void validateForStoryShare(ShareContent<?, ?> shareContent) {
+        INSTANCE.validate(shareContent, storyValidator);
+    }
+
+    private final void validate(ShareContent<?, ?> shareContent, Validator validator) throws FacebookException {
+        if (shareContent == null) {
+            throw new FacebookException("Must provide non-null content to share");
+        }
+        if (shareContent instanceof ShareLinkContent) {
+            validator.validate((ShareLinkContent) shareContent);
+            return;
+        }
+        if (shareContent instanceof SharePhotoContent) {
+            validator.validate((SharePhotoContent) shareContent);
+            return;
+        }
+        if (shareContent instanceof ShareVideoContent) {
+            validator.validate((ShareVideoContent) shareContent);
+            return;
+        }
+        if (shareContent instanceof ShareMediaContent) {
+            validator.validate((ShareMediaContent) shareContent);
+        } else if (shareContent instanceof ShareCameraEffectContent) {
+            validator.validate((ShareCameraEffectContent) shareContent);
+        } else if (shareContent instanceof ShareStoryContent) {
+            validator.validate((ShareStoryContent) shareContent);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final void validateStoryContent(ShareStoryContent shareStoryContent, Validator validator) {
+        if (shareStoryContent == null || (shareStoryContent.getBackgroundAsset() == null && shareStoryContent.getStickerAsset() == null)) {
+            throw new FacebookException("Must pass the Facebook app a background asset, a sticker asset, or both");
+        }
+        if (shareStoryContent.getBackgroundAsset() != null) {
+            validator.validate(shareStoryContent.getBackgroundAsset());
+        }
+        if (shareStoryContent.getStickerAsset() != null) {
+            validator.validate(shareStoryContent.getStickerAsset());
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final void validateLinkContent(ShareLinkContent shareLinkContent, Validator validator) {
+        Uri contentUrl = shareLinkContent.getContentUrl();
+        if (contentUrl != null && !Utility.isWebUri(contentUrl)) {
+            throw new FacebookException("Content Url must be an http:// or https:// url");
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final void validatePhotoContent(SharePhotoContent sharePhotoContent, Validator validator) {
+        List<SharePhoto> photos = sharePhotoContent.getPhotos();
+        if (photos == null || photos.isEmpty()) {
+            throw new FacebookException("Must specify at least one Photo in SharePhotoContent.");
+        }
+        if (photos.size() > 6) {
+            StringCompanionObject stringCompanionObject = StringCompanionObject.INSTANCE;
+            String format = String.format(Locale.ROOT, "Cannot add more than %d photos.", Arrays.copyOf(new Object[]{6}, 1));
+            Intrinsics.checkNotNullExpressionValue(format, "java.lang.String.format(locale, format, *args)");
+            throw new FacebookException(format);
+        }
+        Iterator<SharePhoto> it = photos.iterator();
+        while (it.hasNext()) {
+            validator.validate(it.next());
+        }
+    }
+
+    private final void validatePhoto(SharePhoto sharePhoto) {
+        if (sharePhoto == null) {
+            throw new FacebookException("Cannot share a null SharePhoto");
+        }
+        Bitmap bitmap = sharePhoto.getBitmap();
+        Uri imageUrl = sharePhoto.getImageUrl();
+        if (bitmap == null && imageUrl == null) {
+            throw new FacebookException("SharePhoto does not have a Bitmap or ImageUrl specified");
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final void validatePhotoForApi(SharePhoto sharePhoto, Validator validator) {
+        validatePhoto(sharePhoto);
+        Bitmap bitmap = sharePhoto.getBitmap();
+        Uri imageUrl = sharePhoto.getImageUrl();
+        if (bitmap == null && Utility.isWebUri(imageUrl)) {
+            throw new FacebookException("Cannot set the ImageUrl of a SharePhoto to the Uri of an image on the web when sharing SharePhotoContent");
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final void validatePhotoForNativeDialog(SharePhoto sharePhoto, Validator validator) {
+        validatePhotoForApi(sharePhoto, validator);
+        if (sharePhoto.getBitmap() == null) {
+            Utility utility = Utility.INSTANCE;
+            if (Utility.isWebUri(sharePhoto.getImageUrl())) {
+                return;
+            }
+        }
+        Validate validate = Validate.INSTANCE;
+        Validate.hasContentProvider(FacebookSdk.getApplicationContext());
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final void validatePhotoForWebDialog(SharePhoto sharePhoto, Validator validator) {
+        validatePhoto(sharePhoto);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final void validateVideoContent(ShareVideoContent shareVideoContent, Validator validator) {
+        validator.validate(shareVideoContent.getVideo());
+        SharePhoto previewPhoto = shareVideoContent.getPreviewPhoto();
+        if (previewPhoto != null) {
+            validator.validate(previewPhoto);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final void validateVideo(ShareVideo shareVideo, Validator validator) {
+        if (shareVideo == null) {
+            throw new FacebookException("Cannot share a null ShareVideo");
+        }
+        Uri localUrl = shareVideo.getLocalUrl();
+        if (localUrl == null) {
+            throw new FacebookException("ShareVideo does not have a LocalUrl specified");
+        }
+        if (!Utility.isContentUri(localUrl) && !Utility.isFileUri(localUrl)) {
+            throw new FacebookException("ShareVideo must reference a video that is on the device");
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final void validateMediaContent(ShareMediaContent shareMediaContent, Validator validator) {
+        List<ShareMedia<?, ?>> media = shareMediaContent.getMedia();
+        if (media == null || media.isEmpty()) {
+            throw new FacebookException("Must specify at least one medium in ShareMediaContent.");
+        }
+        if (media.size() > 6) {
+            StringCompanionObject stringCompanionObject = StringCompanionObject.INSTANCE;
+            String format = String.format(Locale.ROOT, "Cannot add more than %d media.", Arrays.copyOf(new Object[]{6}, 1));
+            Intrinsics.checkNotNullExpressionValue(format, "java.lang.String.format(locale, format, *args)");
+            throw new FacebookException(format);
+        }
+        Iterator<ShareMedia<?, ?>> it = media.iterator();
+        while (it.hasNext()) {
+            validator.validate(it.next());
+        }
+    }
+
+    public static final void validateMedium(ShareMedia<?, ?> medium, Validator validator) {
+        Intrinsics.checkNotNullParameter(medium, "medium");
+        Intrinsics.checkNotNullParameter(validator, "validator");
+        if (medium instanceof SharePhoto) {
+            validator.validate((SharePhoto) medium);
+        } else {
+            if (medium instanceof ShareVideo) {
+                validator.validate((ShareVideo) medium);
+                return;
+            }
+            StringCompanionObject stringCompanionObject = StringCompanionObject.INSTANCE;
+            String format = String.format(Locale.ROOT, "Invalid media type: %s", Arrays.copyOf(new Object[]{medium.getClass().getSimpleName()}, 1));
+            Intrinsics.checkNotNullExpressionValue(format, "java.lang.String.format(locale, format, *args)");
+            throw new FacebookException(format);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final void validateCameraEffectContent(ShareCameraEffectContent shareCameraEffectContent) {
+        if (Utility.isNullOrEmpty(shareCameraEffectContent.getEffectId())) {
+            throw new FacebookException("Must specify a non-empty effectId");
+        }
+    }
+
+    private final void validateShareMessengerActionButton(ShareMessengerActionButton shareMessengerActionButton) {
+        if (shareMessengerActionButton == null) {
+            return;
+        }
+        Utility utility = Utility.INSTANCE;
+        if (Utility.isNullOrEmpty(shareMessengerActionButton.getTitle())) {
+            throw new FacebookException("Must specify title for ShareMessengerActionButton");
+        }
+        if (shareMessengerActionButton instanceof ShareMessengerURLActionButton) {
+            validateShareMessengerURLActionButton((ShareMessengerURLActionButton) shareMessengerActionButton);
+        }
+    }
+
+    private final void validateShareMessengerURLActionButton(ShareMessengerURLActionButton shareMessengerURLActionButton) {
+        if (shareMessengerURLActionButton.getUrl() == null) {
+            throw new FacebookException("Must specify url for ShareMessengerURLActionButton");
+        }
+    }
+
+    public static final class StoryShareValidator extends Validator {
+        @Override // com.facebook.share.internal.ShareContentValidation.Validator
+        public void validate(ShareStoryContent shareStoryContent) {
+            ShareContentValidation.INSTANCE.validateStoryContent(shareStoryContent, this);
+        }
+    }
+
+    public static final class WebShareValidator extends Validator {
+        @Override // com.facebook.share.internal.ShareContentValidation.Validator
+        public void validate(ShareVideoContent videoContent) {
+            Intrinsics.checkNotNullParameter(videoContent, "videoContent");
+            throw new FacebookException("Cannot share ShareVideoContent via web sharing dialogs");
+        }
+
+        @Override // com.facebook.share.internal.ShareContentValidation.Validator
+        public void validate(ShareMediaContent mediaContent) {
+            Intrinsics.checkNotNullParameter(mediaContent, "mediaContent");
+            throw new FacebookException("Cannot share ShareMediaContent via web sharing dialogs");
+        }
+
+        @Override // com.facebook.share.internal.ShareContentValidation.Validator
+        public void validate(SharePhoto photo) {
+            Intrinsics.checkNotNullParameter(photo, "photo");
+            ShareContentValidation.INSTANCE.validatePhotoForWebDialog(photo, this);
+        }
+    }
+
+    public static final class ApiValidator extends Validator {
+        @Override // com.facebook.share.internal.ShareContentValidation.Validator
+        public void validate(SharePhoto photo) {
+            Intrinsics.checkNotNullParameter(photo, "photo");
+            ShareContentValidation.INSTANCE.validatePhotoForApi(photo, this);
+        }
+
+        @Override // com.facebook.share.internal.ShareContentValidation.Validator
+        public void validate(ShareVideoContent videoContent) {
+            Intrinsics.checkNotNullParameter(videoContent, "videoContent");
+            Utility utility = Utility.INSTANCE;
+            if (!Utility.isNullOrEmpty(videoContent.getPlaceId())) {
+                throw new FacebookException("Cannot share video content with place IDs using the share api");
+            }
+            if (!Utility.isNullOrEmpty(videoContent.getPeopleIds())) {
+                throw new FacebookException("Cannot share video content with people IDs using the share api");
+            }
+            if (!Utility.isNullOrEmpty(videoContent.getRef())) {
+                throw new FacebookException("Cannot share video content with referrer URL using the share api");
+            }
+        }
+
+        @Override // com.facebook.share.internal.ShareContentValidation.Validator
+        public void validate(ShareMediaContent mediaContent) {
+            Intrinsics.checkNotNullParameter(mediaContent, "mediaContent");
+            throw new FacebookException("Cannot share ShareMediaContent using the share api");
+        }
+
+        @Override // com.facebook.share.internal.ShareContentValidation.Validator
+        public void validate(ShareLinkContent linkContent) {
+            Intrinsics.checkNotNullParameter(linkContent, "linkContent");
+            Utility utility = Utility.INSTANCE;
+            if (!Utility.isNullOrEmpty(linkContent.getQuote())) {
+                throw new FacebookException("Cannot share link content with quote using the share api");
+            }
+        }
+    }
+
+    public static class Validator {
+        public void validate(ShareLinkContent linkContent) {
+            Intrinsics.checkNotNullParameter(linkContent, "linkContent");
+            ShareContentValidation.INSTANCE.validateLinkContent(linkContent, this);
+        }
+
+        public void validate(SharePhotoContent photoContent) {
+            Intrinsics.checkNotNullParameter(photoContent, "photoContent");
+            ShareContentValidation.INSTANCE.validatePhotoContent(photoContent, this);
+        }
+
+        public void validate(ShareVideoContent videoContent) {
+            Intrinsics.checkNotNullParameter(videoContent, "videoContent");
+            ShareContentValidation.INSTANCE.validateVideoContent(videoContent, this);
+        }
+
+        public void validate(ShareMediaContent mediaContent) {
+            Intrinsics.checkNotNullParameter(mediaContent, "mediaContent");
+            ShareContentValidation.INSTANCE.validateMediaContent(mediaContent, this);
+        }
+
+        public void validate(ShareCameraEffectContent cameraEffectContent) {
+            Intrinsics.checkNotNullParameter(cameraEffectContent, "cameraEffectContent");
+            ShareContentValidation.INSTANCE.validateCameraEffectContent(cameraEffectContent);
+        }
+
+        public void validate(SharePhoto photo) {
+            Intrinsics.checkNotNullParameter(photo, "photo");
+            ShareContentValidation.INSTANCE.validatePhotoForNativeDialog(photo, this);
+        }
+
+        public void validate(ShareVideo shareVideo) {
+            ShareContentValidation.INSTANCE.validateVideo(shareVideo, this);
+        }
+
+        public void validate(ShareMedia<?, ?> medium) {
+            Intrinsics.checkNotNullParameter(medium, "medium");
+            ShareContentValidation.validateMedium(medium, this);
+        }
+
+        public void validate(ShareStoryContent shareStoryContent) {
+            ShareContentValidation.INSTANCE.validateStoryContent(shareStoryContent, this);
+        }
+    }
+}

decompiled-community/sources/com/facebook/share/internal/ShareDialogFeature.java

@@ -0,0 +1,37 @@
+package com.facebook.share.internal;
+
+import com.facebook.internal.DialogFeature;
+import com.facebook.internal.NativeProtocol;
+import java.util.Arrays;
+
+/* loaded from: classes2.dex */
+public enum ShareDialogFeature implements DialogFeature {
+    SHARE_DIALOG(NativeProtocol.PROTOCOL_VERSION_20130618),
+    PHOTOS(NativeProtocol.PROTOCOL_VERSION_20140204),
+    VIDEO(NativeProtocol.PROTOCOL_VERSION_20141028),
+    MULTIMEDIA(NativeProtocol.PROTOCOL_VERSION_20160327),
+    HASHTAG(NativeProtocol.PROTOCOL_VERSION_20160327),
+    LINK_SHARE_QUOTES(NativeProtocol.PROTOCOL_VERSION_20160327);
+
+    private final int minVersion;
+
+    @Override // com.facebook.internal.DialogFeature
+    public String getAction() {
+        return NativeProtocol.ACTION_FEED_DIALOG;
+    }
+
+    @Override // com.facebook.internal.DialogFeature
+    public int getMinVersion() {
+        return this.minVersion;
+    }
+
+    ShareDialogFeature(int i) {
+        this.minVersion = i;
+    }
+
+    /* renamed from: values, reason: to resolve conflict with enum method */
+    public static ShareDialogFeature[] valuesCustom() {
+        ShareDialogFeature[] valuesCustom = values();
+        return (ShareDialogFeature[]) Arrays.copyOf(valuesCustom, valuesCustom.length);
+    }
+}

decompiled-community/sources/com/facebook/share/internal/ShareFeedContent.java

@@ -0,0 +1,227 @@
+package com.facebook.share.internal;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.facebook.share.model.ShareContent;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes2.dex */
+public final class ShareFeedContent extends ShareContent<ShareFeedContent, Builder> {
+    private final String link;
+    private final String linkCaption;
+    private final String linkDescription;
+    private final String linkName;
+    private final String mediaSource;
+    private final String picture;
+    private final String toId;
+    public static final Companion Companion = new Companion(null);
+    public static final Parcelable.Creator<ShareFeedContent> CREATOR = new Parcelable.Creator<ShareFeedContent>() { // from class: com.facebook.share.internal.ShareFeedContent$Companion$CREATOR$1
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public ShareFeedContent createFromParcel(Parcel parcel) {
+            Intrinsics.checkNotNullParameter(parcel, "parcel");
+            return new ShareFeedContent(parcel);
+        }
+
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public ShareFeedContent[] newArray(int i) {
+            return new ShareFeedContent[i];
+        }
+    };
+
+    public /* synthetic */ ShareFeedContent(Builder builder, DefaultConstructorMarker defaultConstructorMarker) {
+        this(builder);
+    }
+
+    @Override // com.facebook.share.model.ShareContent, android.os.Parcelable
+    public int describeContents() {
+        return 0;
+    }
+
+    public final String getLink() {
+        return this.link;
+    }
+
+    public final String getLinkCaption() {
+        return this.linkCaption;
+    }
+
+    public final String getLinkDescription() {
+        return this.linkDescription;
+    }
+
+    public final String getLinkName() {
+        return this.linkName;
+    }
+
+    public final String getMediaSource() {
+        return this.mediaSource;
+    }
+
+    public final String getPicture() {
+        return this.picture;
+    }
+
+    public final String getToId() {
+        return this.toId;
+    }
+
+    private ShareFeedContent(Builder builder) {
+        super(builder);
+        this.toId = builder.getToId$facebook_common_release();
+        this.link = builder.getLink$facebook_common_release();
+        this.linkName = builder.getLinkName$facebook_common_release();
+        this.linkCaption = builder.getLinkCaption$facebook_common_release();
+        this.linkDescription = builder.getLinkDescription$facebook_common_release();
+        this.picture = builder.getPicture$facebook_common_release();
+        this.mediaSource = builder.getMediaSource$facebook_common_release();
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public ShareFeedContent(Parcel parcel) {
+        super(parcel);
+        Intrinsics.checkNotNullParameter(parcel, "parcel");
+        this.toId = parcel.readString();
+        this.link = parcel.readString();
+        this.linkName = parcel.readString();
+        this.linkCaption = parcel.readString();
+        this.linkDescription = parcel.readString();
+        this.picture = parcel.readString();
+        this.mediaSource = parcel.readString();
+    }
+
+    @Override // com.facebook.share.model.ShareContent, android.os.Parcelable
+    public void writeToParcel(Parcel out, int i) {
+        Intrinsics.checkNotNullParameter(out, "out");
+        super.writeToParcel(out, i);
+        out.writeString(this.toId);
+        out.writeString(this.link);
+        out.writeString(this.linkName);
+        out.writeString(this.linkCaption);
+        out.writeString(this.linkDescription);
+        out.writeString(this.picture);
+        out.writeString(this.mediaSource);
+    }
+
+    public static final class Builder extends ShareContent.Builder<ShareFeedContent, Builder> {
+        private String link;
+        private String linkCaption;
+        private String linkDescription;
+        private String linkName;
+        private String mediaSource;
+        private String picture;
+        private String toId;
+
+        public final String getLink$facebook_common_release() {
+            return this.link;
+        }
+
+        public final String getLinkCaption$facebook_common_release() {
+            return this.linkCaption;
+        }
+
+        public final String getLinkDescription$facebook_common_release() {
+            return this.linkDescription;
+        }
+
+        public final String getLinkName$facebook_common_release() {
+            return this.linkName;
+        }
+
+        public final String getMediaSource$facebook_common_release() {
+            return this.mediaSource;
+        }
+
+        public final String getPicture$facebook_common_release() {
+            return this.picture;
+        }
+
+        public final String getToId$facebook_common_release() {
+            return this.toId;
+        }
+
+        public final Builder setLink(String str) {
+            this.link = str;
+            return this;
+        }
+
+        public final void setLink$facebook_common_release(String str) {
+            this.link = str;
+        }
+
+        public final Builder setLinkCaption(String str) {
+            this.linkCaption = str;
+            return this;
+        }
+
+        public final void setLinkCaption$facebook_common_release(String str) {
+            this.linkCaption = str;
+        }
+
+        public final Builder setLinkDescription(String str) {
+            this.linkDescription = str;
+            return this;
+        }
+
+        public final void setLinkDescription$facebook_common_release(String str) {
+            this.linkDescription = str;
+        }
+
+        public final Builder setLinkName(String str) {
+            this.linkName = str;
+            return this;
+        }
+
+        public final void setLinkName$facebook_common_release(String str) {
+            this.linkName = str;
+        }
+
+        public final Builder setMediaSource(String str) {
+            this.mediaSource = str;
+            return this;
+        }
+
+        public final void setMediaSource$facebook_common_release(String str) {
+            this.mediaSource = str;
+        }
+
+        public final Builder setPicture(String str) {
+            this.picture = str;
+            return this;
+        }
+
+        public final void setPicture$facebook_common_release(String str) {
+            this.picture = str;
+        }
+
+        public final Builder setToId(String str) {
+            this.toId = str;
+            return this;
+        }
+
+        public final void setToId$facebook_common_release(String str) {
+            this.toId = str;
+        }
+
+        @Override // com.facebook.share.ShareBuilder
+        public ShareFeedContent build() {
+            return new ShareFeedContent(this, null);
+        }
+
+        @Override // com.facebook.share.model.ShareContent.Builder, com.facebook.share.model.ShareModelBuilder
+        public Builder readFrom(ShareFeedContent shareFeedContent) {
+            return shareFeedContent == null ? this : ((Builder) super.readFrom((Builder) shareFeedContent)).setToId(shareFeedContent.getToId()).setLink(shareFeedContent.getLink()).setLinkName(shareFeedContent.getLinkName()).setLinkCaption(shareFeedContent.getLinkCaption()).setLinkDescription(shareFeedContent.getLinkDescription()).setPicture(shareFeedContent.getPicture()).setMediaSource(shareFeedContent.getMediaSource());
+        }
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+    }
+}

decompiled-community/sources/com/facebook/share/internal/ShareInternalUtility.java

@@ -0,0 +1,568 @@
+package com.facebook.share.internal;
+
+import android.content.Intent;
+import android.graphics.Bitmap;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.ParcelFileDescriptor;
+import android.util.Pair;
+import com.facebook.AccessToken;
+import com.facebook.CallbackManager;
+import com.facebook.FacebookCallback;
+import com.facebook.FacebookException;
+import com.facebook.FacebookGraphResponseException;
+import com.facebook.FacebookOperationCanceledException;
+import com.facebook.FacebookRequestError;
+import com.facebook.FacebookSdk;
+import com.facebook.GraphRequest;
+import com.facebook.GraphResponse;
+import com.facebook.HttpMethod;
+import com.facebook.appevents.InternalAppEventsLogger;
+import com.facebook.devicerequests.internal.DeviceRequestsHelper;
+import com.facebook.internal.AnalyticsEvents;
+import com.facebook.internal.AppCall;
+import com.facebook.internal.CallbackManagerImpl;
+import com.facebook.internal.NativeAppCallAttachmentStore;
+import com.facebook.internal.NativeProtocol;
+import com.facebook.internal.Utility;
+import com.facebook.share.Sharer;
+import com.facebook.share.model.CameraEffectTextures;
+import com.facebook.share.model.ShareCameraEffectContent;
+import com.facebook.share.model.ShareMedia;
+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.ShareVideo;
+import com.facebook.share.model.ShareVideoContent;
+import com.google.android.gms.drive.DriveFile;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.UUID;
+import kotlin.collections.CollectionsKt__CollectionsJVMKt;
+import kotlin.collections.CollectionsKt__IterablesKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.StringsKt__StringsJVMKt;
+import kotlin.text.StringsKt__StringsKt;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes2.dex */
+public final class ShareInternalUtility {
+    public static final ShareInternalUtility INSTANCE = new ShareInternalUtility();
+    public static final String MY_STAGING_RESOURCES = "me/staging_resources";
+    public static final String STAGING_PARAM = "file";
+
+    private ShareInternalUtility() {
+    }
+
+    public static final void invokeCallbackWithException(FacebookCallback<Sharer.Result> facebookCallback, Exception exception) {
+        Intrinsics.checkNotNullParameter(exception, "exception");
+        if (exception instanceof FacebookException) {
+            invokeOnErrorCallback(facebookCallback, (FacebookException) exception);
+        } else {
+            invokeCallbackWithError(facebookCallback, Intrinsics.stringPlus("Error preparing share content: ", exception.getLocalizedMessage()));
+        }
+    }
+
+    public static final void invokeCallbackWithError(FacebookCallback<Sharer.Result> facebookCallback, String str) {
+        invokeOnErrorCallback(facebookCallback, str);
+    }
+
+    public static final void invokeCallbackWithResults(FacebookCallback<Sharer.Result> facebookCallback, String str, GraphResponse graphResponse) {
+        Intrinsics.checkNotNullParameter(graphResponse, "graphResponse");
+        FacebookRequestError error = graphResponse.getError();
+        if (error != null) {
+            String errorMessage = error.getErrorMessage();
+            if (Utility.isNullOrEmpty(errorMessage)) {
+                errorMessage = "Unexpected error sharing.";
+            }
+            invokeOnErrorCallback(facebookCallback, graphResponse, errorMessage);
+            return;
+        }
+        invokeOnSuccessCallback(facebookCallback, str);
+    }
+
+    public static final String getNativeDialogCompletionGesture(Bundle result) {
+        Intrinsics.checkNotNullParameter(result, "result");
+        if (result.containsKey(NativeProtocol.RESULT_ARGS_DIALOG_COMPLETION_GESTURE_KEY)) {
+            return result.getString(NativeProtocol.RESULT_ARGS_DIALOG_COMPLETION_GESTURE_KEY);
+        }
+        return result.getString(NativeProtocol.EXTRA_DIALOG_COMPLETION_GESTURE_KEY);
+    }
+
+    public static final String getShareDialogPostId(Bundle result) {
+        Intrinsics.checkNotNullParameter(result, "result");
+        if (result.containsKey(ShareConstants.RESULT_POST_ID)) {
+            return result.getString(ShareConstants.RESULT_POST_ID);
+        }
+        if (result.containsKey(ShareConstants.EXTRA_RESULT_POST_ID)) {
+            return result.getString(ShareConstants.EXTRA_RESULT_POST_ID);
+        }
+        return result.getString(ShareConstants.WEB_DIALOG_RESULT_PARAM_POST_ID);
+    }
+
+    public static final boolean handleActivityResult(int i, int i2, Intent intent, ResultProcessor resultProcessor) {
+        AppCall appCallFromActivityResult = INSTANCE.getAppCallFromActivityResult(i, i2, intent);
+        if (appCallFromActivityResult == null) {
+            return false;
+        }
+        NativeAppCallAttachmentStore nativeAppCallAttachmentStore = NativeAppCallAttachmentStore.INSTANCE;
+        NativeAppCallAttachmentStore.cleanupAttachmentsForCall(appCallFromActivityResult.getCallId());
+        if (resultProcessor == null) {
+            return true;
+        }
+        FacebookException exceptionFromErrorData = intent != null ? NativeProtocol.getExceptionFromErrorData(NativeProtocol.getErrorDataFromResultIntent(intent)) : null;
+        if (exceptionFromErrorData != null) {
+            if (exceptionFromErrorData instanceof FacebookOperationCanceledException) {
+                resultProcessor.onCancel(appCallFromActivityResult);
+            } else {
+                resultProcessor.onError(appCallFromActivityResult, exceptionFromErrorData);
+            }
+        } else {
+            resultProcessor.onSuccess(appCallFromActivityResult, intent != null ? NativeProtocol.getSuccessResultsFromIntent(intent) : null);
+        }
+        return true;
+    }
+
+    public static final ResultProcessor getShareResultProcessor(final FacebookCallback<Sharer.Result> facebookCallback) {
+        return new ResultProcessor(facebookCallback) { // from class: com.facebook.share.internal.ShareInternalUtility$getShareResultProcessor$1
+            final /* synthetic */ FacebookCallback<Sharer.Result> $callback;
+
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(facebookCallback);
+                this.$callback = facebookCallback;
+            }
+
+            @Override // com.facebook.share.internal.ResultProcessor
+            public void onSuccess(AppCall appCall, Bundle bundle) {
+                boolean equals;
+                boolean equals2;
+                Intrinsics.checkNotNullParameter(appCall, "appCall");
+                if (bundle != null) {
+                    String nativeDialogCompletionGesture = ShareInternalUtility.getNativeDialogCompletionGesture(bundle);
+                    if (nativeDialogCompletionGesture != null) {
+                        equals = StringsKt__StringsJVMKt.equals("post", nativeDialogCompletionGesture, true);
+                        if (!equals) {
+                            equals2 = StringsKt__StringsJVMKt.equals("cancel", nativeDialogCompletionGesture, true);
+                            if (equals2) {
+                                ShareInternalUtility.invokeOnCancelCallback(this.$callback);
+                                return;
+                            } else {
+                                ShareInternalUtility.invokeOnErrorCallback(this.$callback, new FacebookException(NativeProtocol.ERROR_UNKNOWN_ERROR));
+                                return;
+                            }
+                        }
+                    }
+                    ShareInternalUtility.invokeOnSuccessCallback(this.$callback, ShareInternalUtility.getShareDialogPostId(bundle));
+                }
+            }
+
+            @Override // com.facebook.share.internal.ResultProcessor
+            public void onCancel(AppCall appCall) {
+                Intrinsics.checkNotNullParameter(appCall, "appCall");
+                ShareInternalUtility shareInternalUtility = ShareInternalUtility.INSTANCE;
+                ShareInternalUtility.invokeOnCancelCallback(this.$callback);
+            }
+
+            @Override // com.facebook.share.internal.ResultProcessor
+            public void onError(AppCall appCall, FacebookException error) {
+                Intrinsics.checkNotNullParameter(appCall, "appCall");
+                Intrinsics.checkNotNullParameter(error, "error");
+                ShareInternalUtility shareInternalUtility = ShareInternalUtility.INSTANCE;
+                ShareInternalUtility.invokeOnErrorCallback(this.$callback, error);
+            }
+        };
+    }
+
+    private final AppCall getAppCallFromActivityResult(int i, int i2, Intent intent) {
+        UUID callIdFromIntent = NativeProtocol.getCallIdFromIntent(intent);
+        if (callIdFromIntent == null) {
+            return null;
+        }
+        return AppCall.Companion.finishPendingCall(callIdFromIntent, i);
+    }
+
+    public static final void registerStaticShareCallback(final int i) {
+        CallbackManagerImpl.Companion.registerStaticCallback(i, new CallbackManagerImpl.Callback() { // from class: com.facebook.share.internal.ShareInternalUtility$$ExternalSyntheticLambda0
+            @Override // com.facebook.internal.CallbackManagerImpl.Callback
+            public final boolean onActivityResult(int i2, Intent intent) {
+                boolean m644registerStaticShareCallback$lambda0;
+                m644registerStaticShareCallback$lambda0 = ShareInternalUtility.m644registerStaticShareCallback$lambda0(i, i2, intent);
+                return m644registerStaticShareCallback$lambda0;
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* renamed from: registerStaticShareCallback$lambda-0, reason: not valid java name */
+    public static final boolean m644registerStaticShareCallback$lambda0(int i, int i2, Intent intent) {
+        return handleActivityResult(i, i2, intent, getShareResultProcessor(null));
+    }
+
+    public static final void registerSharerCallback(final int i, CallbackManager callbackManager, final FacebookCallback<Sharer.Result> facebookCallback) {
+        if (!(callbackManager instanceof CallbackManagerImpl)) {
+            throw new FacebookException("Unexpected CallbackManager, please use the provided Factory.");
+        }
+        ((CallbackManagerImpl) callbackManager).registerCallback(i, new CallbackManagerImpl.Callback() { // from class: com.facebook.share.internal.ShareInternalUtility$$ExternalSyntheticLambda1
+            @Override // com.facebook.internal.CallbackManagerImpl.Callback
+            public final boolean onActivityResult(int i2, Intent intent) {
+                boolean m643registerSharerCallback$lambda1;
+                m643registerSharerCallback$lambda1 = ShareInternalUtility.m643registerSharerCallback$lambda1(i, facebookCallback, i2, intent);
+                return m643registerSharerCallback$lambda1;
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* renamed from: registerSharerCallback$lambda-1, reason: not valid java name */
+    public static final boolean m643registerSharerCallback$lambda1(int i, FacebookCallback facebookCallback, int i2, Intent intent) {
+        return handleActivityResult(i, i2, intent, getShareResultProcessor(facebookCallback));
+    }
+
+    public static final List<String> getPhotoUrls(SharePhotoContent sharePhotoContent, UUID appCallId) {
+        Intrinsics.checkNotNullParameter(appCallId, "appCallId");
+        List<SharePhoto> photos = sharePhotoContent == null ? null : sharePhotoContent.getPhotos();
+        if (photos == null) {
+            return null;
+        }
+        ArrayList arrayList = new ArrayList();
+        Iterator<T> it = photos.iterator();
+        while (it.hasNext()) {
+            NativeAppCallAttachmentStore.Attachment attachment = INSTANCE.getAttachment(appCallId, (SharePhoto) it.next());
+            if (attachment != null) {
+                arrayList.add(attachment);
+            }
+        }
+        ArrayList arrayList2 = new ArrayList(CollectionsKt__IterablesKt.collectionSizeOrDefault(arrayList, 10));
+        Iterator it2 = arrayList.iterator();
+        while (it2.hasNext()) {
+            arrayList2.add(((NativeAppCallAttachmentStore.Attachment) it2.next()).getAttachmentUrl());
+        }
+        NativeAppCallAttachmentStore.addAttachments(arrayList);
+        return arrayList2;
+    }
+
+    public static final String getVideoUrl(ShareVideoContent shareVideoContent, UUID appCallId) {
+        ShareVideo video;
+        Intrinsics.checkNotNullParameter(appCallId, "appCallId");
+        Uri localUrl = (shareVideoContent == null || (video = shareVideoContent.getVideo()) == null) ? null : video.getLocalUrl();
+        if (localUrl == null) {
+            return null;
+        }
+        NativeAppCallAttachmentStore.Attachment createAttachment = NativeAppCallAttachmentStore.createAttachment(appCallId, localUrl);
+        NativeAppCallAttachmentStore.addAttachments(CollectionsKt__CollectionsJVMKt.listOf(createAttachment));
+        return createAttachment.getAttachmentUrl();
+    }
+
+    public static final List<Bundle> getMediaInfos(ShareMediaContent shareMediaContent, UUID appCallId) {
+        Bundle bundle;
+        Intrinsics.checkNotNullParameter(appCallId, "appCallId");
+        List<ShareMedia<?, ?>> media = shareMediaContent == null ? null : shareMediaContent.getMedia();
+        if (media == null) {
+            return null;
+        }
+        ArrayList arrayList = new ArrayList();
+        ArrayList arrayList2 = new ArrayList();
+        for (ShareMedia<?, ?> shareMedia : media) {
+            NativeAppCallAttachmentStore.Attachment attachment = INSTANCE.getAttachment(appCallId, shareMedia);
+            if (attachment == null) {
+                bundle = null;
+            } else {
+                arrayList.add(attachment);
+                bundle = new Bundle();
+                bundle.putString("type", shareMedia.getMediaType().name());
+                bundle.putString(ShareConstants.MEDIA_URI, attachment.getAttachmentUrl());
+            }
+            if (bundle != null) {
+                arrayList2.add(bundle);
+            }
+        }
+        NativeAppCallAttachmentStore.addAttachments(arrayList);
+        return arrayList2;
+    }
+
+    public static final Bundle getTextureUrlBundle(ShareCameraEffectContent shareCameraEffectContent, UUID appCallId) {
+        Intrinsics.checkNotNullParameter(appCallId, "appCallId");
+        CameraEffectTextures textures = shareCameraEffectContent == null ? null : shareCameraEffectContent.getTextures();
+        if (textures == null) {
+            return null;
+        }
+        Bundle bundle = new Bundle();
+        ArrayList arrayList = new ArrayList();
+        for (String str : textures.keySet()) {
+            NativeAppCallAttachmentStore.Attachment attachment = INSTANCE.getAttachment(appCallId, textures.getTextureUri(str), textures.getTextureBitmap(str));
+            if (attachment != null) {
+                arrayList.add(attachment);
+                bundle.putString(str, attachment.getAttachmentUrl());
+            }
+        }
+        NativeAppCallAttachmentStore.addAttachments(arrayList);
+        return bundle;
+    }
+
+    public static final JSONArray removeNamespacesFromOGJsonArray(JSONArray jsonArray, boolean z) throws JSONException {
+        Intrinsics.checkNotNullParameter(jsonArray, "jsonArray");
+        JSONArray jSONArray = new JSONArray();
+        int length = jsonArray.length();
+        if (length > 0) {
+            int i = 0;
+            while (true) {
+                int i2 = i + 1;
+                Object obj = jsonArray.get(i);
+                if (obj instanceof JSONArray) {
+                    obj = removeNamespacesFromOGJsonArray((JSONArray) obj, z);
+                } else if (obj instanceof JSONObject) {
+                    obj = removeNamespacesFromOGJsonObject((JSONObject) obj, z);
+                }
+                jSONArray.put(obj);
+                if (i2 >= length) {
+                    break;
+                }
+                i = i2;
+            }
+        }
+        return jSONArray;
+    }
+
+    public static final JSONObject removeNamespacesFromOGJsonObject(JSONObject jSONObject, boolean z) {
+        if (jSONObject == null) {
+            return null;
+        }
+        try {
+            JSONObject jSONObject2 = new JSONObject();
+            JSONObject jSONObject3 = new JSONObject();
+            JSONArray names = jSONObject.names();
+            if (names == null) {
+                return null;
+            }
+            int length = names.length();
+            if (length > 0) {
+                int i = 0;
+                while (true) {
+                    int i2 = i + 1;
+                    String key = names.getString(i);
+                    Object obj = jSONObject.get(key);
+                    if (obj instanceof JSONObject) {
+                        obj = removeNamespacesFromOGJsonObject((JSONObject) obj, true);
+                    } else if (obj instanceof JSONArray) {
+                        obj = removeNamespacesFromOGJsonArray((JSONArray) obj, true);
+                    }
+                    Intrinsics.checkNotNullExpressionValue(key, "key");
+                    Pair<String, String> fieldNameAndNamespaceFromFullName = getFieldNameAndNamespaceFromFullName(key);
+                    String str = (String) fieldNameAndNamespaceFromFullName.first;
+                    String str2 = (String) fieldNameAndNamespaceFromFullName.second;
+                    if (z) {
+                        if (str != null && Intrinsics.areEqual(str, DeviceRequestsHelper.SDK_HEADER)) {
+                            jSONObject2.put(key, obj);
+                        } else {
+                            if (str != null && !Intrinsics.areEqual(str, "og")) {
+                                jSONObject3.put(str2, obj);
+                            }
+                            jSONObject2.put(str2, obj);
+                        }
+                    } else if (str != null && Intrinsics.areEqual(str, "fb")) {
+                        jSONObject2.put(key, obj);
+                    } else {
+                        jSONObject2.put(str2, obj);
+                    }
+                    if (i2 >= length) {
+                        break;
+                    }
+                    i = i2;
+                }
+            }
+            if (jSONObject3.length() > 0) {
+                jSONObject2.put("data", jSONObject3);
+            }
+            return jSONObject2;
+        } catch (JSONException unused) {
+            throw new FacebookException("Failed to create json object from share content");
+        }
+    }
+
+    public static final Pair<String, String> getFieldNameAndNamespaceFromFullName(String fullName) {
+        String str;
+        int i;
+        Intrinsics.checkNotNullParameter(fullName, "fullName");
+        int indexOf$default = StringsKt__StringsKt.indexOf$default((CharSequence) fullName, ':', 0, false, 6, (Object) null);
+        if (indexOf$default == -1 || fullName.length() <= (i = indexOf$default + 1)) {
+            str = null;
+        } else {
+            str = fullName.substring(0, indexOf$default);
+            Intrinsics.checkNotNullExpressionValue(str, "(this as java.lang.Strin…ing(startIndex, endIndex)");
+            fullName = fullName.substring(i);
+            Intrinsics.checkNotNullExpressionValue(fullName, "(this as java.lang.String).substring(startIndex)");
+        }
+        return new Pair<>(str, fullName);
+    }
+
+    private final NativeAppCallAttachmentStore.Attachment getAttachment(UUID uuid, ShareMedia<?, ?> shareMedia) {
+        Uri uri;
+        Bitmap bitmap;
+        if (shareMedia instanceof SharePhoto) {
+            SharePhoto sharePhoto = (SharePhoto) shareMedia;
+            bitmap = sharePhoto.getBitmap();
+            uri = sharePhoto.getImageUrl();
+        } else if (shareMedia instanceof ShareVideo) {
+            uri = ((ShareVideo) shareMedia).getLocalUrl();
+            bitmap = null;
+        } else {
+            uri = null;
+            bitmap = null;
+        }
+        return getAttachment(uuid, uri, bitmap);
+    }
+
+    private final NativeAppCallAttachmentStore.Attachment getAttachment(UUID uuid, Uri uri, Bitmap bitmap) {
+        if (bitmap != null) {
+            return NativeAppCallAttachmentStore.createAttachment(uuid, bitmap);
+        }
+        if (uri != null) {
+            return NativeAppCallAttachmentStore.createAttachment(uuid, uri);
+        }
+        return null;
+    }
+
+    public static final void invokeOnCancelCallback(FacebookCallback<Sharer.Result> facebookCallback) {
+        INSTANCE.logShareResult(AnalyticsEvents.PARAMETER_SHARE_OUTCOME_CANCELLED, null);
+        if (facebookCallback == null) {
+            return;
+        }
+        facebookCallback.onCancel();
+    }
+
+    public static final void invokeOnSuccessCallback(FacebookCallback<Sharer.Result> facebookCallback, String str) {
+        INSTANCE.logShareResult(AnalyticsEvents.PARAMETER_SHARE_OUTCOME_SUCCEEDED, null);
+        if (facebookCallback == null) {
+            return;
+        }
+        facebookCallback.onSuccess(new Sharer.Result(str));
+    }
+
+    public static final void invokeOnErrorCallback(FacebookCallback<Sharer.Result> facebookCallback, GraphResponse graphResponse, String str) {
+        INSTANCE.logShareResult("error", str);
+        if (facebookCallback == null) {
+            return;
+        }
+        facebookCallback.onError(new FacebookGraphResponseException(graphResponse, str));
+    }
+
+    public static final void invokeOnErrorCallback(FacebookCallback<Sharer.Result> facebookCallback, String str) {
+        INSTANCE.logShareResult("error", str);
+        if (facebookCallback == null) {
+            return;
+        }
+        facebookCallback.onError(new FacebookException(str));
+    }
+
+    public static final void invokeOnErrorCallback(FacebookCallback<Sharer.Result> facebookCallback, FacebookException ex) {
+        Intrinsics.checkNotNullParameter(ex, "ex");
+        INSTANCE.logShareResult("error", ex.getMessage());
+        if (facebookCallback == null) {
+            return;
+        }
+        facebookCallback.onError(ex);
+    }
+
+    private final void logShareResult(String str, String str2) {
+        InternalAppEventsLogger internalAppEventsLogger = new InternalAppEventsLogger(FacebookSdk.getApplicationContext());
+        Bundle bundle = new Bundle();
+        bundle.putString(AnalyticsEvents.PARAMETER_SHARE_OUTCOME, str);
+        if (str2 != null) {
+            bundle.putString("error_message", str2);
+        }
+        internalAppEventsLogger.logEventImplicitly(AnalyticsEvents.EVENT_SHARE_RESULT, bundle);
+    }
+
+    public static final GraphRequest newUploadStagingResourceWithImageRequest(AccessToken accessToken, Bitmap bitmap, GraphRequest.Callback callback) {
+        Bundle bundle = new Bundle(1);
+        bundle.putParcelable("file", bitmap);
+        return new GraphRequest(accessToken, MY_STAGING_RESOURCES, bundle, HttpMethod.POST, callback, null, 32, null);
+    }
+
+    public static final GraphRequest newUploadStagingResourceWithImageRequest(AccessToken accessToken, File file, GraphRequest.Callback callback) throws FileNotFoundException {
+        GraphRequest.ParcelableResourceWithMimeType parcelableResourceWithMimeType = new GraphRequest.ParcelableResourceWithMimeType(ParcelFileDescriptor.open(file, DriveFile.MODE_READ_ONLY), "image/png");
+        Bundle bundle = new Bundle(1);
+        bundle.putParcelable("file", parcelableResourceWithMimeType);
+        return new GraphRequest(accessToken, MY_STAGING_RESOURCES, bundle, HttpMethod.POST, callback, null, 32, null);
+    }
+
+    public static final GraphRequest newUploadStagingResourceWithImageRequest(AccessToken accessToken, Uri imageUri, GraphRequest.Callback callback) throws FileNotFoundException {
+        Intrinsics.checkNotNullParameter(imageUri, "imageUri");
+        String path = imageUri.getPath();
+        if (Utility.isFileUri(imageUri) && path != null) {
+            return newUploadStagingResourceWithImageRequest(accessToken, new File(path), callback);
+        }
+        if (!Utility.isContentUri(imageUri)) {
+            throw new FacebookException("The image Uri must be either a file:// or content:// Uri");
+        }
+        GraphRequest.ParcelableResourceWithMimeType parcelableResourceWithMimeType = new GraphRequest.ParcelableResourceWithMimeType(imageUri, "image/png");
+        Bundle bundle = new Bundle(1);
+        bundle.putParcelable("file", parcelableResourceWithMimeType);
+        return new GraphRequest(accessToken, MY_STAGING_RESOURCES, bundle, HttpMethod.POST, callback, null, 32, null);
+    }
+
+    public static final Bundle getStickerUrl(ShareStoryContent shareStoryContent, UUID appCallId) {
+        Intrinsics.checkNotNullParameter(appCallId, "appCallId");
+        if (shareStoryContent == null || shareStoryContent.getStickerAsset() == null) {
+            return null;
+        }
+        new ArrayList().add(shareStoryContent.getStickerAsset());
+        NativeAppCallAttachmentStore.Attachment attachment = INSTANCE.getAttachment(appCallId, shareStoryContent.getStickerAsset());
+        if (attachment == null) {
+            return null;
+        }
+        Bundle bundle = new Bundle();
+        bundle.putString(ShareConstants.MEDIA_URI, attachment.getAttachmentUrl());
+        String uriExtension = getUriExtension(attachment.getOriginalUri());
+        if (uriExtension != null) {
+            Utility.putNonEmptyString(bundle, ShareConstants.MEDIA_EXTENSION, uriExtension);
+        }
+        NativeAppCallAttachmentStore nativeAppCallAttachmentStore = NativeAppCallAttachmentStore.INSTANCE;
+        NativeAppCallAttachmentStore.addAttachments(CollectionsKt__CollectionsJVMKt.listOf(attachment));
+        return bundle;
+    }
+
+    public static final Bundle getBackgroundAssetMediaInfo(ShareStoryContent shareStoryContent, UUID appCallId) {
+        Intrinsics.checkNotNullParameter(appCallId, "appCallId");
+        Bundle bundle = null;
+        if (shareStoryContent != null && shareStoryContent.getBackgroundAsset() != null) {
+            ShareMedia<?, ?> backgroundAsset = shareStoryContent.getBackgroundAsset();
+            NativeAppCallAttachmentStore.Attachment attachment = INSTANCE.getAttachment(appCallId, backgroundAsset);
+            if (attachment == null) {
+                return null;
+            }
+            bundle = new Bundle();
+            bundle.putString("type", backgroundAsset.getMediaType().name());
+            bundle.putString(ShareConstants.MEDIA_URI, attachment.getAttachmentUrl());
+            String uriExtension = getUriExtension(attachment.getOriginalUri());
+            if (uriExtension != null) {
+                Utility.putNonEmptyString(bundle, ShareConstants.MEDIA_EXTENSION, uriExtension);
+            }
+            NativeAppCallAttachmentStore nativeAppCallAttachmentStore = NativeAppCallAttachmentStore.INSTANCE;
+            NativeAppCallAttachmentStore.addAttachments(CollectionsKt__CollectionsJVMKt.listOf(attachment));
+        }
+        return bundle;
+    }
+
+    public static final String getUriExtension(Uri uri) {
+        if (uri == null) {
+            return null;
+        }
+        String uri2 = uri.toString();
+        Intrinsics.checkNotNullExpressionValue(uri2, "uri.toString()");
+        int lastIndexOf$default = StringsKt__StringsKt.lastIndexOf$default((CharSequence) uri2, '.', 0, false, 6, (Object) null);
+        if (lastIndexOf$default == -1) {
+            return null;
+        }
+        String substring = uri2.substring(lastIndexOf$default);
+        Intrinsics.checkNotNullExpressionValue(substring, "(this as java.lang.String).substring(startIndex)");
+        return substring;
+    }
+}

decompiled-community/sources/com/facebook/share/internal/ShareStoryFeature.java

@@ -0,0 +1,32 @@
+package com.facebook.share.internal;
+
+import com.facebook.internal.DialogFeature;
+import com.facebook.internal.NativeProtocol;
+import java.util.Arrays;
+
+/* loaded from: classes2.dex */
+public enum ShareStoryFeature implements DialogFeature {
+    SHARE_STORY_ASSET(NativeProtocol.PROTOCOL_VERSION_20170417);
+
+    private final int minVersion;
+
+    @Override // com.facebook.internal.DialogFeature
+    public String getAction() {
+        return NativeProtocol.ACTION_SHARE_STORY;
+    }
+
+    @Override // com.facebook.internal.DialogFeature
+    public int getMinVersion() {
+        return this.minVersion;
+    }
+
+    ShareStoryFeature(int i) {
+        this.minVersion = i;
+    }
+
+    /* renamed from: values, reason: to resolve conflict with enum method */
+    public static ShareStoryFeature[] valuesCustom() {
+        ShareStoryFeature[] valuesCustom = values();
+        return (ShareStoryFeature[]) Arrays.copyOf(valuesCustom, valuesCustom.length);
+    }
+}

decompiled-community/sources/com/facebook/share/internal/VideoUploader.java

@@ -0,0 +1,582 @@
+package com.facebook.share.internal;
+
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.ParcelFileDescriptor;
+import android.text.TextUtils;
+import android.util.Log;
+import com.facebook.AccessToken;
+import com.facebook.AccessTokenTracker;
+import com.facebook.FacebookCallback;
+import com.facebook.FacebookException;
+import com.facebook.FacebookGraphResponseException;
+import com.facebook.FacebookRequestError;
+import com.facebook.FacebookSdk;
+import com.facebook.GraphRequest;
+import com.facebook.GraphResponse;
+import com.facebook.HttpMethod;
+import com.facebook.gamingservices.internal.TournamentShareDialogURIBuilder;
+import com.facebook.internal.Utility;
+import com.facebook.internal.Validate;
+import com.facebook.internal.WorkQueue;
+import com.facebook.internal.instrument.crashshield.CrashShieldHandler;
+import com.facebook.share.Sharer;
+import com.facebook.share.model.ShareVideo;
+import com.facebook.share.model.ShareVideoContent;
+import com.google.android.gms.drive.DriveFile;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Locale;
+import java.util.Set;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes2.dex */
+public class VideoUploader {
+    private static final String ERROR_BAD_SERVER_RESPONSE = "Unexpected error in server response";
+    private static final String ERROR_UPLOAD = "Video upload failed";
+    private static final int MAX_RETRIES_PER_PHASE = 2;
+    private static final String PARAM_DESCRIPTION = "description";
+    private static final String PARAM_END_OFFSET = "end_offset";
+    private static final String PARAM_FILE_SIZE = "file_size";
+    private static final String PARAM_REF = "ref";
+    private static final String PARAM_SESSION_ID = "upload_session_id";
+    private static final String PARAM_START_OFFSET = "start_offset";
+    private static final String PARAM_TITLE = "title";
+    private static final String PARAM_UPLOAD_PHASE = "upload_phase";
+    private static final String PARAM_VALUE_UPLOAD_FINISH_PHASE = "finish";
+    private static final String PARAM_VALUE_UPLOAD_START_PHASE = "start";
+    private static final String PARAM_VALUE_UPLOAD_TRANSFER_PHASE = "transfer";
+    private static final String PARAM_VIDEO_FILE_CHUNK = "video_file_chunk";
+    private static final String PARAM_VIDEO_ID = "video_id";
+    private static final int RETRY_DELAY_BACK_OFF_FACTOR = 3;
+    private static final int RETRY_DELAY_UNIT_MS = 5000;
+    private static final String TAG = "VideoUploader";
+    private static final int UPLOAD_QUEUE_MAX_CONCURRENT = 8;
+    private static AccessTokenTracker accessTokenTracker;
+    private static Handler handler;
+    private static boolean initialized;
+    private static WorkQueue uploadQueue = new WorkQueue(8);
+    private static Set<UploadContext> pendingUploads = new HashSet();
+
+    public static synchronized void uploadAsyncWithProgressCallback(ShareVideoContent shareVideoContent, GraphRequest.OnProgressCallback onProgressCallback) throws FileNotFoundException {
+        synchronized (VideoUploader.class) {
+            uploadAsync(shareVideoContent, TournamentShareDialogURIBuilder.me, null, onProgressCallback);
+        }
+    }
+
+    public static synchronized void uploadAsyncWithProgressCallback(ShareVideoContent shareVideoContent, String str, GraphRequest.OnProgressCallback onProgressCallback) throws FileNotFoundException {
+        synchronized (VideoUploader.class) {
+            uploadAsync(shareVideoContent, str, null, onProgressCallback);
+        }
+    }
+
+    public static synchronized void uploadAsync(ShareVideoContent shareVideoContent, String str, FacebookCallback<Sharer.Result> facebookCallback) throws FileNotFoundException {
+        synchronized (VideoUploader.class) {
+            uploadAsync(shareVideoContent, str, facebookCallback, null);
+        }
+    }
+
+    private static synchronized void uploadAsync(ShareVideoContent shareVideoContent, String str, FacebookCallback<Sharer.Result> facebookCallback, GraphRequest.OnProgressCallback onProgressCallback) throws FileNotFoundException {
+        synchronized (VideoUploader.class) {
+            try {
+                if (!initialized) {
+                    registerAccessTokenTracker();
+                    initialized = true;
+                }
+                Validate.notNull(shareVideoContent, "videoContent");
+                Validate.notNull(str, "graphNode");
+                ShareVideo video = shareVideoContent.getVideo();
+                Validate.notNull(video, "videoContent.video");
+                Validate.notNull(video.getLocalUrl(), "videoContent.video.localUrl");
+                UploadContext uploadContext = new UploadContext(shareVideoContent, str, facebookCallback, onProgressCallback);
+                uploadContext.initialize();
+                pendingUploads.add(uploadContext);
+                enqueueUploadStart(uploadContext, 0);
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static synchronized void cancelAllRequests() {
+        synchronized (VideoUploader.class) {
+            Iterator<UploadContext> it = pendingUploads.iterator();
+            while (it.hasNext()) {
+                it.next().isCanceled = true;
+            }
+        }
+    }
+
+    private static synchronized void removePendingUpload(UploadContext uploadContext) {
+        synchronized (VideoUploader.class) {
+            pendingUploads.remove(uploadContext);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static synchronized Handler getHandler() {
+        Handler handler2;
+        synchronized (VideoUploader.class) {
+            try {
+                if (handler == null) {
+                    handler = new Handler(Looper.getMainLooper());
+                }
+                handler2 = handler;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return handler2;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static void issueResponse(UploadContext uploadContext, FacebookException facebookException, GraphResponse graphResponse, String str) {
+        removePendingUpload(uploadContext);
+        Utility.closeQuietly(uploadContext.videoStream);
+        FacebookCallback<Sharer.Result> facebookCallback = uploadContext.callback;
+        if (facebookCallback != null) {
+            if (facebookException != null) {
+                ShareInternalUtility.invokeOnErrorCallback(facebookCallback, facebookException);
+            } else if (uploadContext.isCanceled) {
+                ShareInternalUtility.invokeOnCancelCallback(facebookCallback);
+            } else {
+                ShareInternalUtility.invokeOnSuccessCallback(facebookCallback, str);
+            }
+        }
+        if (uploadContext.progressCallback != null) {
+            if (graphResponse != null) {
+                try {
+                    if (graphResponse.getJSONObject() != null) {
+                        graphResponse.getJSONObject().put(PARAM_VIDEO_ID, str);
+                    }
+                } catch (JSONException unused) {
+                }
+            }
+            uploadContext.progressCallback.onCompleted(graphResponse);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static void enqueueUploadStart(UploadContext uploadContext, int i) {
+        enqueueRequest(uploadContext, new StartUploadWorkItem(uploadContext, i));
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static void enqueueUploadChunk(UploadContext uploadContext, String str, String str2, int i) {
+        enqueueRequest(uploadContext, new TransferChunkWorkItem(uploadContext, str, str2, i));
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static void enqueueUploadFinish(UploadContext uploadContext, int i) {
+        enqueueRequest(uploadContext, new FinishUploadWorkItem(uploadContext, i));
+    }
+
+    private static synchronized void enqueueRequest(UploadContext uploadContext, Runnable runnable) {
+        synchronized (VideoUploader.class) {
+            uploadContext.workItem = uploadQueue.addActiveWorkItem(runnable);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static byte[] getChunk(UploadContext uploadContext, String str, String str2) throws IOException {
+        int read;
+        if (!Utility.areObjectsEqual(str, uploadContext.chunkStart)) {
+            logError(null, "Error reading video chunk. Expected chunk '%s'. Requested chunk '%s'.", uploadContext.chunkStart, str);
+            return null;
+        }
+        int parseLong = (int) (Long.parseLong(str2) - Long.parseLong(str));
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        byte[] bArr = new byte[Math.min(8192, parseLong)];
+        do {
+            read = uploadContext.videoStream.read(bArr);
+            if (read != -1) {
+                byteArrayOutputStream.write(bArr, 0, read);
+                parseLong -= read;
+                if (parseLong == 0) {
+                }
+            }
+            uploadContext.chunkStart = str2;
+            return byteArrayOutputStream.toByteArray();
+        } while (parseLong >= 0);
+        logError(null, "Error reading video chunk. Expected buffer length - '%d'. Actual - '%d'.", Integer.valueOf(parseLong + read), Integer.valueOf(read));
+        return null;
+    }
+
+    private static void registerAccessTokenTracker() {
+        accessTokenTracker = new AccessTokenTracker() { // from class: com.facebook.share.internal.VideoUploader.1
+            @Override // com.facebook.AccessTokenTracker
+            public void onCurrentAccessTokenChanged(AccessToken accessToken, AccessToken accessToken2) {
+                if (accessToken == null) {
+                    return;
+                }
+                if (accessToken2 == null || !Utility.areObjectsEqual(accessToken2.getUserId(), accessToken.getUserId())) {
+                    VideoUploader.cancelAllRequests();
+                }
+            }
+        };
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static void logError(Exception exc, String str, Object... objArr) {
+        Log.e(TAG, String.format(Locale.ROOT, str, objArr), exc);
+    }
+
+    public static class UploadContext {
+        public final AccessToken accessToken;
+        public final FacebookCallback<Sharer.Result> callback;
+        public String chunkStart;
+        public final String description;
+        public final String graphNode;
+        public boolean isCanceled;
+        public Bundle params;
+        public final GraphRequest.OnProgressCallback progressCallback;
+        public final String ref;
+        public String sessionId;
+        public final String title;
+        public String videoId;
+        public long videoSize;
+        public InputStream videoStream;
+        public final Uri videoUri;
+        public WorkQueue.WorkItem workItem;
+
+        private UploadContext(ShareVideoContent shareVideoContent, String str, FacebookCallback<Sharer.Result> facebookCallback, GraphRequest.OnProgressCallback onProgressCallback) {
+            this.chunkStart = "0";
+            this.accessToken = AccessToken.getCurrentAccessToken();
+            this.videoUri = shareVideoContent.getVideo().getLocalUrl();
+            this.title = shareVideoContent.getContentTitle();
+            this.description = shareVideoContent.getContentDescription();
+            this.ref = shareVideoContent.getRef();
+            this.graphNode = str;
+            this.callback = facebookCallback;
+            this.progressCallback = onProgressCallback;
+            this.params = shareVideoContent.getVideo().getParameters();
+            if (!Utility.isNullOrEmpty(shareVideoContent.getPeopleIds())) {
+                this.params.putString("tags", TextUtils.join(", ", shareVideoContent.getPeopleIds()));
+            }
+            if (!Utility.isNullOrEmpty(shareVideoContent.getPlaceId())) {
+                this.params.putString("place", shareVideoContent.getPlaceId());
+            }
+            if (Utility.isNullOrEmpty(shareVideoContent.getRef())) {
+                return;
+            }
+            this.params.putString(VideoUploader.PARAM_REF, shareVideoContent.getRef());
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public void initialize() throws FileNotFoundException {
+            try {
+                if (Utility.isFileUri(this.videoUri)) {
+                    ParcelFileDescriptor open = ParcelFileDescriptor.open(new File(this.videoUri.getPath()), DriveFile.MODE_READ_ONLY);
+                    this.videoSize = open.getStatSize();
+                    this.videoStream = new ParcelFileDescriptor.AutoCloseInputStream(open);
+                } else {
+                    if (Utility.isContentUri(this.videoUri)) {
+                        this.videoSize = Utility.getContentSize(this.videoUri);
+                        this.videoStream = FacebookSdk.getApplicationContext().getContentResolver().openInputStream(this.videoUri);
+                        return;
+                    }
+                    throw new FacebookException("Uri must be a content:// or file:// uri");
+                }
+            } catch (FileNotFoundException e) {
+                Utility.closeQuietly(this.videoStream);
+                throw e;
+            }
+        }
+    }
+
+    public static class StartUploadWorkItem extends UploadWorkItemBase {
+        static final Set<Integer> transientErrorCodes = new HashSet<Integer>() { // from class: com.facebook.share.internal.VideoUploader.StartUploadWorkItem.1
+            {
+                add(6000);
+            }
+        };
+
+        @Override // com.facebook.share.internal.VideoUploader.UploadWorkItemBase
+        public Set<Integer> getTransientErrorCodes() {
+            return transientErrorCodes;
+        }
+
+        public StartUploadWorkItem(UploadContext uploadContext, int i) {
+            super(uploadContext, i);
+        }
+
+        @Override // com.facebook.share.internal.VideoUploader.UploadWorkItemBase
+        public Bundle getParameters() {
+            Bundle bundle = new Bundle();
+            bundle.putString(VideoUploader.PARAM_UPLOAD_PHASE, "start");
+            bundle.putLong(VideoUploader.PARAM_FILE_SIZE, this.uploadContext.videoSize);
+            return bundle;
+        }
+
+        @Override // com.facebook.share.internal.VideoUploader.UploadWorkItemBase
+        public void handleSuccess(JSONObject jSONObject) throws JSONException {
+            this.uploadContext.sessionId = jSONObject.getString(VideoUploader.PARAM_SESSION_ID);
+            this.uploadContext.videoId = jSONObject.getString(VideoUploader.PARAM_VIDEO_ID);
+            String string = jSONObject.getString(VideoUploader.PARAM_START_OFFSET);
+            String string2 = jSONObject.getString(VideoUploader.PARAM_END_OFFSET);
+            if (this.uploadContext.progressCallback != null) {
+                long parseLong = Long.parseLong(string);
+                UploadContext uploadContext = this.uploadContext;
+                uploadContext.progressCallback.onProgress(parseLong, uploadContext.videoSize);
+            }
+            VideoUploader.enqueueUploadChunk(this.uploadContext, string, string2, 0);
+        }
+
+        @Override // com.facebook.share.internal.VideoUploader.UploadWorkItemBase
+        public void handleError(FacebookException facebookException) {
+            VideoUploader.logError(facebookException, "Error starting video upload", new Object[0]);
+            endUploadWithFailure(facebookException);
+        }
+
+        @Override // com.facebook.share.internal.VideoUploader.UploadWorkItemBase
+        public void enqueueRetry(int i) {
+            VideoUploader.enqueueUploadStart(this.uploadContext, i);
+        }
+    }
+
+    public static class TransferChunkWorkItem extends UploadWorkItemBase {
+        static final Set<Integer> transientErrorCodes = new HashSet<Integer>() { // from class: com.facebook.share.internal.VideoUploader.TransferChunkWorkItem.1
+            {
+                add(1363019);
+                add(1363021);
+                add(1363030);
+                add(1363033);
+                add(1363041);
+            }
+        };
+        private String chunkEnd;
+        private String chunkStart;
+
+        @Override // com.facebook.share.internal.VideoUploader.UploadWorkItemBase
+        public Set<Integer> getTransientErrorCodes() {
+            return transientErrorCodes;
+        }
+
+        public TransferChunkWorkItem(UploadContext uploadContext, String str, String str2, int i) {
+            super(uploadContext, i);
+            this.chunkStart = str;
+            this.chunkEnd = str2;
+        }
+
+        @Override // com.facebook.share.internal.VideoUploader.UploadWorkItemBase
+        public Bundle getParameters() throws IOException {
+            Bundle bundle = new Bundle();
+            bundle.putString(VideoUploader.PARAM_UPLOAD_PHASE, VideoUploader.PARAM_VALUE_UPLOAD_TRANSFER_PHASE);
+            bundle.putString(VideoUploader.PARAM_SESSION_ID, this.uploadContext.sessionId);
+            bundle.putString(VideoUploader.PARAM_START_OFFSET, this.chunkStart);
+            byte[] chunk = VideoUploader.getChunk(this.uploadContext, this.chunkStart, this.chunkEnd);
+            if (chunk != null) {
+                bundle.putByteArray(VideoUploader.PARAM_VIDEO_FILE_CHUNK, chunk);
+                return bundle;
+            }
+            throw new FacebookException("Error reading video");
+        }
+
+        @Override // com.facebook.share.internal.VideoUploader.UploadWorkItemBase
+        public void handleSuccess(JSONObject jSONObject) throws JSONException {
+            String string = jSONObject.getString(VideoUploader.PARAM_START_OFFSET);
+            String string2 = jSONObject.getString(VideoUploader.PARAM_END_OFFSET);
+            if (this.uploadContext.progressCallback != null) {
+                long parseLong = Long.parseLong(string);
+                UploadContext uploadContext = this.uploadContext;
+                uploadContext.progressCallback.onProgress(parseLong, uploadContext.videoSize);
+            }
+            if (Utility.areObjectsEqual(string, string2)) {
+                VideoUploader.enqueueUploadFinish(this.uploadContext, 0);
+            } else {
+                VideoUploader.enqueueUploadChunk(this.uploadContext, string, string2, 0);
+            }
+        }
+
+        @Override // com.facebook.share.internal.VideoUploader.UploadWorkItemBase
+        public void handleError(FacebookException facebookException) {
+            VideoUploader.logError(facebookException, "Error uploading video '%s'", this.uploadContext.videoId);
+            endUploadWithFailure(facebookException);
+        }
+
+        @Override // com.facebook.share.internal.VideoUploader.UploadWorkItemBase
+        public void enqueueRetry(int i) {
+            VideoUploader.enqueueUploadChunk(this.uploadContext, this.chunkStart, this.chunkEnd, i);
+        }
+    }
+
+    public static class FinishUploadWorkItem extends UploadWorkItemBase {
+        static final Set<Integer> transientErrorCodes = new HashSet<Integer>() { // from class: com.facebook.share.internal.VideoUploader.FinishUploadWorkItem.1
+            {
+                add(1363011);
+            }
+        };
+
+        @Override // com.facebook.share.internal.VideoUploader.UploadWorkItemBase
+        public Set<Integer> getTransientErrorCodes() {
+            return transientErrorCodes;
+        }
+
+        public FinishUploadWorkItem(UploadContext uploadContext, int i) {
+            super(uploadContext, i);
+        }
+
+        @Override // com.facebook.share.internal.VideoUploader.UploadWorkItemBase
+        public Bundle getParameters() {
+            Bundle bundle = new Bundle();
+            Bundle bundle2 = this.uploadContext.params;
+            if (bundle2 != null) {
+                bundle.putAll(bundle2);
+            }
+            bundle.putString(VideoUploader.PARAM_UPLOAD_PHASE, VideoUploader.PARAM_VALUE_UPLOAD_FINISH_PHASE);
+            bundle.putString(VideoUploader.PARAM_SESSION_ID, this.uploadContext.sessionId);
+            Utility.putNonEmptyString(bundle, "title", this.uploadContext.title);
+            Utility.putNonEmptyString(bundle, "description", this.uploadContext.description);
+            Utility.putNonEmptyString(bundle, VideoUploader.PARAM_REF, this.uploadContext.ref);
+            return bundle;
+        }
+
+        @Override // com.facebook.share.internal.VideoUploader.UploadWorkItemBase
+        public void handleSuccess(JSONObject jSONObject) throws JSONException {
+            if (jSONObject.getBoolean("success")) {
+                issueResponseOnMainThread(null, this.uploadContext.videoId);
+            } else {
+                handleError(new FacebookException(VideoUploader.ERROR_BAD_SERVER_RESPONSE));
+            }
+        }
+
+        @Override // com.facebook.share.internal.VideoUploader.UploadWorkItemBase
+        public void handleError(FacebookException facebookException) {
+            VideoUploader.logError(facebookException, "Video '%s' failed to finish uploading", this.uploadContext.videoId);
+            endUploadWithFailure(facebookException);
+        }
+
+        @Override // com.facebook.share.internal.VideoUploader.UploadWorkItemBase
+        public void enqueueRetry(int i) {
+            VideoUploader.enqueueUploadFinish(this.uploadContext, i);
+        }
+    }
+
+    public static abstract class UploadWorkItemBase implements Runnable {
+        protected int completedRetries;
+        protected GraphResponse response;
+        protected UploadContext uploadContext;
+
+        public abstract void enqueueRetry(int i);
+
+        public abstract Bundle getParameters() throws Exception;
+
+        public abstract Set<Integer> getTransientErrorCodes();
+
+        public abstract void handleError(FacebookException facebookException);
+
+        public abstract void handleSuccess(JSONObject jSONObject) throws JSONException;
+
+        public UploadWorkItemBase(UploadContext uploadContext, int i) {
+            this.uploadContext = uploadContext;
+            this.completedRetries = i;
+        }
+
+        @Override // java.lang.Runnable
+        public void run() {
+            if (CrashShieldHandler.isObjectCrashing(this)) {
+                return;
+            }
+            try {
+                if (!this.uploadContext.isCanceled) {
+                    try {
+                        try {
+                            executeGraphRequestSynchronously(getParameters());
+                            return;
+                        } catch (Exception e) {
+                            endUploadWithFailure(new FacebookException(VideoUploader.ERROR_UPLOAD, e));
+                            return;
+                        }
+                    } catch (FacebookException e2) {
+                        endUploadWithFailure(e2);
+                        return;
+                    }
+                }
+                endUploadWithFailure(null);
+            } catch (Throwable th) {
+                CrashShieldHandler.handleThrowable(th, this);
+            }
+        }
+
+        public void executeGraphRequestSynchronously(Bundle bundle) {
+            UploadContext uploadContext = this.uploadContext;
+            GraphResponse executeAndWait = new GraphRequest(uploadContext.accessToken, String.format(Locale.ROOT, "%s/videos", uploadContext.graphNode), bundle, HttpMethod.POST, null).executeAndWait();
+            this.response = executeAndWait;
+            if (executeAndWait != null) {
+                FacebookRequestError error = executeAndWait.getError();
+                JSONObject jSONObject = this.response.getJSONObject();
+                if (error != null) {
+                    if (attemptRetry(error.getSubErrorCode())) {
+                        return;
+                    }
+                    handleError(new FacebookGraphResponseException(this.response, VideoUploader.ERROR_UPLOAD));
+                    return;
+                } else {
+                    if (jSONObject != null) {
+                        try {
+                            handleSuccess(jSONObject);
+                            return;
+                        } catch (JSONException e) {
+                            endUploadWithFailure(new FacebookException(VideoUploader.ERROR_BAD_SERVER_RESPONSE, e));
+                            return;
+                        }
+                    }
+                    handleError(new FacebookException(VideoUploader.ERROR_BAD_SERVER_RESPONSE));
+                    return;
+                }
+            }
+            handleError(new FacebookException(VideoUploader.ERROR_BAD_SERVER_RESPONSE));
+        }
+
+        private boolean attemptRetry(int i) {
+            if (this.completedRetries >= 2 || !getTransientErrorCodes().contains(Integer.valueOf(i))) {
+                return false;
+            }
+            VideoUploader.getHandler().postDelayed(new Runnable() { // from class: com.facebook.share.internal.VideoUploader.UploadWorkItemBase.1
+                @Override // java.lang.Runnable
+                public void run() {
+                    if (CrashShieldHandler.isObjectCrashing(this)) {
+                        return;
+                    }
+                    try {
+                        UploadWorkItemBase uploadWorkItemBase = UploadWorkItemBase.this;
+                        uploadWorkItemBase.enqueueRetry(uploadWorkItemBase.completedRetries + 1);
+                    } catch (Throwable th) {
+                        CrashShieldHandler.handleThrowable(th, this);
+                    }
+                }
+            }, ((int) Math.pow(3.0d, this.completedRetries)) * 5000);
+            return true;
+        }
+
+        public void endUploadWithFailure(FacebookException facebookException) {
+            issueResponseOnMainThread(facebookException, null);
+        }
+
+        public void issueResponseOnMainThread(final FacebookException facebookException, final String str) {
+            VideoUploader.getHandler().post(new Runnable() { // from class: com.facebook.share.internal.VideoUploader.UploadWorkItemBase.2
+                @Override // java.lang.Runnable
+                public void run() {
+                    if (CrashShieldHandler.isObjectCrashing(this)) {
+                        return;
+                    }
+                    try {
+                        UploadWorkItemBase uploadWorkItemBase = UploadWorkItemBase.this;
+                        VideoUploader.issueResponse(uploadWorkItemBase.uploadContext, facebookException, uploadWorkItemBase.response, str);
+                    } catch (Throwable th) {
+                        CrashShieldHandler.handleThrowable(th, this);
+                    }
+                }
+            });
+        }
+    }
+}

decompiled-community/sources/com/facebook/share/internal/WebDialogParameters.java

@@ -0,0 +1,146 @@
+package com.facebook.share.internal;
+
+import android.annotation.SuppressLint;
+import android.os.Bundle;
+import com.facebook.internal.Utility;
+import com.facebook.share.model.AppGroupCreationContent;
+import com.facebook.share.model.GameRequestContent;
+import com.facebook.share.model.ShareContent;
+import com.facebook.share.model.ShareHashtag;
+import com.facebook.share.model.ShareLinkContent;
+import com.facebook.share.model.SharePhoto;
+import com.facebook.share.model.SharePhotoContent;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import kotlin.collections.CollectionsKt__CollectionsKt;
+import kotlin.collections.CollectionsKt__IterablesKt;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes2.dex */
+public final class WebDialogParameters {
+    public static final WebDialogParameters INSTANCE = new WebDialogParameters();
+
+    private WebDialogParameters() {
+    }
+
+    public static final Bundle create(AppGroupCreationContent appGroupCreationContent) {
+        String obj;
+        Intrinsics.checkNotNullParameter(appGroupCreationContent, "appGroupCreationContent");
+        Bundle bundle = new Bundle();
+        Utility utility = Utility.INSTANCE;
+        Utility.putNonEmptyString(bundle, "name", appGroupCreationContent.getName());
+        Utility.putNonEmptyString(bundle, "description", appGroupCreationContent.getDescription());
+        AppGroupCreationContent.AppGroupPrivacy appGroupPrivacy = appGroupCreationContent.getAppGroupPrivacy();
+        String str = null;
+        if (appGroupPrivacy != null && (obj = appGroupPrivacy.toString()) != null) {
+            Locale ENGLISH = Locale.ENGLISH;
+            Intrinsics.checkNotNullExpressionValue(ENGLISH, "ENGLISH");
+            str = obj.toLowerCase(ENGLISH);
+            Intrinsics.checkNotNullExpressionValue(str, "(this as java.lang.String).toLowerCase(locale)");
+        }
+        Utility.putNonEmptyString(bundle, ShareConstants.WEB_DIALOG_PARAM_PRIVACY, str);
+        return bundle;
+    }
+
+    public static final Bundle create(GameRequestContent gameRequestContent) {
+        String obj;
+        String lowerCase;
+        String obj2;
+        Intrinsics.checkNotNullParameter(gameRequestContent, "gameRequestContent");
+        Bundle bundle = new Bundle();
+        Utility utility = Utility.INSTANCE;
+        Utility.putNonEmptyString(bundle, "message", gameRequestContent.getMessage());
+        Utility.putCommaSeparatedStringList(bundle, "to", gameRequestContent.getRecipients());
+        Utility.putNonEmptyString(bundle, "title", gameRequestContent.getTitle());
+        Utility.putNonEmptyString(bundle, "data", gameRequestContent.getData());
+        GameRequestContent.ActionType actionType = gameRequestContent.getActionType();
+        String str = null;
+        if (actionType == null || (obj = actionType.toString()) == null) {
+            lowerCase = null;
+        } else {
+            Locale ENGLISH = Locale.ENGLISH;
+            Intrinsics.checkNotNullExpressionValue(ENGLISH, "ENGLISH");
+            lowerCase = obj.toLowerCase(ENGLISH);
+            Intrinsics.checkNotNullExpressionValue(lowerCase, "(this as java.lang.String).toLowerCase(locale)");
+        }
+        Utility.putNonEmptyString(bundle, ShareConstants.WEB_DIALOG_PARAM_ACTION_TYPE, lowerCase);
+        Utility.putNonEmptyString(bundle, "object_id", gameRequestContent.getObjectId());
+        GameRequestContent.Filters filters = gameRequestContent.getFilters();
+        if (filters != null && (obj2 = filters.toString()) != null) {
+            Locale ENGLISH2 = Locale.ENGLISH;
+            Intrinsics.checkNotNullExpressionValue(ENGLISH2, "ENGLISH");
+            str = obj2.toLowerCase(ENGLISH2);
+            Intrinsics.checkNotNullExpressionValue(str, "(this as java.lang.String).toLowerCase(locale)");
+        }
+        Utility.putNonEmptyString(bundle, "filters", str);
+        Utility.putCommaSeparatedStringList(bundle, ShareConstants.WEB_DIALOG_PARAM_SUGGESTIONS, gameRequestContent.getSuggestions());
+        return bundle;
+    }
+
+    public static final Bundle create(ShareLinkContent shareLinkContent) {
+        Intrinsics.checkNotNullParameter(shareLinkContent, "shareLinkContent");
+        Bundle createBaseParameters = createBaseParameters(shareLinkContent);
+        Utility utility = Utility.INSTANCE;
+        Utility.putUri(createBaseParameters, ShareConstants.WEB_DIALOG_PARAM_HREF, shareLinkContent.getContentUrl());
+        Utility.putNonEmptyString(createBaseParameters, ShareConstants.WEB_DIALOG_PARAM_QUOTE, shareLinkContent.getQuote());
+        return createBaseParameters;
+    }
+
+    public static final Bundle create(SharePhotoContent sharePhotoContent) {
+        Intrinsics.checkNotNullParameter(sharePhotoContent, "sharePhotoContent");
+        Bundle createBaseParameters = createBaseParameters(sharePhotoContent);
+        List<SharePhoto> photos = sharePhotoContent.getPhotos();
+        if (photos == null) {
+            photos = CollectionsKt__CollectionsKt.emptyList();
+        }
+        List<SharePhoto> list = photos;
+        ArrayList arrayList = new ArrayList(CollectionsKt__IterablesKt.collectionSizeOrDefault(list, 10));
+        Iterator<T> it = list.iterator();
+        while (it.hasNext()) {
+            arrayList.add(String.valueOf(((SharePhoto) it.next()).getImageUrl()));
+        }
+        Object[] array = arrayList.toArray(new String[0]);
+        if (array == null) {
+            throw new NullPointerException("null cannot be cast to non-null type kotlin.Array<T>");
+        }
+        createBaseParameters.putStringArray("media", (String[]) array);
+        return createBaseParameters;
+    }
+
+    public static final Bundle createBaseParameters(ShareContent<?, ?> shareContent) {
+        Intrinsics.checkNotNullParameter(shareContent, "shareContent");
+        Bundle bundle = new Bundle();
+        Utility utility = Utility.INSTANCE;
+        ShareHashtag shareHashtag = shareContent.getShareHashtag();
+        Utility.putNonEmptyString(bundle, ShareConstants.WEB_DIALOG_PARAM_HASHTAG, shareHashtag == null ? null : shareHashtag.getHashtag());
+        return bundle;
+    }
+
+    @SuppressLint({"DeprecatedMethod"})
+    public static final Bundle createForFeed(ShareLinkContent shareLinkContent) {
+        Intrinsics.checkNotNullParameter(shareLinkContent, "shareLinkContent");
+        Bundle bundle = new Bundle();
+        Utility utility = Utility.INSTANCE;
+        Utility.putNonEmptyString(bundle, "link", Utility.getUriString(shareLinkContent.getContentUrl()));
+        Utility.putNonEmptyString(bundle, ShareConstants.WEB_DIALOG_PARAM_QUOTE, shareLinkContent.getQuote());
+        ShareHashtag shareHashtag = shareLinkContent.getShareHashtag();
+        Utility.putNonEmptyString(bundle, ShareConstants.WEB_DIALOG_PARAM_HASHTAG, shareHashtag == null ? null : shareHashtag.getHashtag());
+        return bundle;
+    }
+
+    public static final Bundle createForFeed(ShareFeedContent shareFeedContent) {
+        Intrinsics.checkNotNullParameter(shareFeedContent, "shareFeedContent");
+        Bundle bundle = new Bundle();
+        Utility utility = Utility.INSTANCE;
+        Utility.putNonEmptyString(bundle, "to", shareFeedContent.getToId());
+        Utility.putNonEmptyString(bundle, "link", shareFeedContent.getLink());
+        Utility.putNonEmptyString(bundle, "picture", shareFeedContent.getPicture());
+        Utility.putNonEmptyString(bundle, ShareConstants.FEED_SOURCE_PARAM, shareFeedContent.getMediaSource());
+        Utility.putNonEmptyString(bundle, "name", shareFeedContent.getLinkName());
+        Utility.putNonEmptyString(bundle, ShareConstants.FEED_CAPTION_PARAM, shareFeedContent.getLinkCaption());
+        Utility.putNonEmptyString(bundle, "description", shareFeedContent.getLinkDescription());
+        return bundle;
+    }
+}