Java FacebookDialog.Callback方法代碼示例

import com.facebook.widget.FacebookDialog; //導入方法依賴的package包/類
private void cancelPendingAppCall(FacebookDialog.Callback facebookDialogCallback) {
    if (facebookDialogCallback != null) {
        Intent pendingIntent = pendingFacebookDialogCall.getRequestIntent();

        Intent cancelIntent = new Intent();
        cancelIntent.putExtra(NativeProtocol.EXTRA_PROTOCOL_CALL_ID,
                pendingIntent.getStringExtra(NativeProtocol.EXTRA_PROTOCOL_CALL_ID));
        cancelIntent.putExtra(NativeProtocol.EXTRA_PROTOCOL_ACTION,
                pendingIntent.getStringExtra(NativeProtocol.EXTRA_PROTOCOL_ACTION));
        cancelIntent.putExtra(NativeProtocol.EXTRA_PROTOCOL_VERSION,
                pendingIntent.getIntExtra(NativeProtocol.EXTRA_PROTOCOL_VERSION, 0));
        cancelIntent.putExtra(NativeProtocol.STATUS_ERROR_TYPE, NativeProtocol.ERROR_UNKNOWN_ERROR);

        FacebookDialog.handleActivityResult(activity, pendingFacebookDialogCall,
                pendingFacebookDialogCall.getRequestCode(), cancelIntent, facebookDialogCallback);
    }
    pendingFacebookDialogCall = null;
}
 

import com.facebook.widget.FacebookDialog; //導入方法依賴的package包/類
private boolean handleFacebookDialogActivityResult(int paramInt1, int paramInt2, Intent paramIntent, FacebookDialog.Callback paramCallback)
{
  if ((this.pendingFacebookDialogCall == null) || (this.pendingFacebookDialogCall.getRequestCode() != paramInt1))
    return false;
  if (paramIntent == null)
  {
    cancelPendingAppCall(paramCallback);
    return true;
  }
  String str = paramIntent.getStringExtra("com.facebook.platform.protocol.CALL_ID");
  UUID localUUID = null;
  if (str != null);
  try
  {
    localUUID = UUID.fromString(str);
  }
  catch (IllegalArgumentException localIllegalArgumentException)
  {
  }
  if ((localUUID != null) && (this.pendingFacebookDialogCall.getCallId().equals(localUUID)))
    FacebookDialog.handleActivityResult(this.activity, this.pendingFacebookDialogCall, paramInt1, paramIntent, paramCallback);
  else
    cancelPendingAppCall(paramCallback);
  this.pendingFacebookDialogCall = null;
  return true;
}
 

import com.facebook.widget.FacebookDialog; //導入方法依賴的package包/類
/**
 * To be called from an Activity or Fragment's onActivityResult method, when the results of a FacebookDialog
 * call are expected.
 *
 * @param requestCode the request code
 * @param resultCode the result code
 * @param data the result data
 * @param dialogCallback the callback for handling FacebookDialog results, can be null
 */
public void onActivityResult(int requestCode, int resultCode, Intent data,
            FacebookDialog.Callback facebookDialogCallback) {
    Session session = Session.getActiveSession();
    if (session != null) {
        session.onActivityResult(activity, requestCode, resultCode, data);
    }

    handleFacebookDialogActivityResult(requestCode, resultCode, data, facebookDialogCallback);
}
 

import com.facebook.widget.FacebookDialog; //導入方法依賴的package包/類
private boolean handleFacebookDialogActivityResult(int requestCode, int resultCode, Intent data,
        FacebookDialog.Callback facebookDialogCallback) {
    if (pendingFacebookDialogCall == null || pendingFacebookDialogCall.getRequestCode() != requestCode) {
        return false;
    }

    if (data == null) {
        // We understand the request code, but have no Intent. This can happen if the called Activity crashes
        // before it can be started; we treat this as a cancellation because we have no other information.
        cancelPendingAppCall(facebookDialogCallback);
        return true;
    }

    String callIdString = data.getStringExtra(NativeProtocol.EXTRA_PROTOCOL_CALL_ID);
    UUID callId = null;
    if (callIdString != null) {
        try {
            callId = UUID.fromString(callIdString);
        } catch (IllegalArgumentException exception) {
        }
    }

    // Was this result for the call we are waiting on?
    if (callId != null && pendingFacebookDialogCall.getCallId().equals(callId)) {
        // Yes, we can handle it normally.
        FacebookDialog.handleActivityResult(activity, pendingFacebookDialogCall, requestCode, data,
                facebookDialogCallback);
    } else {
        // No, send a cancellation error to the pending call and ignore the result, because we
        // don't know what to do with it.
        cancelPendingAppCall(facebookDialogCallback);
    }

    pendingFacebookDialogCall = null;
    return true;
}
 

import com.facebook.widget.FacebookDialog; //導入方法依賴的package包/類
public static boolean presentWebFallback(final Context context,
                                         String dialogUrl,
                                         String applicationId,
                                         final FacebookDialog.PendingCall appCall,
                                         final FacebookDialog.Callback callback) {
    if (Utility.isNullOrEmpty(dialogUrl)) {
        return false;
    }

    String redirectUrl = String.format("fb%s://bridge/", applicationId);

    // Show the webdialog.
    FacebookWebFallbackDialog fallbackWebDialog = new FacebookWebFallbackDialog(
            context, dialogUrl, redirectUrl);
    fallbackWebDialog.setOnCompleteListener(new WebDialog.OnCompleteListener() {
        @Override
        public void onComplete(Bundle values, FacebookException error) {
            Intent dummyIntent = new Intent();
            dummyIntent.putExtras(values == null ? new Bundle() : values);
            FacebookDialog.handleActivityResult(
                    context,
                    appCall,
                    appCall.getRequestCode(),
                    dummyIntent,
                    callback);
        }
    });

    fallbackWebDialog.show();
    return true;
}
 

import com.facebook.widget.FacebookDialog; //導入方法依賴的package包/類
/**
 * To be called from an Activity or Fragment's onActivityResult method, when the results of a FacebookDialog
 * call are expected.
 *
 * @param requestCode the request code
 * @param resultCode the result code
 * @param data the result data
 * @param facebookDialogCallback the callback for handling FacebookDialog results, can be null
 */
public void onActivityResult(int requestCode, int resultCode, Intent data,
            FacebookDialog.Callback facebookDialogCallback) {
    Session session = Session.getActiveSession();
    if (session != null) {
        session.onActivityResult(activity, requestCode, resultCode, data);
    }

    if (LikeActionController.handleOnActivityResult(activity, requestCode, resultCode, data)) {
        return;
    }

    handleFacebookDialogActivityResult(requestCode, resultCode, data, facebookDialogCallback);
}
 

import com.facebook.widget.FacebookDialog; //導入方法依賴的package包/類
private boolean handleFacebookDialogActivityResult(int requestCode, int resultCode, Intent data,
        FacebookDialog.Callback facebookDialogCallback) {
    if (pendingFacebookDialogCallId == null) {
        return false;
    }
    FacebookDialog.PendingCall pendingCall =
            pendingFacebookDialogCallStore.getPendingCallById(pendingFacebookDialogCallId);
    if (pendingCall == null || pendingCall.getRequestCode() != requestCode) {
        return false;
    }

    if (data == null) {
        // We understand the request code, but have no Intent. This can happen if the called Activity crashes
        // before it can be started; we treat this as a cancellation because we have no other information.
        cancelPendingAppCall(facebookDialogCallback);
        return true;
    }

    UUID callId = NativeProtocol.getCallIdFromIntent(data);

    // Was this result for the call we are waiting on?
    if (callId != null && pendingFacebookDialogCallId.equals(callId)) {
        // Yes, we can handle it normally.
        FacebookDialog.handleActivityResult(activity, pendingCall, requestCode, data,
                facebookDialogCallback);
    } else {
        // No, send a cancellation error to the pending call and ignore the result, because we
        // don't know what to do with it.
        cancelPendingAppCall(facebookDialogCallback);
    }

    stopTrackingPendingAppCall();
    return true;
}
 

import com.facebook.widget.FacebookDialog; //導入方法依賴的package包/類
private void cancelPendingAppCall(FacebookDialog.Callback facebookDialogCallback) {
    if (pendingFacebookDialogCallId == null) {
        return;
    }

    FacebookDialog.PendingCall pendingCall =
            pendingFacebookDialogCallStore.getPendingCallById(pendingFacebookDialogCallId);
    if (pendingCall == null) {
        return;
    }

    if (facebookDialogCallback != null) {
        Intent pendingIntent = pendingCall.getRequestIntent();

        Intent cancelIntent = new Intent();
        cancelIntent.putExtra(NativeProtocol.EXTRA_PROTOCOL_CALL_ID,
                pendingIntent.getStringExtra(NativeProtocol.EXTRA_PROTOCOL_CALL_ID));
        cancelIntent.putExtra(NativeProtocol.EXTRA_PROTOCOL_ACTION,
                pendingIntent.getStringExtra(NativeProtocol.EXTRA_PROTOCOL_ACTION));
        cancelIntent.putExtra(NativeProtocol.EXTRA_PROTOCOL_VERSION,
                pendingIntent.getIntExtra(NativeProtocol.EXTRA_PROTOCOL_VERSION, 0));
        cancelIntent.putExtra(NativeProtocol.STATUS_ERROR_TYPE, NativeProtocol.ERROR_UNKNOWN_ERROR);

        FacebookDialog.handleActivityResult(activity, pendingCall,
                pendingCall.getRequestCode(), cancelIntent, facebookDialogCallback);
    }

    stopTrackingPendingAppCall();
}
 

import com.facebook.widget.FacebookDialog; //導入方法依賴的package包/類
private void cancelPendingAppCall(FacebookDialog.Callback paramCallback)
{
  if (paramCallback != null)
  {
    Intent localIntent1 = this.pendingFacebookDialogCall.getRequestIntent();
    Intent localIntent2 = new Intent();
    localIntent2.putExtra("com.facebook.platform.protocol.CALL_ID", localIntent1.getStringExtra("com.facebook.platform.protocol.CALL_ID"));
    localIntent2.putExtra("com.facebook.platform.protocol.PROTOCOL_ACTION", localIntent1.getStringExtra("com.facebook.platform.protocol.PROTOCOL_ACTION"));
    localIntent2.putExtra("com.facebook.platform.protocol.PROTOCOL_VERSION", localIntent1.getIntExtra("com.facebook.platform.protocol.PROTOCOL_VERSION", 0));
    localIntent2.putExtra("com.facebook.platform.status.ERROR_TYPE", "UnknownError");
    FacebookDialog.handleActivityResult(this.activity, this.pendingFacebookDialogCall, this.pendingFacebookDialogCall.getRequestCode(), localIntent2, paramCallback);
  }
  this.pendingFacebookDialogCall = null;
}
 

import com.facebook.widget.FacebookDialog; //導入方法依賴的package包/類
public Facebook initialize(Activity activity) {
    this.activity = activity;
    sessionSubject = PublishSubject.create();
    sessionStatusCallback = new Session.StatusCallback() {
        @Override
        public void call(Session session, SessionState state, Exception exception) {
            if (exception != null) {
                sessionSubject.onError(exception);
            } else {
                sessionSubject.onNext(session);
            }
        }
    };

    dialogSubject = PublishSubject.create();
    dialogCallback = new FacebookDialog.Callback() {
        @Override
        public void onError(PendingCall pendingCall, Exception error, Bundle data) {
            Log.d("RetroFacebook", "dialogCallback.onError: " + pendingCall);
            Log.d("RetroFacebook", "dialogCallback.onError: " + error);
            error.printStackTrace();
            //Subject<Bundle, Bundle> sub = dialogSubs.get(pendingCall.getCallId());
            Subject<Bundle, Bundle> sub = dialogSubject;
            if (sub != null) {
                sub.onError(error);
                dialogSubs.remove(pendingCall.getCallId());
            }
        }

        @Override
        public void onComplete(PendingCall pendingCall, Bundle data) {
            Log.d("RetroFacebook", "dialogCallback.onComplete: " + pendingCall);
            //Subject<Bundle, Bundle> sub = dialogSubs.get(pendingCall.getCallId());
            Subject<Bundle, Bundle> sub = dialogSubject;
            if (sub != null) {
                sub.onNext(data);
                //sub.onCompleted();
                dialogSubs.remove(pendingCall.getCallId());
            }
            /*
            boolean didComplete = FacebookDialog.getNativeDialogDidComplete(data);
            String postId = FacebookDialog.getNativeDialogPostId(data);
            String completeGesture = FacebookDialog.getNativeDialogCompletionGesture(data);
            if (completeGesture != null) {
                if (completeGesture.equals("post")) {
                    mOnPublishListener.onComplete(postId != null ? postId : "no postId return");
                } else {
                    mOnPublishListener.onFail("Canceled by user");
                }
            } else if (didComplete) {
                mOnPublishListener.onComplete(postId != null ? postId : "published successfully. (post id is not availaible if you are not logged in)");
            } else {
                mOnPublishListener.onFail("Canceled by user");
            }
            */
        }
    };

    uiLifecycleHelper = new UiLifecycleHelper(activity, sessionStatusCallback);

    return this;
}
 

import com.facebook.widget.FacebookDialog; //導入方法依賴的package包/類
void onActivityResult(int requestCode, int resultCode, Intent data, FacebookDialog.Callback callback);