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.widget;

import android.content.Intent;

import android.os.Bundle;

import android.support.v4.app.Fragment;

import com.facebook.Session;

import com.facebook.SessionLoginBehavior;

import com.facebook.SessionState;

import com.facebook.internal.SessionAuthorizationType;

import com.facebook.internal.SessionTracker;

import java.util.Date;

import java.util.List;

/**

 * <p>Basic implementation of a Fragment that uses a Session to perform 

 * Single Sign On (SSO). This class is package private, and is not intended

 * to be consumed by external applications.</p>

 * 

 * <p>The method {@link android.support.v4.app.Fragment#onActivityResult} is

 * used to manage the session information, so if you override it in a subclass, 

 * be sure to call {@code super.onActivityResult}.</p>

 * 

 * <p>The methods in this class are not thread-safe.</p>

 */

class FacebookFragment extends Fragment {

    private SessionTracker sessionTracker;

    @Override

    public void onActivityCreated(Bundle savedInstanceState) {

        super.onActivityCreated(savedInstanceState);

        sessionTracker = new SessionTracker(getActivity(), new DefaultSessionStatusCallback());

    }

    /**

     * Called when the activity that was launched exits. This method manages session

     * information when a session is opened. If this method is overridden in subclasses,

     * be sure to call {@code super.onActivityResult(...)} first.

     */

    @Override

    public void onActivityResult(int requestCode, int resultCode, Intent data) {

        super.onActivityResult(requestCode, resultCode, data);

        sessionTracker.getSession().onActivityResult(this.getActivity(), requestCode, resultCode, data);

    }

    @Override

    public void onDestroy() {

        super.onDestroy();

        sessionTracker.stopTracking();

    }

    /**

     * Use the supplied Session object instead of the active Session.

     *

     * @param newSession the Session object to use

     */

    public void setSession(Session newSession) {

        if (sessionTracker != null) {

            sessionTracker.setSession(newSession);

        }

    }

    // METHOD TO BE OVERRIDDEN

    /**

     * Called when the session state changes. Override this method to take action

     * on session state changes.

     * 

     * @param state the new state

     * @param exception any exceptions that occurred during the state change

     */

    protected void onSessionStateChange(SessionState state, Exception exception) {

    }

    // ACCESSORS (CANNOT BE OVERRIDDEN)

    /**

     * Gets the current Session.

     * 

     * @return the current Session object.

     */

    protected final Session getSession() {

        if (sessionTracker != null) {

            return sessionTracker.getSession();

        }

        return null;

    }

    /**

     * Determines whether the current session is open.

     * 

     * @return true if the current session is open

     */

    protected final boolean isSessionOpen() {

        if (sessionTracker != null) {

            return sessionTracker.getOpenSession() != null;

        }

        return false;

    }

    /**

     * Gets the current state of the session or null if no session has been created.

     * 

     * @return the current state of the session

     */

    protected final SessionState getSessionState() {

        if (sessionTracker != null) {

            Session currentSession = sessionTracker.getSession();

            return (currentSession != null) ? currentSession.getState() : null;

        }

        return null;

    }

    /**

     * Gets the access token associated with the current session or null if no 

     * session has been created.

     * 

     * @return the access token

     */

    protected final String getAccessToken() {

        if (sessionTracker != null) {

            Session currentSession = sessionTracker.getOpenSession();

            return (currentSession != null) ? currentSession.getAccessToken() : null;

        }

        return null;

    }

    /**

     * Gets the date at which the current session will expire or null if no session 

     * has been created.

     * 

     * @return the date at which the current session will expire

     */

    protected final Date getExpirationDate() {

        if (sessionTracker != null) {

            Session currentSession = sessionTracker.getOpenSession();

            return (currentSession != null) ? currentSession.getExpirationDate() : null;

        }

        return null;

    }

    /**

     * Closes the current session.

     */

    protected final void closeSession() {

        if (sessionTracker != null) {

            Session currentSession = sessionTracker.getOpenSession();

            if (currentSession != null) {

                currentSession.close();

            }

        }

    }

    /**

     * Closes the current session as well as clearing the token cache.

     */

    protected final void closeSessionAndClearTokenInformation() {

        if (sessionTracker != null) {

            Session currentSession = sessionTracker.getOpenSession();

            if (currentSession != null) {

                currentSession.closeAndClearTokenInformation();

            }

        }

    }

    /**

     * Gets the permissions associated with the current session or null if no session 

     * has been created.

     * 

     * @return the permissions associated with the current session

     */

    protected final List<String> getSessionPermissions() {

        if (sessionTracker != null) {

            Session currentSession = sessionTracker.getSession();

            return (currentSession != null) ? currentSession.getPermissions() : null;

        }

        return null;

    }

    /**

     * Opens a new session. This method will use the application id from

     * the associated meta-data value and an empty list of permissions.

     */

    protected final void openSession() {

        openSessionForRead(null, null);

    }

    /**

     * Opens a new session with read permissions. If either applicationID or permissions

     * is null, this method will default to using the values from the associated

     * meta-data value and an empty list respectively.

     *

     * @param applicationId the applicationID, can be null

     * @param permissions the permissions list, can be null

     */

    protected final void openSessionForRead(String applicationId, List<String> permissions) {

        openSessionForRead(applicationId, permissions, SessionLoginBehavior.SSO_WITH_FALLBACK,

                Session.DEFAULT_AUTHORIZE_ACTIVITY_CODE);

    }

    /**

     * Opens a new session with read permissions. If either applicationID or permissions

     * is null, this method will default to using the values from the associated

     * meta-data value and an empty list respectively.

     *

     * @param applicationId the applicationID, can be null

     * @param permissions the permissions list, can be null

     * @param behavior the login behavior to use with the session

     * @param activityCode the activity code to use for the SSO activity

     */

    protected final void openSessionForRead(String applicationId, List<String> permissions,

            SessionLoginBehavior behavior, int activityCode) {

        openSession(applicationId, permissions, behavior, activityCode, SessionAuthorizationType.READ);

    }

    /**

     * Opens a new session with publish permissions. If either applicationID is null,

     * this method will default to using the value from the associated

     * meta-data value. The permissions list cannot be null.

     *

     * @param applicationId the applicationID, can be null

     * @param permissions the permissions list, cannot be null

     */

    protected final void openSessionForPublish(String applicationId, List<String> permissions) {

        openSessionForPublish(applicationId, permissions, SessionLoginBehavior.SSO_WITH_FALLBACK,

                Session.DEFAULT_AUTHORIZE_ACTIVITY_CODE);

    }

    /**

     * Opens a new session with publish permissions. If either applicationID is null,

     * this method will default to using the value from the associated

     * meta-data value. The permissions list cannot be null.

     *

     * @param applicationId the applicationID, can be null

     * @param permissions the permissions list, cannot be null

     * @param behavior the login behavior to use with the session

     * @param activityCode the activity code to use for the SSO activity

     */

    protected final void openSessionForPublish(String applicationId, List<String> permissions,

            SessionLoginBehavior behavior, int activityCode) {

        openSession(applicationId, permissions, behavior, activityCode, SessionAuthorizationType.PUBLISH);

    }

    private void openSession(String applicationId, List<String> permissions,

            SessionLoginBehavior behavior, int activityCode, SessionAuthorizationType authType) {

        if (sessionTracker != null) {

            Session currentSession = sessionTracker.getSession();

            if (currentSession == null || currentSession.getState().isClosed()) {

                Session session = new Session.Builder(getActivity()).setApplicationId(applicationId).build();

                Session.setActiveSession(session);

                currentSession = session;

            }

            if (!currentSession.isOpened()) {

                Session.OpenRequest openRequest = new Session.OpenRequest(this).

                        setPermissions(permissions).

                        setLoginBehavior(behavior).

                        setRequestCode(activityCode);

                if (SessionAuthorizationType.PUBLISH.equals(authType)) {

                    currentSession.openForPublish(openRequest);

                } else {

                    currentSession.openForRead(openRequest);

                }

            }

        }

    }

    /**

     * The default callback implementation for the session.

     */

    private class DefaultSessionStatusCallback implements Session.StatusCallback {

        @Override

        public void call(Session session, 

                         SessionState state,

                         Exception exception) {

            FacebookFragment.this.onSessionStateChange(state, exception);

        }

    }

}