@ohos-ports/react-native-fbsdk-next 13.4.3-beta.0

package/android/src/main/java/com/facebook/reactnative/androidsdk/FBGraphRequestModule.java

@@ -0,0 +1,283 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ * <p/>
+ * You are hereby granted a non-exclusive, worldwide, royalty-free license to use,
+ * copy, modify, and distribute this software in source code or binary form for use
+ * in connection with the web services and APIs provided by Facebook.
+ * <p/>
+ * As with any software that integrates with the Facebook platform, your use of
+ * this software is subject to the Facebook Developer Principles and Policies
+ * [http://developers.facebook.com/policy/]. This copyright notice shall be
+ * included in all copies or substantial portions of the software.
+ * <p/>
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package com.facebook.reactnative.androidsdk;
+
+import android.os.Bundle;
+import android.util.SparseArray;
+
+import com.facebook.AccessToken;
+import com.facebook.FacebookRequestError;
+import com.facebook.GraphRequest;
+import com.facebook.GraphRequestBatch;
+import com.facebook.GraphResponse;
+import com.facebook.HttpMethod;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.module.annotations.ReactModule;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.HashMap;
+import java.util.Iterator;
+
+/**
+ * FBGraphRequestModule holds a list of request objects and send them to Facebook in a single
+ * round-trip.
+ */
+@ReactModule(name = FBGraphRequestModule.NAME)
+public class FBGraphRequestModule extends ReactContextBaseJavaModule {
+    public static final String NAME = "FBGraphRequest";
+
+    private SparseArray<WritableMap> mResponses;
+
+    private class GraphRequestBatchCallback implements GraphRequestBatch.Callback {
+
+        private int mBatchID;
+        private Callback mCallback;
+
+        public GraphRequestBatchCallback(int batchID, Callback callback) {
+            mBatchID = batchID;
+            mCallback = callback;
+        }
+
+        @Override
+        public void onBatchCompleted(GraphRequestBatch batch) {
+            WritableMap result = Arguments.createMap();
+            result.putString("result", "batch finished executing or timed out");
+            mCallback.invoke(null, result, mResponses.get(mBatchID));
+            mResponses.remove(mBatchID);
+        }
+    }
+
+    private class GraphRequestCallback implements GraphRequest.Callback {
+
+        private String mIndex;
+        private int mBatchID;
+
+        public GraphRequestCallback(int index, int batchID) {
+            mIndex = String.valueOf(index);
+            mBatchID = batchID;
+        }
+
+        @Override
+        public void onCompleted(GraphResponse response) {
+            WritableArray responseArray = Arguments.createArray();
+            responseArray.pushMap(buildFacebookRequestError(response.getError()));
+            responseArray.pushMap(buildGraphResponse(response));
+            mResponses.get(mBatchID).putArray(mIndex, responseArray);
+        }
+    }
+
+    public FBGraphRequestModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        mResponses = new SparseArray<WritableMap>();
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    /**
+     * Send the batch of requests.
+     * @param requestBatch
+     * @param timeout
+     * @param batchCallback
+     */
+    @ReactMethod
+    public void start(ReadableArray requestBatch, int timeout, Callback batchCallback) {
+        GraphRequestBatch batch = new GraphRequestBatch();
+        int potentialID = 0;
+        int batchID = 0;
+        synchronized (this) {
+            do {
+                batchID = potentialID++;
+            } while (mResponses.get(batchID) != null);
+            mResponses.put(batchID, Arguments.createMap());
+        }
+        for (int i = 0; i < requestBatch.size(); i++) {
+            GraphRequest request = buildRequest(requestBatch.getMap(i));
+            request.setCallback(new GraphRequestCallback(i, batchID));
+            batch.add(request);
+        }
+        batch.setTimeout(timeout);
+        GraphRequestBatchCallback callback = new GraphRequestBatchCallback(batchID, batchCallback);
+        batch.addCallback(callback);
+        batch.executeAsync();
+    }
+
+    private GraphRequest buildRequest(ReadableMap requestMap) {
+        GraphRequest graphRequest = new GraphRequest();
+        graphRequest.setGraphPath(requestMap.getString("graphPath"));
+        setConfig(graphRequest, requestMap.getMap("config"));
+        return graphRequest;
+    }
+
+    private void setConfig(GraphRequest graphRequest, ReadableMap configMap) {
+        if (configMap == null) {
+            graphRequest.setAccessToken(AccessToken.getCurrentAccessToken());
+            return;
+        }
+        if (configMap.hasKey("parameters")) {
+            graphRequest.setParameters(buildParameters(configMap.getMap("parameters")));
+        }
+        if (configMap.hasKey("httpMethod")) {
+            graphRequest.setHttpMethod(HttpMethod.valueOf(configMap.getString("httpMethod")));
+        }
+        if (configMap.hasKey("version")) {
+            graphRequest.setVersion(configMap.getString("version"));
+        }
+        if (configMap.hasKey("accessToken")) {
+            graphRequest.setAccessToken(new AccessToken(
+                configMap.getString("accessToken"),
+                AccessToken.getCurrentAccessToken().getApplicationId(),
+                AccessToken.getCurrentAccessToken().getUserId(),
+                null,
+                null,
+                null,
+                null,
+                null,
+                null,
+                null));
+        } else {
+            graphRequest.setAccessToken(AccessToken.getCurrentAccessToken());
+        }
+    }
+
+    private Bundle buildParameters(ReadableMap parameterMap) {
+        Bundle parameters = new Bundle();
+        ReadableMapKeySetIterator keyIterator = parameterMap.keySetIterator();
+        while (keyIterator.hasNextKey()) {
+            String key = keyIterator.nextKey();
+            ReadableMap parameter = parameterMap.getMap(key);
+            if (parameter.hasKey("string")) {
+                parameters.putString(key, parameter.getString("string"));
+            }
+        }
+        return parameters;
+    }
+
+    private WritableMap buildFacebookRequestError(FacebookRequestError error) {
+        if (error == null) {
+            return null;
+        }
+        WritableMap errorMap = Arguments.createMap();
+        errorMap.putInt("requestStatusCode", error.getRequestStatusCode());
+        errorMap.putInt("errorCode", error.getErrorCode());
+        errorMap.putInt("subErrorCode", error.getSubErrorCode());
+        if (error.getErrorType() != null) {
+            errorMap.putString("errorType", error.getErrorType());
+        }
+        if (error.getErrorMessage() != null) {
+            errorMap.putString("errorMessage", error.getErrorMessage());
+        }
+        if (error.getErrorUserTitle() != null) {
+            errorMap.putString("errorUserTitle", error.getErrorUserTitle());
+        }
+        if (error.getErrorUserMessage() != null) {
+            errorMap.putString("errorUserMessage", error.getErrorUserMessage());
+        }
+        if (error.getRequestResultBody() != null) {
+            errorMap.putString("requestResultBody", error.getRequestResultBody().toString());
+        }
+        if (error.getRequestResult() != null) {
+            errorMap.putString("requestResult", error.getRequestResult().toString());
+        }
+        if (error.getBatchRequestResult() != null) {
+            errorMap.putString("batchRequestResult", error.getBatchRequestResult().toString());
+        }
+        if (error.getException() != null) {
+            errorMap.putString("exception", error.getException().toString());
+        }
+        return errorMap;
+    }
+
+    private WritableMap buildGraphResponse(GraphResponse response) {
+        if (response.getJSONObject() != null) {
+            return convertJSONObject(response.getJSONObject());
+        }
+        return Arguments.createMap();
+    }
+
+    private WritableArray convertJSONArray(JSONArray jsonArray) {
+        WritableArray result = Arguments.createArray();
+        for (int i = 0; i < jsonArray.length(); i++) {
+            Object object;
+            try {
+                object = jsonArray.get(i);
+            } catch (JSONException e) {
+                return result;
+            }
+            if (object instanceof JSONObject) {
+                result.pushMap(convertJSONObject((JSONObject) object));
+            } else if (object instanceof JSONArray) {
+                result.pushArray(convertJSONArray((JSONArray) object));
+            } else if (object instanceof String) {
+                result.pushString((String) object);
+            } else if (object instanceof Integer) {
+                result.pushInt((int) object);
+            } else if (object instanceof Boolean) {
+                result.pushBoolean((Boolean) object);
+            } else if (object instanceof Double) {
+                result.pushDouble((Double) object);
+            }
+        }
+        return result;
+    }
+
+    private WritableMap convertJSONObject(JSONObject object) {
+        WritableMap result = Arguments.createMap();
+        Iterator<String> keyIterator = object.keys();
+        while (keyIterator.hasNext()) {
+            String key = keyIterator.next();
+            Object value;
+            try {
+                value = object.get(key);
+            } catch (JSONException e) {
+                return result;
+            }
+            if (value instanceof JSONObject) {
+                result.putMap(key, convertJSONObject((JSONObject) value));
+            } else if (value instanceof JSONArray) {
+                result.putArray(key, convertJSONArray((JSONArray) value));
+            } else if (value instanceof String) {
+                result.putString(key, (String) value);
+            } else if (value instanceof Integer) {
+                result.putInt(key, (int) value);
+            } else if (value instanceof Boolean) {
+                result.putBoolean(key, (Boolean) value);
+            } else if (value instanceof Double) {
+                result.putDouble(key, (Double) value);
+            }
+        }
+        return result;
+    }
+}

package/android/src/main/java/com/facebook/reactnative/androidsdk/FBLoginButtonManager.java

@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * You are hereby granted a non-exclusive, worldwide, royalty-free license to use,
+ * copy, modify, and distribute this software in source code or binary form for use
+ * in connection with the web services and APIs provided by Facebook.
+ *
+ * As with any software that integrates with the Facebook platform, your use of
+ * this software is subject to the Facebook Developer Principles and Policies
+ * [http://developers.facebook.com/policy/]. This copyright notice shall be
+ * included in all copies or substantial portions of the software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package com.facebook.reactnative.androidsdk;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.login.DefaultAudience;
+import com.facebook.login.LoginBehavior;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.facebook.react.uimanager.SimpleViewManager;
+import com.facebook.react.uimanager.ThemedReactContext;
+
+import java.util.Locale;
+
+public class FBLoginButtonManager extends SimpleViewManager<RCTLoginButton> {
+
+    public static final String REACT_CLASS = "RCTFBLoginButton";
+
+    private final FBActivityEventListener mActivityEventListener = new FBActivityEventListener();
+
+    public FBLoginButtonManager(ReactApplicationContext reactApplicationContext) {
+        reactApplicationContext.addActivityEventListener(mActivityEventListener);
+    }
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @Override
+    public RCTLoginButton createViewInstance(ThemedReactContext context) {
+        return new RCTLoginButton(context, mActivityEventListener.getCallbackManager());
+    }
+
+    @ReactProp(name = "loginBehaviorAndroid")
+    public void setLoginBehavior(RCTLoginButton loginButton, @Nullable String loginBehavior) {
+        LoginBehavior behavior = LoginBehavior.NATIVE_WITH_FALLBACK;
+
+        if (loginBehavior != null) {
+            behavior = LoginBehavior.valueOf(loginBehavior.toUpperCase(Locale.ROOT));
+        }
+
+        loginButton.setLoginBehavior(behavior);
+    }
+
+    @ReactProp(name = "defaultAudience")
+    public void setDefaultAudience(RCTLoginButton loginButton, @Nullable String defaultAudience) {
+        DefaultAudience audience = DefaultAudience.FRIENDS;
+
+        if (defaultAudience != null) {
+            audience = DefaultAudience.valueOf(defaultAudience.toUpperCase(Locale.ROOT));
+        }
+
+        loginButton.setDefaultAudience(audience);
+    }
+
+    @ReactProp(name = "permissions")
+    public void setPermissions(
+            RCTLoginButton loginButton,
+            @Nullable ReadableArray publishPermissions) {
+        loginButton.setPermissions(Utility.reactArrayToStringList(publishPermissions));
+    }
+}

package/android/src/main/java/com/facebook/reactnative/androidsdk/FBLoginManagerModule.java

@@ -0,0 +1,171 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * You are hereby granted a non-exclusive, worldwide, royalty-free license to use,
+ * copy, modify, and distribute this software in source code or binary form for use
+ * in connection with the web services and APIs provided by Facebook.
+ *
+ * As with any software that integrates with the Facebook platform, your use of
+ * this software is subject to the Facebook Developer Principles and Policies
+ * [http://developers.facebook.com/policy/]. This copyright notice shall be
+ * included in all copies or substantial portions of the software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package com.facebook.reactnative.androidsdk;
+
+import android.app.Activity;
+
+import com.facebook.AccessToken;
+import com.facebook.login.DefaultAudience;
+import com.facebook.login.LoginBehavior;
+import com.facebook.login.LoginManager;
+import com.facebook.login.LoginResult;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.module.annotations.ReactModule;
+
+import java.util.Locale;
+import java.util.Set;
+
+/**
+ * This is a {@link NativeModule} that allows JS to use LoginManager of Facebook Android SDK.
+ */
+@ReactModule(name = FBLoginManagerModule.NAME)
+public class FBLoginManagerModule extends FBSDKCallbackManagerBaseJavaModule {
+
+    public static final String NAME = "FBLoginManager";
+
+    private class LoginManagerCallback extends ReactNativeFacebookSDKCallback<LoginResult> {
+
+        public LoginManagerCallback(Promise promise) {
+            super(promise);
+        }
+
+        @Override
+        public void onSuccess(LoginResult loginResult) {
+            if (mPromise != null) {
+                AccessToken accessToken = loginResult.getAccessToken();
+                AccessToken.setCurrentAccessToken(accessToken);
+                WritableMap result = Arguments.createMap();
+                result.putBoolean("isCancelled", false);
+                result.putArray("grantedPermissions",
+                        setToWritableArray(loginResult.getRecentlyGrantedPermissions()));
+                result.putArray("declinedPermissions",
+                        setToWritableArray(loginResult.getRecentlyDeniedPermissions()));
+                mPromise.resolve(result);
+                mPromise = null;
+            }
+        }
+    }
+
+    public FBLoginManagerModule(ReactApplicationContext reactContext, FBActivityEventListener activityEventListener) {
+        super(reactContext, activityEventListener);
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    /**
+     * Get {@link LoginBehavior} for login attempts.
+     * @param promise Use Promise to pass login behavior back to JS.
+     */
+    @ReactMethod
+    public void getLoginBehavior(Promise promise) {
+        promise.resolve(LoginManager.getInstance().getLoginBehavior().name().toLowerCase(Locale.ROOT));
+    }
+
+    /**
+     * Set {@link LoginBehavior} for login attempts.
+     * @param loginBehaviorString must be one of the constants in Enum
+     * {@link LoginBehavior}.
+     * @throws {@link java.lang.IllegalArgumentException} if the argument is not a valid constant.
+     */
+    @ReactMethod
+    public void setLoginBehavior(String loginBehaviorString) {
+        LoginBehavior loginBehavior = LoginBehavior.valueOf(loginBehaviorString.toUpperCase(Locale.ROOT));
+        LoginManager.getInstance().setLoginBehavior(loginBehavior);
+    }
+
+    /**
+     * Get {@link DefaultAudience} to use for sessions that post data to Facebook.
+     * @param promise Use promise to pass default audience back to JS.
+     */
+    @ReactMethod
+    public void getDefaultAudience(Promise promise) {
+        promise.resolve(LoginManager.getInstance().getDefaultAudience().name().toLowerCase(Locale.ROOT));
+    }
+
+    /**
+     * Set {@link DefaultAudience} to use for sessions that post data to Facebook.
+     * @param defaultAudienceString must be one of the constants in Enum {@link DefaultAudience}.
+     * @throws {@link java.lang.IllegalArgumentException} if the argument is not a valid constant.
+     */
+    @ReactMethod
+    public void setDefaultAudience(String defaultAudienceString) {
+        DefaultAudience defaultAudience = DefaultAudience.valueOf(defaultAudienceString.toUpperCase(Locale.ROOT));
+        LoginManager.getInstance().setDefaultAudience(defaultAudience);
+    }
+
+    /**
+     * Log out from Facebook.
+     */
+    @ReactMethod
+    public void logOut() {
+        LoginManager.getInstance().logOut();
+    }
+
+    /**
+     * Attempts a Facebook login with the specified permissions.
+     * @param permissions must be one of the provided permissions. See
+     *                    <a href="https://developers.facebook.com/docs/facebook-login/permissions">
+     *                    Facebook login permissions</a>.
+     * @param promise Use promise to pass login result to JS after login finish.
+     */
+    @ReactMethod
+    public void logInWithPermissions(ReadableArray permissions, final Promise promise) {
+        final LoginManager loginManager = LoginManager.getInstance();
+        loginManager.registerCallback(getCallbackManager(), new LoginManagerCallback(promise));
+        Activity activity = getCurrentActivity();
+        if (activity != null) {
+            loginManager.logIn(activity,
+                    Utility.reactArrayToStringList(permissions));
+        }
+    }
+
+    /**
+     * Attempts a re-authorization to regain data access.
+     * @param promise Use promise to pass re-authorization result to JS after re-authorization finish.
+     */
+    @ReactMethod
+    public void reauthorizeDataAccess(final Promise promise) {
+        final LoginManager loginManager = LoginManager.getInstance();
+        loginManager.registerCallback(getCallbackManager(), new LoginManagerCallback(promise));
+        Activity activity = getCurrentActivity();
+        if (activity != null) {
+            loginManager.reauthorizeDataAccess(activity);
+        }
+    }
+
+    private WritableArray setToWritableArray(Set<String> set) {
+        WritableArray array = Arguments.createArray();
+        for (String e: set) {
+            array.pushString(e);
+        }
+        return array;
+    }
+}

package/android/src/main/java/com/facebook/reactnative/androidsdk/FBMessageDialogModule.java

@@ -0,0 +1,111 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * You are hereby granted a non-exclusive, worldwide, royalty-free license to use,
+ * copy, modify, and distribute this software in source code or binary form for use
+ * in connection with the web services and APIs provided by Facebook.
+ *
+ * As with any software that integrates with the Facebook platform, your use of
+ * this software is subject to the Facebook Developer Principles and Policies
+ * [http://developers.facebook.com/policy/]. This copyright notice shall be
+ * included in all copies or substantial portions of the software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package com.facebook.reactnative.androidsdk;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.share.model.ShareContent;
+import com.facebook.share.widget.MessageDialog;
+
+/**
+ * Provides functionality to send content via the Facebook Message Dialog
+ */
+@ReactModule(name = FBMessageDialogModule.NAME)
+public class FBMessageDialogModule extends FBSDKCallbackManagerBaseJavaModule {
+    public static final String NAME = "FBMessageDialog";
+
+    private class MessageDialogCallback extends ReactNativeFacebookSDKCallback<MessageDialog.Result> {
+
+        public MessageDialogCallback(Promise promise) {
+            super(promise);
+        }
+
+        @Override
+        public void onSuccess(MessageDialog.Result result) {
+            if (mPromise != null) {
+                WritableMap messageDialogResult = Arguments.createMap();
+                messageDialogResult.putString("postId", result.getPostId());
+                mPromise.resolve(messageDialogResult);
+                mPromise = null;
+            }
+        }
+    }
+
+    private boolean mShouldFailOnDataError;
+
+    public FBMessageDialogModule(ReactApplicationContext reactContext, FBActivityEventListener activityEventListener) {
+        super(reactContext, activityEventListener);
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    /**
+     * Indicates whether it is possible to show the dialog for ShareContent of the specified type.
+     * @param shareContentMap  must be a valid {@link ShareContent}.
+     * @param promise Use promise to pass message dialog result to JS.
+     */
+    @ReactMethod
+    public void canShow(ReadableMap shareContentMap, Promise promise) {
+        if (getCurrentActivity() != null) {
+            ShareContent shareContent = Utility.buildShareContent(shareContentMap);
+            MessageDialog messageDialog = new MessageDialog(getCurrentActivity());
+            promise.resolve(messageDialog.canShow(shareContent));
+        } else {
+            promise.reject("No current activity.");
+        }
+    }
+
+    /**
+     * Show the provided ShareContent using the provided Activity.
+     * @param shareContentMap  must be a valid {@link ShareContent}.
+     * @param promise Use promise to pass message dialog result to JS.
+     */
+    @ReactMethod
+    public void show(ReadableMap shareContentMap, Promise promise) {
+        if (getCurrentActivity() != null) {
+            ShareContent shareContent = Utility.buildShareContent(shareContentMap);
+            MessageDialog messageDialog = new MessageDialog(getCurrentActivity());
+            messageDialog.setShouldFailOnDataError(mShouldFailOnDataError);
+            messageDialog.registerCallback(getCallbackManager(), new MessageDialogCallback(promise));
+            messageDialog.show(shareContent);
+        } else {
+            promise.reject("No current activity.");
+        }
+    }
+
+    /**
+     * Specifies whether the sharer should fail if it finds an error with the share content.
+     * If false, the share dialog will still be displayed without the data that was mis-configured.
+     * @param shouldFailOnDataError Whether the dialog should fail if it finds an error.
+     */
+    @ReactMethod
+    public void setShouldFailOnDataError(boolean shouldFailOnDataError) {
+        mShouldFailOnDataError = shouldFailOnDataError;
+    }
+}