android - buscar - google imagenes busqueda avanzada

StatusCallback no se llama después de requestNewReadPermissions y luego requestNewPublishPermissions

Question

Estoy desarrollando una aplicación de Android que se integra con Facebook. Me gustaría:

1. Deja que el usuario inicie sesión con Facebook
2. Obtenga la dirección de correo electrónico del usuario en Facebook (podría ser una dirección de correo electrónico proxy , lo cual está bien)
3. Publicar en la pared / línea de tiempo del usuario en su nombre

Técnicamente, eso sería:

1. Autenticar al usuario
2. Solicite el permiso de email
3. Solicitar el permiso publish_stream

1. Autenticar al usuario

Llamé a Session.openActiveSession() con un Session.StatusCallback (ya verifiqué que no hay una sesión abierta activa de antemano):

final Session.StatusCallback sessionStatusCallback = new Session.StatusCallback() {
    public void call(final Session session, SessionState state, Exception exception) {
        // If there is an exception...
        if(exception != null)
        {
            // Handle fail case here.
            return;
        }

        // If session is just opened...
        if(state == SessionState.OPENED)
        {
            // Handle success case here.
            return;
        }
    };
};

// Start Facebook Login.
Session.openActiveSession(activity, true, sessionStatusCallback);

Se llama a mi devolución de llamada después de iniciar sesión correctamente. Hasta ahora tan bueno.

2. Solicitar el permiso de email

Este es mi estado de devolución de llamada:

new Session.StatusCallback() {
    public void call(final Session session, SessionState state, Exception exception) {
        // If there is an exception...
        if(exception != null)
        {
            // Handle fail case here.
            return;
        }

        // If token is just updated...
        if(state == SessionState.OPENED_TOKEN_UPDATED)
        {
            // Handle success case here.
            return;
        }
    };
};

Solicito el permiso con Session.requestNewReadPermissions() :

final Session session = Session.getActiveSession();
final static String[] PERMISSION_ARRAY_READ = {"email"};
final List<String> permissionList = Arrays.asList(PERMISSION_ARRAY_READ);

// If all required permissions are available...
if(session.getPermissions().containsAll(permissionList))
{
    // Handle success case here.
    return;
}

// Request permissions.
session.requestNewReadPermissions(new Session.NewPermissionsRequest(activity, permissionList));

Se llama a mi devolución de llamada después de que se concede el permiso. Hasta ahora tan bueno.

3. Solicitar el permiso publish_stream

Este es mi estado de devolución de llamada:

new Session.StatusCallback() {
    public void call(final Session session, SessionState state, Exception exception) {
        // If there is an exception...
        if(exception != null)
        {
            // Handle fail case here.
            return;
        }

        // If token is just updated...
        if(state == SessionState.OPENED_TOKEN_UPDATED)
        {
            // Handle success case here.
            return;
        }
    };
};

Solicito el permiso con Session.requestNewPublishPermissions() :

final Session session = Session.getActiveSession();
final static String[] PERMISSION_ARRAY_PUBLISH = {"publish_stream"};
final List<String> permissionList = Arrays.asList(PERMISSION_ARRAY_PUBLISH);

// If all required permissions are available...
if(session.getPermissions().containsAll(permissionList))
{
    // Handle success case here.
    return;
}

// Request permissions.
session.requestNewPublishPermissions(new Session.NewPermissionsRequest(activity, permissionList));

Esta vez, no se llama a mi devolución de llamada después de conceder el permiso.

Investigación

Tras una investigación adicional, descubrí que mi devolución de llamada se activa con com.facebook.Session#postStateChange(SessionState, SessionState, Exception) :

void postStateChange(final SessionState oldState, final SessionState newState, final Exception exception) {
    if (oldState == newState && exception == null) {
        return;
    }

    /* ... */
}

Como oldState y newState son iguales (ambos son SessionState.OPENED_TOKEN_UPDATED , no se llama a mi devolución de llamada.

Pregunta

¿Cómo puedo recibir una notificación después de que se haya otorgado el permiso por segunda vez? ¿Se supone que debo close() la sesión y volver a abrirla desde el caché ?

información adicional

Mi Facebook Android SDK 3.0 se descarga desde here , que se indica en Cómo comenzar con el SDK de Facebook para Android de Facebook .

Answer 1

Código de trabajo basado en la respuesta del derecho.

Antes de solicitar permiso por segunda vez (es decir, antes de Session.requestNewPublishPermissions() ), haga esto:

// Re-initialize Facebook session.
session.removeCallback(sessionStatusCallback);          // Remove callback from old session.
session = Session.openActiveSessionFromCache(context);  // Create new session by re-opening from cache.
session.addCallback(sessionStatusCallback);             // Add callback to new session.

El código aún se basa en Facebook Android SDK 3.0, como en la pregunta.

Answer 2

Esto es un error.

[Editar: Como señala Guy en los comentarios, esto se solucionó en 3.0.1, por lo que esta solución ya no es necesaria]

La solución que usted menciona es básicamente correcta, aunque no necesita llamar a close. Si está utilizando la sesión activa única, antes de llamar a requestNewPublishPermissions () simplemente llame:

Session.openActiveSessionFromCache(myContext);

Si está utilizando varias sesiones, necesita inicializar una nueva sesión con TokenCachingStrategy, verificar que esté en el estado CREATED_TOKEN_LOADED y llamar a openForRead (null);

Después de hacer uno de estos, requestNewPublishPermissions () debe llamar a su notificación una vez que se complete.

Answer 3

Otra cosa que encontré fue que mi requestCode para NewPermissionRequest no se configuró en el mismo requestCode que usé para abrir mi Session for Read, por lo que mi Session.StatusCallback nunca fue invocado cuando se concedieron los nuevos permisos.

Por ejemplo, en mi onActivityResult tengo una verificación para el código de solicitud y delego la llamada en consecuencia porque tengo otras cosas relacionadas con este método.

public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
    if (requestCode == FACEBOOK_AUTH_RESULT_CODE) {
        Session session = Session.getActiveSession();
        if(session != null) {
            session.onActivityResult(activity, requestCode, resultCode, data);
        }
    }       
}

Entonces abrí mi Session con el siguiente código:

        Session.getActiveSession().openForRead(
            new Session.OpenRequest(activity).
                setLoginBehavior(SessionLoginBehavior.SSO_WITH_FALLBACK).
                setRequestCode(FACEBOOK_AUTH_RESULT_CODE).
                setPermissions(MY_READ_PERMISSIONS));

Entonces olvidé usar el mismo NewPermissionRequest al construir mi NewPermissionRequest .

Este es el NewPermissionRequest debe tener el NewPermissionRequest correcto:

        Session.getActiveSession().requestNewPublishPermissions(
            new NewPermissionsRequest(activity, MY_PUBLISH_PERMISSIONS)
                .setRequestCode(FACEBOOK_AUTH_RESULT_CODE));