wake-up-neo.com

StatusCallback wird nicht nach requestNewReadPermissions aufgerufen, dann requestNewPublishPermissions

Ich entwickle eine Android-App, die in Facebook integriert ist. Ich würde gerne:

  1. Lassen Sie den Benutzer sich mit Facebook einloggen
  2. Rufen Sie die E-Mail-Adresse des Benutzers auf Facebook ab (möglicherweise eine proxied-E-Mail-Adresse , was in Ordnung ist).
  3. Posten Sie in seinem Namen an die Pinnwand/Zeitleiste des Benutzers

Technisch wäre das:

  1. Authentifizieren Sie den Benutzer
  2. Fordern Sie die email-Berechtigung an .
  3. Fordern Sie die publish_stream-Berechtigung an .

1. Authentifizieren Sie den Benutzer

Ich habe Session.openActiveSession() mit einem Session.StatusCallback angerufen (ich habe bereits überprüft, dass vorher keine aktive Sitzung geöffnet ist):

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);

Mein Rückruf wird nach erfolgreichem Login aufgerufen. So weit, ist es gut.

2. Fordern Sie die email-Berechtigung an .

Dies ist mein Statusrückruf:

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;
        }
    };
};

Ich beantrage die Erlaubnis mit 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));

Mein Rückruf wird aufgerufen, nachdem die Erlaubnis erteilt wurde. So weit, ist es gut.

3. Fordern Sie die publish_stream-Berechtigung an .

Dies ist mein Statusrückruf:

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;
        }
    };
};

Ich beantrage die Erlaubnis mit 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));

Dieses Mal wird mein Rückruf nicht aufgerufen, nachdem die Berechtigung erteilt wurde.

Ermittlung

Bei weiteren Untersuchungen fand ich heraus, dass mein Rückruf durch com.facebook.Session#postStateChange(SessionState, SessionState, Exception) ausgelöst wird:

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

    /* ... */
}

Da oldState und newState gleich sind (beide sind SessionState.OPENED_TOKEN_UPDATED ), wird mein Callback nicht aufgerufen.

Frage

Wie kann ich nach der Erlaubnis zum 2. Mal eine Benachrichtigung erhalten? Soll ich die Sitzung close() [_] und von Cache wieder öffnen?

Zusätzliche Information

Mein Facebook Android SDK 3.0 kann von hier heruntergeladen werden, was in Facebook Erste Schritte mit dem Facebook SDK für Android angegeben ist.

22
Pang

Das ist ein Fehler.

[Bearbeiten: Wie Guy in Kommentaren darauf hinweist, wurde dies in 3.0.1 behoben, sodass diese Problemumgehung nicht mehr erforderlich ist]

Die Problemumgehung, die Sie erwähnen, ist im Grunde korrekt, obwohl Sie nicht auf Schließen schließen müssen. Wenn Sie die einzelne aktive Sitzung verwenden, müssen Sie vor dem Aufruf von requestNewPublishPermissions () einfach Folgendes aufrufen:

Session.openActiveSessionFromCache(myContext);

Wenn Sie mehrere Sitzungen verwenden, müssen Sie eine neue Sitzung mit TokenCachingStrategy initialisieren, überprüfen, dass sie sich im Status CREATED_TOKEN_LOADED befindet, und den Befehl openForRead (null) aufrufen.

Nachdem Sie eine dieser Aktionen ausgeführt haben, sollte requestNewPublishPermissions () Ihre Benachrichtigung aufrufen, sobald sie abgeschlossen ist.

10
rightparen

Arbeitscode basierend auf rightparens Antwort

Bevor Sie die Erlaubnis zum 2. Mal anfordern (d. H. Vor Session.requestNewPublishPermissions() ), führen Sie Folgendes aus:

// 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.

Code basiert weiterhin auf Facebook Android SDK 3.0, wie in der Frage.

2
Pang

Eine andere Sache, auf die ich gestoßen bin, war, dass mein requestCode für die NewPermissionRequest nicht auf den gleichen requestCode gesetzt wurde, mit dem ich meine Session zum Lesen geöffnet habe, wodurch mein Session.StatusCallback nie aufgerufen wurde, wenn die neuen Berechtigungen erteilt wurden.

Zum Beispiel habe ich in meiner onActivityResult eine Überprüfung auf den requestCode und delegiere den Aufruf entsprechend, da andere Dinge in diese Methode kommen.

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);
        }
    }       
}

Ich habe dann meine Session mit folgendem Code geöffnet:

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

Ich habe dann vergessen, denselben requestCode zu verwenden, wenn ich meine NewPermissionRequest erstellt habe.

So muss die richtige NewPermissionRequest aussehen:

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