android - tutorial - iniciar sesion con facebook api

Android-Facebook SDK 3-Cómo iniciar sesión mediante programación sin LoginButton

Question

Estoy escribiendo una aplicación que se integra con Facebook SDK, para compartir algo (cadena) de contenido como publicación de pared. Ahora hice el trabajo HelloFacebookSample. Sin embargo, utiliza su LoginButton para iniciar sesión en el usuario.

No quiero eso. Todo lo que quiero hacer es hacer clic en el botón Compartir en la barra de acciones y compartirlo en Facebook. Por lo tanto, quiero iniciar sesión programáticamente, traté de emular lo que hace el LoginButton pero hasta ahora no ha tenido éxito. yo obtengo

12-06 15: 34: 33.180: E / AndroidRuntime (19493): java.lang.UnsupportedOperationException: Session: se intentó volver a autorizar una sesión que tiene una solicitud pendiente.

la clase pública MainActivity extends FacebookActivity {

@SuppressWarnings("serial")
private static final List<String> PERMISSIONS = new ArrayList<String>() {
{
add("publish_actions");
}
};
private final int REAUTHORIZE_ACTIVITY = 3;
private Button postStatusUpdateButton;
private PendingAction pendingAction = PendingAction.NONE;
private enum PendingAction {
NONE, POST_PHOTO, POST_STATUS_UPDATE
}
/**
* Called when the activity is first created.
*/
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
postStatusUpdateButton = (Button) findViewById(R.id.postStatusUpdateButton);
postStatusUpdateButton.setOnClickListener(new View.OnClickListener() {
public void onClick(View view) {
Log.d("MainActivity", "onClick");
onClickPostStatusUpdate();
}
});
}
@Override
protected void onSessionStateChange(SessionState state, Exception exception) {
super.onSessionStateChange(state, exception);
}
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();
}
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle(title).setMessage(alertMessage).setPositiveButton(getString(R.string.ok), null);
builder.show();
}
private void onClickPostStatusUpdate() {
Log.d("MainActivity", "onClickPostStatusUpdate");
performPublish(PendingAction.POST_STATUS_UPDATE);
}
private boolean hasPublishPermission() {
Session session = Session.getActiveSession();
return session != null && session.getPermissions().contains("publish_actions");
}
private void performPublish(PendingAction action) {
Log.d("MainActivity", "peformPublish");
Session session = Session.getActiveSession();
if (session == null) {
session = new Session.Builder(this).setApplicationId("xxx").build();
Session.setActiveSession(session);
}
if (!session.isOpened()) {
Session.OpenRequest openRequest = new Session.OpenRequest(this);
openRequest.setPermissions(PERMISSIONS);
openRequest.setLoginBehavior(SessionLoginBehavior.SSO_WITH_FALLBACK);
session.openForPublish(openRequest);
}
if (session != null) {
// postStatusUpdate();
pendingAction = action;
if (hasPublishPermission()) {
// We can do the action right away.
handlePendingAction();
// postStatusUpdate();
} else {
// We need to reauthorize, then complete the action when we get
// called back.
Session.ReauthorizeRequest reauthRequest = new Session.ReauthorizeRequest(this, PERMISSIONS)
.setRequestCode(REAUTHORIZE_ACTIVITY).setLoginBehavior(SessionLoginBehavior.SSO_WITH_FALLBACK);
session.reauthorizeForPublish(reauthRequest);
}
}
}
@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_STATUS_UPDATE:
postStatusUpdate();
break;
}
}
private void postStatusUpdate() {
// if (user != null && hasPublishPermission()) {
if (hasPublishPermission()) {
// final String message = getString(R.string.status_update,
// user.getFirstName(), (new Date().toString()));
final String message = "kks uz nemam nervy";
Request request = Request.newStatusUpdateRequest(Session.getActiveSession(), message,
new Request.Callback() {
@Override
public void onCompleted(Response response) {
showPublishResult(message, response.getGraphObject(), response.getError());
}
});
Request.executeBatchAsync(request);
} else {
pendingAction = PendingAction.POST_STATUS_UPDATE;
}
}
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
Log.d("MainActivity", "onActivityResult");
Session.getActiveSession().onActivityResult(this, requestCode, resultCode, data);
}

}

Bueno, este sigue siendo el proyecto HelloFacebookSample que intento doblar de la manera correcta. Lo único con lo que he jugado es con el método performPublish, con la creación de la sesión.

Espero que haya una manera más fácil de hacerlo! PD: estoy usando Facebook SDK 3

Answer 1

¿Es lo que publicaste toda tu actividad?

También debe sobrescribir OnActivityResult y pasar los valores a Session.getActiveSession (). OnActivityResult (...). De lo contrario, la sesión no sabrá que el usuario ha autorizado su aplicación, y es por eso que ve el error (Session piensa que todavía hay una solicitud de autorización pendiente, por lo que no puede volver a autorizar la publicación).

Answer 2

Dado que tenía la misma sensación que muchos aquí que votaron por el comentario de @ Beppi a la respuesta de @Ming Li, y como uso el SDK de Facebook en mis aplicaciones, decidí crear un nivel API más simplificado que esté basado en el último SDK de Facebook 3.0.b.

La biblioteca de código abierto: android-simple-facebook
https://github.com/sromku/android-simple-facebook

A su pregunta: How to login programatically?

1. Establecer oyente de inicio de sesión / cierre de sesión

   // set login / logout listener
   OnLoginOutListener onLoginOutListener = new SimpleFacebook.OnLoginOutListener()
   {
   @Override
   public void onFail()
   {
   Log.w(TAG, "Failed to login");
   }
   @Override
   public void onException(Throwable throwable)
   {
   Log.e(TAG, "Bad thing happened", throwable);
   }
   @Override
   public void onThinking()
   {
   // show progress bar or something to the user while login is happening
   Log.i(TAG, "In progress");
   }
   @Override
   public void onLogout()
   {
   // change the state of the button or do whatever you want
   Log.i(TAG, "Logged out");
   }
   @Override
   public void onLogin()
   {
   // change the state of the button or do whatever you want
   Log.i(TAG, "Logged in");
   }
   };
   // set the listener
   mSimpleFacebook.setLogInOutListener(onLoginOutListener);

2. Al hacer clic en cualquier vista, simplemente llame al método de login(Activity)

   mSimpleFacebook.login(MainActivity.this);

   
   

3. Para desconectar el método call logout() . Me gusta esto:

   mSimpleFacebook.logout();

Cómo establecer permisos antes de iniciar sesión, vea una explicación muy amigable here .

Espero que pueda ser útil a alguien :)

Answer 3

Gran pedazo de código, gracias.

Tenga en cuenta que con la versión v3 SDK, el código de reautorización debe reemplazarse por:

Session.NewPermissionsRequest reauthRequest = new Session.NewPermissionsRequest(FacebookActivity.this, PERMISSIONS)
.setRequestCode(REAUTHORIZE_ACTIVITY)
.setLoginBehavior(SessionLoginBehavior.SSO_WITH_FALLBACK);
session.requestNewPublishPermissions(reauthRequest);