Subversion Repositories SmartDukaan

/**

 * Copyright 2010-present Facebook.

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *    http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package com.facebook;

import android.annotation.SuppressLint;

import android.app.Activity;

import android.content.*;

import android.content.pm.ResolveInfo;

import android.os.*;

import android.support.v4.app.Fragment;

import android.support.v4.content.LocalBroadcastManager;

import android.text.TextUtils;

import android.util.Log;

import com.facebook.internal.NativeProtocol;

import com.facebook.internal.SessionAuthorizationType;

import com.facebook.internal.Utility;

import com.facebook.internal.Validate;

import com.facebook.model.GraphMultiResult;

import com.facebook.model.GraphObject;

import com.facebook.model.GraphObjectList;

import org.json.JSONException;

import org.json.JSONObject;

import java.io.*;

import java.lang.ref.WeakReference;

import java.util.*;

/**

 * <p>

 * Session is used to authenticate a user and manage the user's session with

 * Facebook.

 * </p>

 * <p>

 * Sessions must be opened before they can be used to make a Request. When a

 * Session is created, it attempts to initialize itself from a TokenCachingStrategy.

 * Closing the session can optionally clear this cache.  The Session lifecycle

 * uses {@link SessionState SessionState} to indicate its state. Once a Session has

 * been closed, it can't be re-opened; a new Session must be created.

 * </p>

 * <p>

 * Instances of Session provide state change notification via a callback

 * interface, {@link Session.StatusCallback StatusCallback}.

 * </p>

 */

public class Session implements Serializable {

    private static final long serialVersionUID = 1L;

    /**

     * The logging tag used by Session.

     */

    public static final String TAG = Session.class.getCanonicalName();

    /**

     * The default activity code used for authorization.

     *

     * @see #openForRead(OpenRequest)

     *      open

     */

    public static final int DEFAULT_AUTHORIZE_ACTIVITY_CODE = 0xface;

    /**

     * If Session authorization fails and provides a web view error code, the

     * web view error code is stored in the Bundle returned from

     * {@link #getAuthorizationBundle getAuthorizationBundle} under this key.

     */

    public static final String WEB_VIEW_ERROR_CODE_KEY = "com.facebook.sdk.WebViewErrorCode";

    /**

     * If Session authorization fails and provides a failing url, the failing

     * url is stored in the Bundle returned from {@link #getAuthorizationBundle

     * getAuthorizationBundle} under this key.

     */

    public static final String WEB_VIEW_FAILING_URL_KEY = "com.facebook.sdk.FailingUrl";

    /**

     * The action used to indicate that the active session has been set. This should

     * be used as an action in an IntentFilter and BroadcastReceiver registered with

     * the {@link android.support.v4.content.LocalBroadcastManager}.

     */

    public static final String ACTION_ACTIVE_SESSION_SET = "com.facebook.sdk.ACTIVE_SESSION_SET";

    /**

     * The action used to indicate that the active session has been set to null. This should

     * be used as an action in an IntentFilter and BroadcastReceiver registered with

     * the {@link android.support.v4.content.LocalBroadcastManager}.

     */

    public static final String ACTION_ACTIVE_SESSION_UNSET = "com.facebook.sdk.ACTIVE_SESSION_UNSET";

    /**

     * The action used to indicate that the active session has been opened. This should

     * be used as an action in an IntentFilter and BroadcastReceiver registered with

     * the {@link android.support.v4.content.LocalBroadcastManager}.

     */

    public static final String ACTION_ACTIVE_SESSION_OPENED = "com.facebook.sdk.ACTIVE_SESSION_OPENED";

    /**

     * The action used to indicate that the active session has been closed. This should

     * be used as an action in an IntentFilter and BroadcastReceiver registered with

     * the {@link android.support.v4.content.LocalBroadcastManager}.

     */

    public static final String ACTION_ACTIVE_SESSION_CLOSED = "com.facebook.sdk.ACTIVE_SESSION_CLOSED";

    private static final Object STATIC_LOCK = new Object();

    private static Session activeSession;

    private static volatile Context staticContext;

    // Token extension constants

    private static final int TOKEN_EXTEND_THRESHOLD_SECONDS = 24 * 60 * 60; // 1

    // day

    private static final int TOKEN_EXTEND_RETRY_SECONDS = 60 * 60; // 1 hour

    private static final String SESSION_BUNDLE_SAVE_KEY = "com.facebook.sdk.Session.saveSessionKey";

    private static final String AUTH_BUNDLE_SAVE_KEY = "com.facebook.sdk.Session.authBundleKey";

    private static final String PUBLISH_PERMISSION_PREFIX = "publish";

    private static final String MANAGE_PERMISSION_PREFIX = "manage";

    @SuppressWarnings("serial")

    private static final Set<String> OTHER_PUBLISH_PERMISSIONS = new HashSet<String>() {{

        add("ads_management");

        add("create_event");

        add("rsvp_event");

    }};

    private String applicationId;

    private SessionState state;

    private AccessToken tokenInfo;

    private Date lastAttemptedTokenExtendDate = new Date(0);

    private AuthorizationRequest pendingAuthorizationRequest;

    private AuthorizationClient authorizationClient;

    // The following are not serialized with the Session object

    private volatile Bundle authorizationBundle;

    private final List<StatusCallback> callbacks;

    private Handler handler;

    private AutoPublishAsyncTask autoPublishAsyncTask;

    // This is the object that synchronizes access to state and tokenInfo

    private final Object lock = new Object();

    private TokenCachingStrategy tokenCachingStrategy;

    private volatile TokenRefreshRequest currentTokenRefreshRequest;

    private AppEventsLogger appEventsLogger;

    /**

     * Serialization proxy for the Session class. This is version 1 of

     * serialization. Future serializations may differ in format. This

     * class should not be modified. If serializations formats change,

     * create a new class SerializationProxyVx.

     */

    private static class SerializationProxyV1 implements Serializable {

        private static final long serialVersionUID = 7663436173185080063L;

        private final String applicationId;

        private final SessionState state;

        private final AccessToken tokenInfo;

        private final Date lastAttemptedTokenExtendDate;

        private final boolean shouldAutoPublish;

        private final AuthorizationRequest pendingAuthorizationRequest;

        SerializationProxyV1(String applicationId, SessionState state,

                AccessToken tokenInfo, Date lastAttemptedTokenExtendDate,

                boolean shouldAutoPublish, AuthorizationRequest pendingAuthorizationRequest) {

            this.applicationId = applicationId;

            this.state = state;

            this.tokenInfo = tokenInfo;

            this.lastAttemptedTokenExtendDate = lastAttemptedTokenExtendDate;

            this.shouldAutoPublish = shouldAutoPublish;

            this.pendingAuthorizationRequest = pendingAuthorizationRequest;

        }

        private Object readResolve() {

            return new Session(applicationId, state, tokenInfo,

                    lastAttemptedTokenExtendDate, shouldAutoPublish, pendingAuthorizationRequest);

        }

    }

    /**

     * Serialization proxy for the Session class. This is version 2 of

     * serialization. Future serializations may differ in format. This

     * class should not be modified. If serializations formats change,

     * create a new class SerializationProxyVx.

     */

    @SuppressWarnings("UnusedDeclaration")

    private static class SerializationProxyV2 implements Serializable {

        private static final long serialVersionUID = 7663436173185080064L;

        private final String applicationId;

        private final SessionState state;

        private final AccessToken tokenInfo;

        private final Date lastAttemptedTokenExtendDate;

        private final boolean shouldAutoPublish;

        private final AuthorizationRequest pendingAuthorizationRequest;

        private final Set<String> requestedPermissions;

        SerializationProxyV2(String applicationId, SessionState state,

                             AccessToken tokenInfo, Date lastAttemptedTokenExtendDate,

                             boolean shouldAutoPublish, AuthorizationRequest pendingAuthorizationRequest,

                             Set<String> requestedPermissions) {

            this.applicationId = applicationId;

            this.state = state;

            this.tokenInfo = tokenInfo;

            this.lastAttemptedTokenExtendDate = lastAttemptedTokenExtendDate;

            this.shouldAutoPublish = shouldAutoPublish;

            this.pendingAuthorizationRequest = pendingAuthorizationRequest;

            this.requestedPermissions = requestedPermissions;

        }

        private Object readResolve() {

            return new Session(applicationId, state, tokenInfo,

                    lastAttemptedTokenExtendDate, shouldAutoPublish, pendingAuthorizationRequest, requestedPermissions);

        }

    }

    /**

     * Used by version 1 of the serialization proxy, do not modify.

     */

    private Session(String applicationId, SessionState state,

            AccessToken tokenInfo, Date lastAttemptedTokenExtendDate,

            boolean shouldAutoPublish, AuthorizationRequest pendingAuthorizationRequest) {

        this.applicationId = applicationId;

        this.state = state;

        this.tokenInfo = tokenInfo;

        this.lastAttemptedTokenExtendDate = lastAttemptedTokenExtendDate;

        this.pendingAuthorizationRequest = pendingAuthorizationRequest;

        handler = new Handler(Looper.getMainLooper());

        currentTokenRefreshRequest = null;

        tokenCachingStrategy = null;

        callbacks = new ArrayList<StatusCallback>();

    }

    /**

     * Used by version 2 of the serialization proxy, do not modify.

     */

    private Session(String applicationId, SessionState state,

                    AccessToken tokenInfo, Date lastAttemptedTokenExtendDate,

                    boolean shouldAutoPublish, AuthorizationRequest pendingAuthorizationRequest,

                    Set<String> requestedPermissions) {

        this.applicationId = applicationId;

        this.state = state;

        this.tokenInfo = tokenInfo;

        this.lastAttemptedTokenExtendDate = lastAttemptedTokenExtendDate;

        this.pendingAuthorizationRequest = pendingAuthorizationRequest;

        handler = new Handler(Looper.getMainLooper());

        currentTokenRefreshRequest = null;

        tokenCachingStrategy = null;

        callbacks = new ArrayList<StatusCallback>();

    }

    /**

     * Initializes a new Session with the specified context.

     *

     * @param currentContext The Activity or Service creating this Session.

     */

    public Session(Context currentContext) {

        this(currentContext, null, null, true);

    }

    Session(Context context, String applicationId, TokenCachingStrategy tokenCachingStrategy) {

        this(context, applicationId, tokenCachingStrategy, true);

    }

    Session(Context context, String applicationId, TokenCachingStrategy tokenCachingStrategy,

            boolean loadTokenFromCache) {

        // if the application ID passed in is null, try to get it from the

        // meta-data in the manifest.

        if ((context != null) && (applicationId == null)) {

            applicationId = Utility.getMetadataApplicationId(context);

        }

        Validate.notNull(applicationId, "applicationId");

        initializeStaticContext(context);

        if (tokenCachingStrategy == null) {

            tokenCachingStrategy = new SharedPreferencesTokenCachingStrategy(staticContext);

        }

        this.applicationId = applicationId;

        this.tokenCachingStrategy = tokenCachingStrategy;

        this.state = SessionState.CREATED;

        this.pendingAuthorizationRequest = null;

        this.callbacks = new ArrayList<StatusCallback>();

        this.handler = new Handler(Looper.getMainLooper());

        Bundle tokenState = loadTokenFromCache ? tokenCachingStrategy.load() : null;

        if (TokenCachingStrategy.hasTokenInformation(tokenState)) {

            Date cachedExpirationDate = TokenCachingStrategy

                    .getDate(tokenState, TokenCachingStrategy.EXPIRATION_DATE_KEY);

            Date now = new Date();

            if ((cachedExpirationDate == null) || cachedExpirationDate.before(now)) {

                // If expired or we require new permissions, clear out the

                // current token cache.

                tokenCachingStrategy.clear();

                this.tokenInfo = AccessToken.createEmptyToken();

            } else {

                // Otherwise we have a valid token, so use it.

                this.tokenInfo = AccessToken.createFromCache(tokenState);

                this.state = SessionState.CREATED_TOKEN_LOADED;

            }

        } else {

            this.tokenInfo = AccessToken.createEmptyToken();

        }

    }

    /**

     * Returns a Bundle containing data that was returned from Facebook during

     * authorization.

     *

     * @return a Bundle containing data that was returned from Facebook during

     *         authorization.

     */

    public final Bundle getAuthorizationBundle() {

        synchronized (this.lock) {

            return this.authorizationBundle;

        }

    }

    /**

     * Returns a boolean indicating whether the session is opened.

     *

     * @return a boolean indicating whether the session is opened.

     */

    public final boolean isOpened() {

        synchronized (this.lock) {

            return this.state.isOpened();

        }

    }

    public final boolean isClosed() {

        synchronized (this.lock) {

            return this.state.isClosed();

        }

    }

    /**

     * Returns the current state of the Session.

     * See {@link SessionState} for details.

     *

     * @return the current state of the Session.

     */

    public final SessionState getState() {

        synchronized (this.lock) {

            return this.state;

        }

    }

    /**

     * Returns the application id associated with this Session.

     *

     * @return the application id associated with this Session.

     */

    public final String getApplicationId() {

        return this.applicationId;

    }

    /**

     * Returns the access token String.

     *

     * @return the access token String, or null if there is no access token

     */

    public final String getAccessToken() {

        synchronized (this.lock) {

            return (this.tokenInfo == null) ? null : this.tokenInfo.getToken();

        }

    }

    /**

     * <p>

     * Returns the Date at which the current token will expire.

     * </p>

     * <p>

     * Note that Session automatically attempts to extend the lifetime of Tokens

     * as needed when Facebook requests are made.

     * </p>

     *

     * @return the Date at which the current token will expire, or null if there is no access token

     */

    public final Date getExpirationDate() {

        synchronized (this.lock) {

            return (this.tokenInfo == null) ? null : this.tokenInfo.getExpires();

        }

    }

    /**

     * <p>

     * Returns the list of permissions associated with the session.

     * </p>

     * <p>

     * If there is a valid token, this represents the permissions granted by

     * that token. This can change during calls to

     * {@link #requestNewReadPermissions}

     * or {@link #requestNewPublishPermissions}.

     * </p>

     *

     * @return the list of permissions associated with the session, or null if there is no access token

     */

    public final List<String> getPermissions() {

        synchronized (this.lock) {

            return (this.tokenInfo == null) ? null : this.tokenInfo.getPermissions();

        }

    }

    /**

     * <p>

     *     Returns whether a particular permission has been granted

     * </p>

     *

     * @param permission The permission to check for

     * @return true if the permission is granted, false otherwise

     */

    public boolean isPermissionGranted(String permission) {

        List<String> grantedPermissions = getPermissions();

        if (grantedPermissions != null) {

            return grantedPermissions.contains(permission);

        }

        return false;

    }

    /**

     * <p>

     * Returns the list of permissions that have been requested in this session but not granted

     * </p>

     *

     * @return the list of requested permissions that have been declined

     */

    public final List<String> getDeclinedPermissions() {

        synchronized (this.lock) {

            return (this.tokenInfo == null) ? null : this.tokenInfo.getDeclinedPermissions();

        }

    }

    /**

     * <p>

     * Logs a user in to Facebook.

     * </p>

     * <p>

     * A session may not be used with {@link Request Request} and other classes

     * in the SDK until it is open. If, prior to calling open, the session is in

     * the {@link SessionState#CREATED_TOKEN_LOADED CREATED_TOKEN_LOADED}

     * state, and the requested permissions are a subset of the previously authorized

     * permissions, then the Session becomes usable immediately with no user interaction.

     * </p>

     * <p>

     * The permissions associated with the openRequest passed to this method must

     * be read permissions only (or null/empty). It is not allowed to pass publish

     * permissions to this method and will result in an exception being thrown.

     * </p>

     * <p>

     * Any open method must be called at most once, and cannot be called after the

     * Session is closed. Calling the method at an invalid time will result in

     * UnsuportedOperationException.

     * </p>

     *

     * @param openRequest the open request, can be null only if the Session is in the

     *                    {@link SessionState#CREATED_TOKEN_LOADED CREATED_TOKEN_LOADED} state

     * @throws FacebookException if any publish or manage permissions are requested

     */

    public final void openForRead(OpenRequest openRequest) {

        open(openRequest, SessionAuthorizationType.READ);

    }

    /**

     * <p>

     * Logs a user in to Facebook.

     * </p>

     * <p>

     * A session may not be used with {@link Request Request} and other classes

     * in the SDK until it is open. If, prior to calling open, the session is in

     * the {@link SessionState#CREATED_TOKEN_LOADED CREATED_TOKEN_LOADED}

     * state, and the requested permissions are a subset of the previously authorized

     * permissions, then the Session becomes usable immediately with no user interaction.

     * </p>

     * <p>

     * The permissions associated with the openRequest passed to this method must

     * be publish or manage permissions only and must be non-empty. Any read permissions

     * will result in a warning, and may fail during server-side authorization. Also, an application

     * must have at least basic read permissions prior to requesting publish permissions, so

     * this method should only be used if the application knows that the user has already granted

     * read permissions to the application; otherwise, openForRead should be used, followed by a

     * call to requestNewPublishPermissions. For more information on this flow, see

     * https://developers.facebook.com/docs/facebook-login/permissions/.

     * </p>

     * <p>

     * Any open method must be called at most once, and cannot be called after the

     * Session is closed. Calling the method at an invalid time will result in

     * UnsuportedOperationException.

     * </p>

     *

     * @param openRequest the open request, can be null only if the Session is in the

     *                    {@link SessionState#CREATED_TOKEN_LOADED CREATED_TOKEN_LOADED} state

     * @throws FacebookException if the passed in request is null or has no permissions set.

     */

    public final void openForPublish(OpenRequest openRequest) {

        open(openRequest, SessionAuthorizationType.PUBLISH);

    }

    /**

     * Opens a session based on an existing Facebook access token. This method should be used

     * only in instances where an application has previously obtained an access token and wishes

     * to import it into the Session/TokenCachingStrategy-based session-management system. An

     * example would be an application which previously did not use the Facebook SDK for Android

     * and implemented its own session-management scheme, but wishes to implement an upgrade path

     * for existing users so they do not need to log in again when upgrading to a version of

     * the app that uses the SDK.

     * <p/>

     * No validation is done that the token, token source, or permissions are actually valid.

     * It is the caller's responsibility to ensure that these accurately reflect the state of

     * the token that has been passed in, or calls to the Facebook API may fail.

     *

     * @param accessToken the access token obtained from Facebook

     * @param callback    a callback that will be called when the session status changes; may be null

     */

    public final void open(AccessToken accessToken, StatusCallback callback) {

        synchronized (this.lock) {

            if (pendingAuthorizationRequest != null) {

                throw new UnsupportedOperationException(

                        "Session: an attempt was made to open a session that has a pending request.");

            }

            if (state.isClosed()) {

                throw new UnsupportedOperationException(

                        "Session: an attempt was made to open a previously-closed session.");

            } else if (state != SessionState.CREATED && state != SessionState.CREATED_TOKEN_LOADED) {

                throw new UnsupportedOperationException(

                        "Session: an attempt was made to open an already opened session.");

            }

            if (callback != null) {

                addCallback(callback);

            }

            this.tokenInfo = accessToken;

            if (this.tokenCachingStrategy != null) {

                this.tokenCachingStrategy.save(accessToken.toCacheBundle());

            }

            final SessionState oldState = state;

            state = SessionState.OPENED;

            this.postStateChange(oldState, state, null);

        }

        autoPublishAsync();

    }

    /**

     * <p>

     * Issues a request to add new read permissions to the Session.

     * </p>

     * <p>

     * If successful, this will update the set of permissions on this session to

     * match the newPermissions. If this fails, the Session remains unchanged.

     * </p>

     * <p>

     * The permissions associated with the newPermissionsRequest passed to this method must

     * be read permissions only (or null/empty). It is not allowed to pass publish

     * permissions to this method and will result in an exception being thrown.

     * </p>

     *

     * @param newPermissionsRequest the new permissions request

     */

    public final void requestNewReadPermissions(NewPermissionsRequest newPermissionsRequest) {

        requestNewPermissions(newPermissionsRequest, SessionAuthorizationType.READ);

    }

    /**

     * <p>

     * Issues a request to add new publish or manage permissions to the Session.

     * </p>

     * <p>

     * If successful, this will update the set of permissions on this session to

     * match the newPermissions. If this fails, the Session remains unchanged.

     * </p>

     * <p>

     * The permissions associated with the newPermissionsRequest passed to this method must

     * be publish or manage permissions only and must be non-empty. Any read permissions

     * will result in a warning, and may fail during server-side authorization.

     * </p>

     *

     * @param newPermissionsRequest the new permissions request

     */

    public final void requestNewPublishPermissions(NewPermissionsRequest newPermissionsRequest) {

        requestNewPermissions(newPermissionsRequest, SessionAuthorizationType.PUBLISH);

    }

    /**

     * <p>

     * Issues a request to refresh the permissions on the session.

     * </p>

     * <p>

     * If successful, this will update the permissions and call the app back with

     * {@link SessionState#OPENED_TOKEN_UPDATED}.  The session can then be queried to see the granted and declined

     * permissions.  If this fails because the user has removed the app, the session will close.

     * </p>

     */

    public final void refreshPermissions() {

        Request request = new Request(this, "me/permissions");

        request.setCallback(new Request.Callback() {

            @Override

            public void onCompleted(Response response) {

                PermissionsPair permissionsPair = handlePermissionResponse(response);

                if (permissionsPair != null) {

                    // Update our token with the refreshed permissions

                    synchronized (lock) {

                        tokenInfo = AccessToken.createFromTokenWithRefreshedPermissions(tokenInfo,

                                permissionsPair.getGrantedPermissions(), permissionsPair.getDeclinedPermissions());

                        postStateChange(state, SessionState.OPENED_TOKEN_UPDATED, null);

                    }

                }

            }

        });

        request.executeAsync();

    }

    /**

     * Internal helper class that is used to hold two different permission lists (granted and declined)

     */

    static class PermissionsPair {

        List<String> grantedPermissions;

        List<String> declinedPermissions;

        public PermissionsPair(List<String> grantedPermissions, List<String> declinedPermissions) {

            this.grantedPermissions = grantedPermissions;

            this.declinedPermissions = declinedPermissions;

        }

        public List<String> getGrantedPermissions() {

            return grantedPermissions;

        }

        public List<String> getDeclinedPermissions() {

            return declinedPermissions;

        }

    }

    /**

     * This parses a server response to a call to me/permissions.  It will return the list of granted permissions.

     * It will optionally update a session with the requested permissions.  It also handles the distinction between

     * 1.0 and 2.0 calls to the endpoint.

     *

     * @param response The server response

     * @return A list of granted permissions or null if an error

     */

    static PermissionsPair handlePermissionResponse(Response response) {

        if (response.getError() != null) {

            return null;

        }

        GraphMultiResult result = response.getGraphObjectAs(GraphMultiResult.class);

        if (result == null) {

            return null;

        }

        GraphObjectList<GraphObject> data = result.getData();

        if (data == null || data.size() == 0) {

            return null;

        }

        List<String> grantedPermissions = new ArrayList<String>(data.size());

        List<String> declinedPermissions = new ArrayList<String>(data.size());

        // Check if we are dealing with v2.0 or v1.0 behavior until the server is updated

        GraphObject firstObject = data.get(0);

        if (firstObject.getProperty("permission") != null) { // v2.0

            for (GraphObject graphObject : data) {

                String permission = (String) graphObject.getProperty("permission");

                if (permission.equals("installed")) {

                    continue;

                }

                String status = (String) graphObject.getProperty("status");

                if(status.equals("granted")) {

                    grantedPermissions.add(permission);

                } else if (status.equals("declined")) {

                    declinedPermissions.add(permission);

                }

            }

        } else { // v1.0

            Map<String, Object> permissionsMap = firstObject.asMap();

            for (Map.Entry<String, Object> entry : permissionsMap.entrySet()) {

                if (entry.getKey().equals("installed")) {

                    continue;

                }

                if ((Integer)entry.getValue() == 1) {

                    grantedPermissions.add(entry.getKey());

                }

            }

        }

        return new PermissionsPair(grantedPermissions, declinedPermissions);

    }

    /**

     * Provides an implementation for {@link Activity#onActivityResult

     * onActivityResult} that updates the Session based on information returned

     * during the authorization flow. The Activity that calls open or

     * requestNewPermissions should forward the resulting onActivityResult call here to

     * update the Session state based on the contents of the resultCode and

     * data.

     *

     * @param currentActivity The Activity that is forwarding the onActivityResult call.

     * @param requestCode     The requestCode parameter from the forwarded call. When this

     *                        onActivityResult occurs as part of Facebook authorization

     *                        flow, this value is the activityCode passed to open or

     *                        authorize.

     * @param resultCode      An int containing the resultCode parameter from the forwarded

     *                        call.

     * @param data            The Intent passed as the data parameter from the forwarded

     *                        call.

     * @return A boolean indicating whether the requestCode matched a pending

     *         authorization request for this Session.

     */

    public final boolean onActivityResult(Activity currentActivity, int requestCode, int resultCode, Intent data) {

        Validate.notNull(currentActivity, "currentActivity");

        initializeStaticContext(currentActivity);

        synchronized (lock) {

            if (pendingAuthorizationRequest == null || (requestCode != pendingAuthorizationRequest.getRequestCode())) {

                return false;

            }

        }

        Exception exception = null;

        AuthorizationClient.Result.Code code = AuthorizationClient.Result.Code.ERROR;

        if (data != null) {

            AuthorizationClient.Result result = (AuthorizationClient.Result) data.getSerializableExtra(

                    LoginActivity.RESULT_KEY);

            if (result != null) {

                // This came from LoginActivity.

                handleAuthorizationResult(resultCode, result);

                return true;

            } else if (authorizationClient != null) {

                // Delegate to the auth client.

                authorizationClient.onActivityResult(requestCode, resultCode, data);

                return true;

            }

        } else if (resultCode == Activity.RESULT_CANCELED) {

            exception = new FacebookOperationCanceledException("User canceled operation.");

            code = AuthorizationClient.Result.Code.CANCEL;

        }

        if (exception == null) {

            exception = new FacebookException("Unexpected call to Session.onActivityResult");

        }

        logAuthorizationComplete(code, null, exception);

        finishAuthOrReauth(null, exception);

        return true;

    }

    /**

     * Closes the local in-memory Session object, but does not clear the

     * persisted token cache.

     */

    public final void close() {

        synchronized (this.lock) {

            final SessionState oldState = this.state;

            switch (this.state) {

                case CREATED:

                case OPENING:

                    this.state = SessionState.CLOSED_LOGIN_FAILED;

                    postStateChange(oldState, this.state, new FacebookException(

                            "Log in attempt aborted."));

                    break;

                case CREATED_TOKEN_LOADED:

                case OPENED:

                case OPENED_TOKEN_UPDATED:

                    this.state = SessionState.CLOSED;

                    postStateChange(oldState, this.state, null);

                    break;

                case CLOSED:

                case CLOSED_LOGIN_FAILED:

                    break;

            }

        }

    }

    /**

     * Closes the local in-memory Session object and clears any persisted token

     * cache related to the Session.

     */

    public final void closeAndClearTokenInformation() {

        if (this.tokenCachingStrategy != null) {

            this.tokenCachingStrategy.clear();

        }

        Utility.clearFacebookCookies(staticContext);

        Utility.clearCaches(staticContext);

        close();

    }

    /**

     * Adds a callback that will be called when the state of this Session changes.

     *

     * @param callback the callback

     */

    public final void addCallback(StatusCallback callback) {

        synchronized (callbacks) {

            if (callback != null && !callbacks.contains(callback)) {

                callbacks.add(callback);

            }

        }

    }

    /**

     * Removes a StatusCallback from this Session.

     *

     * @param callback the callback

     */

    public final void removeCallback(StatusCallback callback) {

        synchronized (callbacks) {

            callbacks.remove(callback);

        }

    }

    @Override

    public String toString() {

        return new StringBuilder().append("{Session").append(" state:").append(this.state).append(", token:")

                .append((this.tokenInfo == null) ? "null" : this.tokenInfo).append(", appId:")

                .append((this.applicationId == null) ? "null" : this.applicationId).append("}").toString();

    }

    void extendTokenCompleted(Bundle bundle) {

        synchronized (this.lock) {

            final SessionState oldState = this.state;

            switch (this.state) {

                case OPENED:

                    this.state = SessionState.OPENED_TOKEN_UPDATED;

                    postStateChange(oldState, this.state, null);

                    break;

                case OPENED_TOKEN_UPDATED:

                    break;

                default:

                    // Silently ignore attempts to refresh token if we are not open

                    Log.d(TAG, "refreshToken ignored in state " + this.state);

                    return;

            }

            this.tokenInfo = AccessToken.createFromRefresh(this.tokenInfo, bundle);

            if (this.tokenCachingStrategy != null) {

                this.tokenCachingStrategy.save(this.tokenInfo.toCacheBundle());

            }

        }

    }

    private Object writeReplace() {

        return new SerializationProxyV1(applicationId, state, tokenInfo,

                lastAttemptedTokenExtendDate, false, pendingAuthorizationRequest);

    }

    // have a readObject that throws to prevent spoofing

    private void readObject(ObjectInputStream stream) throws InvalidObjectException {

        throw new InvalidObjectException("Cannot readObject, serialization proxy required");

    }

    /**

     * Save the Session object into the supplied Bundle. This method is intended to be called from an

     * Activity or Fragment's onSaveInstanceState method in order to preserve Sessions across Activity lifecycle events.

     *

     * @param session the Session to save

     * @param bundle  the Bundle to save the Session to

     */

    public static final void saveSession(Session session, Bundle bundle) {

        if (bundle != null && session != null && !bundle.containsKey(SESSION_BUNDLE_SAVE_KEY)) {

            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

            try {

                new ObjectOutputStream(outputStream).writeObject(session);

            } catch (IOException e) {

                throw new FacebookException("Unable to save session.", e);

            }

            bundle.putByteArray(SESSION_BUNDLE_SAVE_KEY, outputStream.toByteArray());

            bundle.putBundle(AUTH_BUNDLE_SAVE_KEY, session.authorizationBundle);

        }

    }

    /**

     * Restores the saved session from a Bundle, if any. Returns the restored Session or

     * null if it could not be restored. This method is intended to be called from an Activity or Fragment's

     * onCreate method when a Session has previously been saved into a Bundle via saveState to preserve a Session

     * across Activity lifecycle events.

     *

     * @param context         the Activity or Service creating the Session, must not be null

     * @param cachingStrategy the TokenCachingStrategy to use to load and store the token. If this is

     *                        null, a default token cachingStrategy that stores data in

     *                        SharedPreferences will be used

     * @param callback        the callback to notify for Session state changes, can be null

     * @param bundle          the bundle to restore the Session from

     * @return the restored Session, or null

     */

    public static final Session restoreSession(

            Context context, TokenCachingStrategy cachingStrategy, StatusCallback callback, Bundle bundle) {

        if (bundle == null) {

            return null;

        }

        byte[] data = bundle.getByteArray(SESSION_BUNDLE_SAVE_KEY);

        if (data != null) {

            ByteArrayInputStream is = new ByteArrayInputStream(data);

            try {

                Session session = (Session) (new ObjectInputStream(is)).readObject();

                initializeStaticContext(context);

                if (cachingStrategy != null) {

                    session.tokenCachingStrategy = cachingStrategy;

                } else {

                    session.tokenCachingStrategy = new SharedPreferencesTokenCachingStrategy(context);

                }

                if (callback != null) {

                    session.addCallback(callback);

                }

                session.authorizationBundle = bundle.getBundle(AUTH_BUNDLE_SAVE_KEY);

                return session;

            } catch (ClassNotFoundException e) {

                Log.w(TAG, "Unable to restore session", e);

            } catch (IOException e) {

                Log.w(TAG, "Unable to restore session.", e);

            }

        }

        return null;

    }

    /**

     * Returns the current active Session, or null if there is none.

     *

     * @return the current active Session, or null if there is none.

     */

    public static final Session getActiveSession() {

        synchronized (Session.STATIC_LOCK) {

            return Session.activeSession;

        }

    }

    /**

     * <p>

     * Sets the current active Session.

     * </p>

     * <p>

     * The active Session is used implicitly by predefined Request factory

     * methods as well as optionally by UI controls in the sdk.

     * </p>

     * <p>

     * It is legal to set this to null, or to a Session that is not yet open.

     * </p>

     *

     * @param session A Session to use as the active Session, or null to indicate

     *                that there is no active Session.

     */

    public static final void setActiveSession(Session session) {

        synchronized (Session.STATIC_LOCK) {

            if (session != Session.activeSession) {

                Session oldSession = Session.activeSession;

                if (oldSession != null) {

                    oldSession.close();

                }

                Session.activeSession = session;

                if (oldSession != null) {

                    postActiveSessionAction(Session.ACTION_ACTIVE_SESSION_UNSET);

                }

                if (session != null) {

                    postActiveSessionAction(Session.ACTION_ACTIVE_SESSION_SET);

                    if (session.isOpened()) {

                        postActiveSessionAction(Session.ACTION_ACTIVE_SESSION_OPENED);

                    }

                }

            }

        }

    }

    /**

     * If a cached token is available, creates and opens the session and makes it active without any user interaction,

     * otherwise this does nothing.

     *

     * @param context The Context creating this session

     * @return The new session or null if one could not be created

     */

    public static Session openActiveSessionFromCache(Context context) {

        return openActiveSession(context, false, null);

    }

    /**

     * If allowLoginUI is true, this will create a new Session, make it active, and

     * open it. If the default token cache is not available, then this will request

     * basic permissions. If the default token cache is available and cached tokens