0

我正在创建一个应用程序，该应用程序从用户那里获取一些文本输入并将其发布到 usr 的墙上我正在使用以下代码发布文本

   private void post_to_wall(String user_text) {
    // TODO Auto-generated method stub
    Log.d("post to wall", user_text);
    try{
        String response = facebook.request("me");
         Bundle parameters = new Bundle();
         parameters.putString("message", user_text);
         parameters.putString("description", "test test test");
         response = facebook.request("me/feed", parameters, "POST");
         Log.d("Tests", "got response: " + response);
         if (response == null || response.equals("") || 
                 response.equals("false")) {
            Log.v("Error", "Blank response");
         }

    }catch(Exception e) {
        e.printStackTrace();
    }
  }

运行此代码后没有任何反应。没有发生错误。请告诉我如何检查用户是否已登录。基本上，如果用户已登录 fb 应用程序，我想做什么然后允许他发布文本，否则告诉他先登录。谢谢

4

2 回答 2

0

看publishStory样品的方法。

https://developers.facebook.com/docs/android/publish-to-feed/

他们使用HTTPPost和RequestAsyncTask。解析响应的回调，并将 id 显示为 toast 以确认发布成功

例子：

private void publishStory(String user_text) {
    Session session = Session.getActiveSession();

    if (session != null){

        // Check for publish permissions    
        List<String> permissions = session.getPermissions();
        if (!isSubsetOf(PERMISSIONS, permissions)) {
            pendingPublishReauthorization = true;
            Session.NewPermissionsRequest newPermissionsRequest = new Session
                    .NewPermissionsRequest(this, PERMISSIONS);
        session.requestNewPublishPermissions(newPermissionsRequest);
            return;
        }

        Bundle postParams = new Bundle();
        postParams.putString("message", user_text);
            postParams.parameters.putString("description", "test test test");

        Request.Callback callback= new Request.Callback() {
            public void onCompleted(Response response) {
                JSONObject graphResponse = response
                                           .getGraphObject()
                                           .getInnerJSONObject();
                String postId = null;
                try {
                    postId = graphResponse.getString("id");
                } catch (JSONException e) {
                    Log.i(TAG,
                        "JSON error "+ e.getMessage());
                }
                FacebookRequestError error = response.getError();
                if (error != null) {
                    Toast.makeText(getActivity()
                         .getApplicationContext(),
                         error.getErrorMessage(),
                         Toast.LENGTH_SHORT).show();
                    } else {
                        Toast.makeText(getActivity()
                             .getApplicationContext(), 
                             postId,
                             Toast.LENGTH_LONG).show();
                }
            }
        };

        Request request = new Request(session, "me/feed", postParams, 
                              HttpMethod.POST, callback);

        RequestAsyncTask task = new RequestAsyncTask(request);
        task.execute();
    }
}

编辑：

检查 facebook 登录示例

https://developers.facebook.com/docs/android/login-with-facebook/

发布示例的先决条件是登录 facebook。

于 2013-10-18T09:18:57.410 回答
0

尝试这个 ：

    public class HelloFacebookSampleActivity extends FragmentActivity {

private static final String PERMISSION = "publish_actions";
private static final Location SEATTLE_LOCATION = new Location("") {
    {
        setLatitude(47.6097);
        setLongitude(-122.3331);
    }
};

private final String PENDING_ACTION_BUNDLE_KEY = "com.facebook.samples.hellofacebook:PendingAction";

private Button postStatusUpdateButton;
private Button postPhotoButton;
private Button pickFriendsButton;
private Button pickPlaceButton;
private LoginButton loginButton;
private ProfilePictureView profilePictureView;
private TextView greeting;
private PendingAction pendingAction = PendingAction.NONE;
private ViewGroup controlsContainer;
private GraphUser user;
private GraphPlace place;
private List<GraphUser> tags;
private boolean canPresentShareDialog;

private enum PendingAction {
    NONE, POST_PHOTO, POST_STATUS_UPDATE
}

private UiLifecycleHelper uiHelper;

private Session.StatusCallback callback = new Session.StatusCallback() {
    @Override
    public void call(Session session, SessionState state,
            Exception exception) {
        onSessionStateChange(session, state, exception);
    }
};

private FacebookDialog.Callback dialogCallback = new FacebookDialog.Callback() {
    @Override
    public void onError(FacebookDialog.PendingCall pendingCall,
            Exception error, Bundle data) {
        Log.d("HelloFacebook", String.format("Error: %s", error.toString()));
    }

    @Override
    public void onComplete(FacebookDialog.PendingCall pendingCall,
            Bundle data) {
        Log.d("HelloFacebook", "Success!");
    }
};

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    uiHelper = new UiLifecycleHelper(this, callback);
    uiHelper.onCreate(savedInstanceState);

    if (savedInstanceState != null) {
        String name = savedInstanceState
                .getString(PENDING_ACTION_BUNDLE_KEY);
        pendingAction = PendingAction.valueOf(name);
    }

    setContentView(R.layout.main);

    loginButton = (LoginButton) findViewById(R.id.login_button);
    loginButton
            .setUserInfoChangedCallback(new LoginButton.UserInfoChangedCallback() {
                @Override
                public void onUserInfoFetched(GraphUser user) {
                    HelloFacebookSampleActivity.this.user = user;
                    updateUI();
                    // It's possible that we were waiting for this.user to
                    // be populated in order to post a
                    // status update.
                    handlePendingAction();
                }
            });

    profilePictureView = (ProfilePictureView) findViewById(R.id.profilePicture);
    greeting = (TextView) findViewById(R.id.greeting);

    postStatusUpdateButton = (Button) findViewById(R.id.postStatusUpdateButton);
    postStatusUpdateButton.setOnClickListener(new View.OnClickListener() {
        public void onClick(View view) {
            onClickPostStatusUpdate();
        }
    });

    postPhotoButton = (Button) findViewById(R.id.postPhotoButton);
    postPhotoButton.setOnClickListener(new View.OnClickListener() {
        public void onClick(View view) {
            onClickPostPhoto();
        }
    });

    pickFriendsButton = (Button) findViewById(R.id.pickFriendsButton);
    pickFriendsButton.setOnClickListener(new View.OnClickListener() {
        public void onClick(View view) {
            onClickPickFriends();
        }
    });

    pickPlaceButton = (Button) findViewById(R.id.pickPlaceButton);
    pickPlaceButton.setOnClickListener(new View.OnClickListener() {
        public void onClick(View view) {
            onClickPickPlace();
        }
    });

    controlsContainer = (ViewGroup) findViewById(R.id.main_ui_container);

    final FragmentManager fm = getSupportFragmentManager();
    Fragment fragment = fm.findFragmentById(R.id.fragment_container);
    if (fragment != null) {
        // If we're being re-created and have a fragment, we need to a) hide
        // the main UI controls and
        // b) hook up its listeners again.
        controlsContainer.setVisibility(View.GONE);
        if (fragment instanceof FriendPickerFragment) {
            setFriendPickerListeners((FriendPickerFragment) fragment);
        } else if (fragment instanceof PlacePickerFragment) {
            setPlacePickerListeners((PlacePickerFragment) fragment);
        }
    }

    // Listen for changes in the back stack so we know if a fragment got
    // popped off because the user
    // clicked the back button.
    fm.addOnBackStackChangedListener(new FragmentManager.OnBackStackChangedListener() {
        @Override
        public void onBackStackChanged() {
            if (fm.getBackStackEntryCount() == 0) {
                // We need to re-show our UI.
                controlsContainer.setVisibility(View.VISIBLE);
            }
        }
    });

    canPresentShareDialog = FacebookDialog.canPresentShareDialog(this,
            FacebookDialog.ShareDialogFeature.SHARE_DIALOG);
}

@Override
protected void onResume() {
    super.onResume();
    uiHelper.onResume();

    // Call the 'activateApp' method to log an app event for use in
    // analytics and advertising reporting. Do so in
    // the onResume methods of the primary Activities that an app may be
    // launched into.
    AppEventsLogger.activateApp(this);

    updateUI();
}

@Override
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    uiHelper.onSaveInstanceState(outState);

    outState.putString(PENDING_ACTION_BUNDLE_KEY, pendingAction.name());
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    uiHelper.onActivityResult(requestCode, resultCode, data, dialogCallback);
}

@Override
public void onPause() {
    super.onPause();
    uiHelper.onPause();
}

@Override
public void onDestroy() {
    super.onDestroy();
    uiHelper.onDestroy();
}

private void onSessionStateChange(Session session, SessionState state,
        Exception exception) {
    if (pendingAction != PendingAction.NONE
            && (exception instanceof FacebookOperationCanceledException || exception instanceof FacebookAuthorizationException)) {
        new AlertDialog.Builder(HelloFacebookSampleActivity.this)
                .setTitle(R.string.cancelled)
                .setMessage(R.string.permission_not_granted)
                .setPositiveButton(R.string.ok, null).show();
        pendingAction = PendingAction.NONE;
    } else if (state == SessionState.OPENED_TOKEN_UPDATED) {
        handlePendingAction();
    }
    updateUI();
}

private void updateUI() {
    Session session = Session.getActiveSession();
    boolean enableButtons = (session != null && session.isOpened());

    postStatusUpdateButton.setEnabled(enableButtons
            || canPresentShareDialog);
    postPhotoButton.setEnabled(enableButtons);
    pickFriendsButton.setEnabled(enableButtons);
    pickPlaceButton.setEnabled(enableButtons);

    if (enableButtons && user != null) {
        profilePictureView.setProfileId(user.getId());
        greeting.setText(getString(R.string.hello_user, user.getFirstName()));
    } else {
        profilePictureView.setProfileId(null);
        greeting.setText(null);
    }
}

@SuppressWarnings("incomplete-switch")
private void handlePendingAction() {
    PendingAction previouslyPendingAction = pendingAction;
    // These actions may re-set pendingAction if they are still pending, but
    // we assume they
    // will succeed.
    pendingAction = PendingAction.NONE;

    switch (previouslyPendingAction) {
    case POST_PHOTO:
        postPhoto();
        break;
    case POST_STATUS_UPDATE:
        postStatusUpdate();
        break;
    }
}

private interface GraphObjectWithId extends GraphObject {
    String getId();
}

private void showPublishResult(String message, GraphObject result,
        FacebookRequestError error) {
    String title = null;
    String alertMessage = null;
    if (error == null) {
        title = getString(R.string.success);
        String id = result.cast(GraphObjectWithId.class).getId();
        alertMessage = getString(R.string.successfully_posted_post,
                message, id);
    } else {
        title = getString(R.string.error);
        alertMessage = error.getErrorMessage();
    }

    new AlertDialog.Builder(this).setTitle(title).setMessage(alertMessage)
            .setPositiveButton(R.string.ok, null).show();
}

private void onClickPostStatusUpdate() {
    performPublish(PendingAction.POST_STATUS_UPDATE, canPresentShareDialog);
}

private FacebookDialog.ShareDialogBuilder createShareDialogBuilder() {
    return new FacebookDialog.ShareDialogBuilder(this)
            .setName("Hello Facebook")
            .setDescription(
                    "The 'Hello Facebook' sample application showcases simple Facebook integration")
            .setLink("http://developers.facebook.com/android");
}

private void postStatusUpdate() {
    if (canPresentShareDialog) {
        FacebookDialog shareDialog = createShareDialogBuilder().build();
        uiHelper.trackPendingDialogCall(shareDialog.present());
    } else if (user != null && hasPublishPermission()) {
        final String message = getString(R.string.status_update,
                user.getFirstName(), (new Date().toString()));
        Request request = Request.newStatusUpdateRequest(
                Session.getActiveSession(), message, place, tags,
                new Request.Callback() {
                    @Override
                    public void onCompleted(Response response) {
                        showPublishResult(message,
                                response.getGraphObject(),
                                response.getError());
                    }
                });
        request.executeAsync();
    } else {
        pendingAction = PendingAction.POST_STATUS_UPDATE;
    }
}

private void onClickPostPhoto() {
    performPublish(PendingAction.POST_PHOTO, false);
}

private void postPhoto() {
    if (hasPublishPermission()) {
        Bitmap image = BitmapFactory.decodeResource(this.getResources(),
                R.drawable.icon);
        Request request = Request.newUploadPhotoRequest(
                Session.getActiveSession(), image, new Request.Callback() {
                    @Override
                    public void onCompleted(Response response) {
                        showPublishResult(getString(R.string.photo_post),
                                response.getGraphObject(),
                                response.getError());
                    }
                });
        request.executeAsync();
    } else {
        pendingAction = PendingAction.POST_PHOTO;
    }
}

private void showPickerFragment(PickerFragment<?> fragment) {
    fragment.setOnErrorListener(new PickerFragment.OnErrorListener() {
        @Override
        public void onError(PickerFragment<?> pickerFragment,
                FacebookException error) {
            String text = getString(R.string.exception, error.getMessage());
            Toast toast = Toast.makeText(HelloFacebookSampleActivity.this,
                    text, Toast.LENGTH_SHORT);
            toast.show();
        }
    });

    FragmentManager fm = getSupportFragmentManager();
    fm.beginTransaction().replace(R.id.fragment_container, fragment)
            .addToBackStack(null).commit();

    controlsContainer.setVisibility(View.GONE);

    // We want the fragment fully created so we can use it immediately.
    fm.executePendingTransactions();

    fragment.loadData(false);
}

private void onClickPickFriends() {
    final FriendPickerFragment fragment = new FriendPickerFragment();

    setFriendPickerListeners(fragment);

    showPickerFragment(fragment);
}

private void setFriendPickerListeners(final FriendPickerFragment fragment) {
    fragment.setOnDoneButtonClickedListener(new FriendPickerFragment.OnDoneButtonClickedListener() {
        @Override
        public void onDoneButtonClicked(PickerFragment<?> pickerFragment) {
            onFriendPickerDone(fragment);
        }
    });
}

private void onFriendPickerDone(FriendPickerFragment fragment) {
    FragmentManager fm = getSupportFragmentManager();
    fm.popBackStack();

    String results = "";

    List<GraphUser> selection = fragment.getSelection();
    tags = selection;
    if (selection != null && selection.size() > 0) {
        ArrayList<String> names = new ArrayList<String>();
        for (GraphUser user : selection) {
            names.add(user.getName());
        }
        results = TextUtils.join(", ", names);
    } else {
        results = getString(R.string.no_friends_selected);
    }

    showAlert(getString(R.string.you_picked), results);
}

private void onPlacePickerDone(PlacePickerFragment fragment) {
    FragmentManager fm = getSupportFragmentManager();
    fm.popBackStack();

    String result = "";

    GraphPlace selection = fragment.getSelection();
    if (selection != null) {
        result = selection.getName();
    } else {
        result = getString(R.string.no_place_selected);
    }

    place = selection;

    showAlert(getString(R.string.you_picked), result);
}

private void onClickPickPlace() {
    final PlacePickerFragment fragment = new PlacePickerFragment();
    fragment.setLocation(SEATTLE_LOCATION);
    fragment.setTitleText(getString(R.string.pick_seattle_place));

    setPlacePickerListeners(fragment);

    showPickerFragment(fragment);
}

private void setPlacePickerListeners(final PlacePickerFragment fragment) {
    fragment.setOnDoneButtonClickedListener(new PlacePickerFragment.OnDoneButtonClickedListener() {
        @Override
        public void onDoneButtonClicked(PickerFragment<?> pickerFragment) {
            onPlacePickerDone(fragment);
        }
    });
    fragment.setOnSelectionChangedListener(new PlacePickerFragment.OnSelectionChangedListener() {
        @Override
        public void onSelectionChanged(PickerFragment<?> pickerFragment) {
            if (fragment.getSelection() != null) {
                onPlacePickerDone(fragment);
            }
        }
    });
}

private void showAlert(String title, String message) {
    new AlertDialog.Builder(this).setTitle(title).setMessage(message)
            .setPositiveButton(R.string.ok, null).show();
}

private boolean hasPublishPermission() {
    Session session = Session.getActiveSession();
    return session != null
            && session.getPermissions().contains("publish_actions");
}

private void performPublish(PendingAction action, boolean allowNoSession) {
    Session session = Session.getActiveSession();
    if (session != null) {
        pendingAction = action;
        if (hasPublishPermission()) {
            // We can do the action right away.
            handlePendingAction();
            return;
        } else if (session.isOpened()) {
            // We need to get new permissions, then complete the action when
            // we get called back.
            session.requestNewPublishPermissions(new Session.NewPermissionsRequest(
                    this, PERMISSION));
            return;
        }
    }

    if (allowNoSession) {
        pendingAction = action;
        handlePendingAction();
    }
}
   }
于 2013-10-18T10:26:10.010 回答