com.facebook.share.Sharer Java Examples

public static void registerSharerCallback(
        final int requestCode,
        final CallbackManager callbackManager,
        final FacebookCallback<Sharer.Result> callback) {
    if (!(callbackManager instanceof CallbackManagerImpl)) {
        throw new FacebookException("Unexpected CallbackManager, " +
                "please use the provided Factory.");
    }

    ((CallbackManagerImpl) callbackManager).registerCallback(
            requestCode,
            new CallbackManagerImpl.Callback() {
                @Override
                public boolean onActivityResult(int resultCode, Intent data) {
                    return handleActivityResult(
                            requestCode,
                            resultCode,
                            data,
                            getShareResultProcessor(callback));
                }
            });
}
 

private UploadContext(
        ShareVideoContent videoContent,
        String graphNode,
        FacebookCallback<Sharer.Result> callback) {
    // Store off the access token right away so that under no circumstances will we
    // end up with different tokens between phases. We will rely on the access token tracker
    // to cancel pending uploads.
    this.accessToken = AccessToken.getCurrentAccessToken();
    this.videoUri = videoContent.getVideo().getLocalUrl();
    this.title = videoContent.getContentTitle();
    this.description = videoContent.getContentDescription();
    this.ref = videoContent.getRef();
    this.graphNode = graphNode;
    this.callback = callback;
    this.params = videoContent.getVideo().getParameters();
}
 

public static synchronized void uploadAsync(
        ShareVideoContent videoContent,
        String graphNode,
        FacebookCallback<Sharer.Result> callback)
        throws FileNotFoundException {
    if (!initialized) {
        registerAccessTokenTracker();
        initialized = true;
    }

    Validate.notNull(videoContent, "videoContent");
    Validate.notNull(graphNode, "graphNode");
    ShareVideo video = videoContent.getVideo();
    Validate.notNull(video, "videoContent.video");
    Uri videoUri = video.getLocalUrl();
    Validate.notNull(videoUri, "videoContent.video.localUrl");

    UploadContext uploadContext = new UploadContext(videoContent, graphNode, callback);
    uploadContext.initialize();

    pendingUploads.add(uploadContext);

    enqueueUploadStart(
            uploadContext,
            0);
}
 

private void facebookShareLink(String quote, String url) {
    final Uri uri = Uri.parse(url);
    final ShareLinkContent content = new ShareLinkContent.Builder().setContentUrl(uri).setQuote(quote).build();
    final ShareDialog shareDialog = new ShareDialog(activity);
    shareDialog.registerCallback(callbackManager, new FacebookCallback<Sharer.Result>() {
        @Override
        public void onSuccess(Sharer.Result result) {
            channel.invokeMethod("onSuccess", null);
            Log.d("SocialSharePlugin", "Sharing successfully done.");
        }

        @Override
        public void onCancel() {
            channel.invokeMethod("onCancel", null);
            Log.d("SocialSharePlugin", "Sharing cancelled.");
        }

        @Override
        public void onError(FacebookException error) {
            channel.invokeMethod("onError", error.getMessage());
            Log.d("SocialSharePlugin", "Sharing error occurred.");
        }
    });

    if (ShareDialog.canShow(ShareLinkContent.class)) {
        shareDialog.show(content);
    }
}
 

@Nullable
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    View view = inflater.inflate(getLayoutId(), null);
    ButterKnife.bind(this, view);
    shareDialog = new ShareDialog(this);
    CallbackManager callbackManager = CallbackManager.Factory.create();
    shareDialog.registerCallback(callbackManager, new FacebookCallback<Sharer.Result>() {
        @Override
        public void onSuccess(Sharer.Result result) {

        }

        @Override
        public void onCancel() {

        }

        @Override
        public void onError(FacebookException error) {
            TextToast.shortShow(getString(R.string.share_fail));
        }
    });
    pager.setOnPageChangeListener(this);
    pager.setOnRefreshListener(new PullToRefreshBase.OnRefreshListener<ViewPager>() {
        @Override
        public void onRefresh(PullToRefreshBase<ViewPager> refreshView) {
            refresh();
        }
    });
    adapter = new FragmentAdapter(getChildFragmentManager(), new ArrayList<AbsBaseFragment>());
    pager.setAdapter(adapter);
    init();
    instance=this;
    return view;
}
 

/**
 * Share content on facebook wall
 *
 * @param activity the activity
 * @param callback the callback to receive a result of this share
 * @param url      the url you wish to share
 * @param quote    the text you wish to associate with the url shared
 */
private void shareLinkOnFacebook(@NonNull final Activity activity, @NonNull final FacebookShareResultCallback callback, @NonNull String url, @Nullable String quote) {
    ShareDialog shareDialog = new ShareDialog(activity);

    shareDialog.registerCallback(mCallbackManager, new FacebookCallback<Sharer.Result>() {
        @Override
        public void onSuccess(Sharer.Result result) {
            callback.onFacebookShareSuccess(result);
        }

        @Override
        public void onCancel() {
            callback.onFacebookShareCancel();
        }

        @Override
        public void onError(FacebookException error) {
            callback.onFacebookShareError(error);
        }
    }, RC_FACEBOOK_SHARE);


    if (ShareDialog.canShow(ShareLinkContent.class)) {
        ShareLinkContent linkContent = new ShareLinkContent.Builder().setContentUrl(Uri.parse(url))
                .setQuote(quote)
                .build();
        shareDialog.show(linkContent);
    } else {
        callback.onFacebookShareCannotShowDialog();
    }
}
 

@Override
protected FacebookDialogBase<ShareContent, Sharer.Result> getDialog() {
    final MessageDialog dialog;
    if (SendButton.this.getFragment() != null) {
        dialog = new MessageDialog(SendButton.this.getFragment() , getRequestCode());
    } else {
        dialog = new MessageDialog(getActivity(), getRequestCode());
    }
    return dialog;
}
 

@Override
protected FacebookDialogBase<ShareContent, Sharer.Result> getDialog() {
    final ShareDialog dialog;
    if (ShareButton.this.getFragment() != null) {
        dialog = new ShareDialog(ShareButton.this.getFragment() , getRequestCode());
    } else {
        dialog = new ShareDialog(getActivity(), getRequestCode());
    }
    return dialog;
}
 

static void invokeOnErrorCallback(
        FacebookCallback<Sharer.Result> callback,
        FacebookException ex) {
    logShareResult(AnalyticsEvents.PARAMETER_SHARE_OUTCOME_ERROR, ex.getMessage());
    if (callback != null) {
        callback.onError(ex);
    }
}
 

static void invokeOnErrorCallback(
        FacebookCallback<Sharer.Result> callback,
        String message) {
    logShareResult(AnalyticsEvents.PARAMETER_SHARE_OUTCOME_ERROR, message);
    if (callback != null) {
        callback.onError(new FacebookException(message));
    }
}
 

static void invokeOnErrorCallback(
        FacebookCallback<Sharer.Result> callback,
        GraphResponse response,
        String message) {
    logShareResult(AnalyticsEvents.PARAMETER_SHARE_OUTCOME_ERROR, message);
    if (callback != null) {
        callback.onError(new FacebookGraphResponseException(response, message));
    }
}
 

static void invokeOnSuccessCallback(
        FacebookCallback<Sharer.Result> callback,
        String postId) {
    logShareResult(AnalyticsEvents.PARAMETER_SHARE_OUTCOME_SUCCEEDED, null);
    if (callback != null) {
        callback.onSuccess(new Sharer.Result(postId));
    }
}
 

public static void invokeCallbackWithResults(
        FacebookCallback<Sharer.Result> callback,
        final String postId,
        final GraphResponse graphResponse) {
    FacebookRequestError requestError = graphResponse.getError();
    if (requestError != null) {
        String errorMessage = requestError.getErrorMessage();
        if (Utility.isNullOrEmpty(errorMessage)) {
            errorMessage = "Unexpected error sharing.";
        }
        invokeOnErrorCallback(callback, graphResponse, errorMessage);
    } else {
        invokeOnSuccessCallback(callback, postId);
    }
}
 

public static void invokeCallbackWithException(
        FacebookCallback<Sharer.Result> callback,
        final Exception exception) {
    if (exception instanceof FacebookException) {
        invokeOnErrorCallback(callback, (FacebookException) exception);
        return;
    }
    invokeCallbackWithError(
            callback,
            "Error preparing share content: " + exception.getLocalizedMessage());
}
 

private void facebookShare(String caption, String mediaPath) {
    final File media = new File(mediaPath);
    final Uri uri = FileProvider.getUriForFile(activity, activity.getPackageName() + ".social.share.fileprovider",
            media);
    final SharePhoto photo = new SharePhoto.Builder().setImageUrl(uri).setCaption(caption).build();
    final SharePhotoContent content = new SharePhotoContent.Builder().addPhoto(photo).build();
    final ShareDialog shareDialog = new ShareDialog(activity);
    shareDialog.registerCallback(callbackManager, new FacebookCallback<Sharer.Result>() {
        @Override
        public void onSuccess(Sharer.Result result) {
            channel.invokeMethod("onSuccess", null);
            Log.d("SocialSharePlugin", "Sharing successfully done.");
        }

        @Override
        public void onCancel() {
            channel.invokeMethod("onCancel", null);
            Log.d("SocialSharePlugin", "Sharing cancelled.");
        }

        @Override
        public void onError(FacebookException error) {
            channel.invokeMethod("onError", error.getMessage());
            Log.d("SocialSharePlugin", "Sharing error occurred.");
        }
    });

    if (ShareDialog.canShow(SharePhotoContent.class)) {
        shareDialog.show(content);
    }
}
 

public static synchronized void uploadAsync(
        ShareVideoContent videoContent,
        FacebookCallback<Sharer.Result> callback)
        throws FileNotFoundException {
    uploadAsync(videoContent, "me", callback);
}
 

static void invokeOnCancelCallback(FacebookCallback<Sharer.Result> callback) {
    logShareResult(AnalyticsEvents.PARAMETER_SHARE_OUTCOME_CANCELLED, null);
    if (callback != null) {
        callback.onCancel();
    }
}
 

public static void invokeCallbackWithError(
        FacebookCallback<Sharer.Result> callback,
        String error) {
    invokeOnErrorCallback(callback, error);
}
 

/**
 * Allows registration of a callback for when the share completes. This should be called
 * in the {@link android.app.Activity#onCreate(android.os.Bundle)} or
 * {@link android.support.v4.app.Fragment#onCreate(android.os.Bundle)} methods.
 *
 * @param callbackManager The {@link com.facebook.CallbackManager} instance that will be
 *                        handling results that are received via
 *                        {@link android.app.Activity#onActivityResult(int, int, android.content.Intent)}
 * @param callback The callback that should be called to handle dialog completion.
 * @param requestCode  The request code to use, this should be outside of the range of those
 *                     reserved for the Facebook SDK
 *                     {@link com.facebook.FacebookSdk#isFacebookRequestCode(int)}.
 */
public void registerCallback(
        final CallbackManager callbackManager,
        final FacebookCallback<Sharer.Result> callback,
        final int requestCode) {
    setRequestCode(requestCode);
    registerCallback(callbackManager, callback);
}
 

/**
 * Allows registration of a callback for when the share completes. This should be called
 * in the {@link android.app.Activity#onCreate(android.os.Bundle)} or
 * {@link android.support.v4.app.Fragment#onCreate(android.os.Bundle)} methods.
 *
 * @param callbackManager The {@link com.facebook.CallbackManager} instance that will be
 *                        handling results that are received via
 *                        {@link android.app.Activity#onActivityResult(int, int, android.content.Intent)}
 * @param callback The callback that should be called to handle dialog completion.
 */
public void registerCallback(
        final CallbackManager callbackManager,
        final FacebookCallback<Sharer.Result> callback) {
    ShareInternalUtility.registerSharerCallback(getRequestCode(), callbackManager, callback);
}
 

abstract protected FacebookDialogBase<ShareContent, Sharer.Result> getDialog(); 

void onFacebookShareSuccess(Sharer.Result result);