com.nijie.samples.facebookfoo.FacebookFooMainActivity.java Source code

Java tutorial

Introduction

Here is the source code for com.nijie.samples.facebookfoo.FacebookFooMainActivity.java

Source

/**
 * 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.nijie.samples.facebookfoo;

import android.app.AlertDialog;
import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.location.Location;
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentActivity;
import android.support.v4.app.FragmentManager;
import android.text.TextUtils;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;

import com.facebook.AccessToken;
import com.facebook.AppEventsLogger;
import com.facebook.FacebookAuthorizationException;
import com.facebook.FacebookException;
import com.facebook.FacebookOperationCanceledException;
import com.facebook.FacebookRequestError;
import com.facebook.Request;
import com.facebook.Response;
import com.facebook.Session;
import com.facebook.SessionState;
import com.facebook.UiLifecycleHelper;
import com.facebook.model.GraphObject;
import com.facebook.model.GraphPlace;
import com.facebook.model.GraphUser;
import com.facebook.widget.FacebookDialog;
import com.facebook.widget.FriendPickerFragment;
import com.facebook.widget.LoginButton;
import com.facebook.widget.PickerFragment;
import com.facebook.widget.PlacePickerFragment;
import com.facebook.widget.ProfilePictureView;

import org.json.JSONArray;
import org.json.JSONObject;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;

public class FacebookFooMainActivity extends FragmentActivity {

    private static final String PERMISSION = "publish_actions";
    private static final String PAGE_PERMISSION = "manage_pages";
    private static final Location SEATTLE_LOCATION = new Location("") {
        {
            setLatitude(47.6097);
            setLongitude(-122.3331);
        }
    };

    private final String PENDING_ACTION_BUNDLE_KEY = "com.nijie.samples.facebookfoo:PendingAction";

    private Button postRegularPostButton;
    private Button postUnpublishedPostButton;
    private Button listAllPostsButton;
    private Button showStatisticsButton;
    private LoginButton loginButton;
    private ProfilePictureView profilePictureView;
    private TextView greeting;
    private PendingAction pendingAction = PendingAction.NONE;
    private ViewGroup controlsContainer;
    private GraphUser user;
    private GraphPlace place;
    private List<GraphUser> tags;
    private boolean canPresentShareDialog;
    private boolean canPresentShareDialogWithPhotos;

    private Session userInfoSession = null;
    private Session pageManageSession = null;

    private final Context mContext = null;
    private String page_id = null;

    private final HashMap<String, PostsRecord> postsTable = new HashMap<String, PostsRecord>();

    private enum PendingAction {
        NONE, POST_PHOTO, POST_PUBLISHED, POST_UNPUBLISHED
    }

    private UiLifecycleHelper uiHelper;

    private Session.StatusCallback callback = new Session.StatusCallback() {
        @Override
        public void call(Session session, SessionState state, Exception exception) {
            onSessionStateChange(session, state, exception);
        }
    };

    private FacebookDialog.Callback dialogCallback = new FacebookDialog.Callback() {
        @Override
        public void onError(FacebookDialog.PendingCall pendingCall, Exception error, Bundle data) {
            Log.d("facebookfoo", String.format("Error: %s", error.toString()));
        }

        @Override
        public void onComplete(FacebookDialog.PendingCall pendingCall, Bundle data) {
            Log.d("facebookfoo", "Success!");
        }
    };

    @Override
    public void onCreate(Bundle savedInstanceState) {

        Log.d("facebookfoo ###############", "FacebookFooMainActivity create!");
        super.onCreate(savedInstanceState);
        uiHelper = new UiLifecycleHelper(this, callback);
        uiHelper.onCreate(savedInstanceState);

        if (savedInstanceState != null) {
            String name = savedInstanceState.getString(PENDING_ACTION_BUNDLE_KEY);
            pendingAction = PendingAction.valueOf(name);
        }

        setContentView(R.layout.main);

        loginButton = (LoginButton) findViewById(R.id.login_button);
        loginButton.setPublishPermissions(PAGE_PERMISSION);
        loginButton.setUserInfoChangedCallback(new LoginButton.UserInfoChangedCallback() {
            @Override
            public void onUserInfoFetched(GraphUser user) {
                FacebookFooMainActivity.this.user = user;
                Log.d("facebookfoo ###############", "onUserInfoFetched!");
                updateUI();
                // It's possible that we were waiting for this.user to be populated in order to post a
                // status update.
                handlePendingAction();
            }
        });

        profilePictureView = (ProfilePictureView) findViewById(R.id.profilePicture);
        greeting = (TextView) findViewById(R.id.greeting);

        postRegularPostButton = (Button) findViewById(R.id.regularPostUpdateButton);
        postRegularPostButton.setOnClickListener(new View.OnClickListener() {
            public void onClick(View view) {
                onClickPostRegularPost();
            }
        });

        postUnpublishedPostButton = (Button) findViewById(R.id.postUnpublishedPostButton);
        postUnpublishedPostButton.setOnClickListener(new View.OnClickListener() {
            public void onClick(View view) {
                onClickPostUnpublishedPost();
            }
        });

        listAllPostsButton = (Button) findViewById(R.id.listAllPostsButton);
        listAllPostsButton.setOnClickListener(new View.OnClickListener() {
            public void onClick(View view) {
                onClickListAllPosts();
            }
        });

        showStatisticsButton = (Button) findViewById(R.id.showStatisticsButton);
        showStatisticsButton.setOnClickListener(new View.OnClickListener() {
            public void onClick(View view) {
                onClickShowStatistics();
            }
        });

        controlsContainer = (ViewGroup) findViewById(R.id.main_ui_container);

        final FragmentManager fm = getSupportFragmentManager();
        Fragment fragment = fm.findFragmentById(R.id.fragment_container);
        if (fragment != null) {
            // If we're being re-created and have a fragment, we need to a) hide the main UI controls and
            // b) hook up its listeners again.
            controlsContainer.setVisibility(View.GONE);
            if (fragment instanceof FriendPickerFragment) {
                setFriendPickerListeners((FriendPickerFragment) fragment);
            } else if (fragment instanceof PlacePickerFragment) {
                setPlacePickerListeners((PlacePickerFragment) fragment);
            }
        }

        // Listen for changes in the back stack so we know if a fragment got popped off because the user
        // clicked the back button.
        fm.addOnBackStackChangedListener(new FragmentManager.OnBackStackChangedListener() {
            @Override
            public void onBackStackChanged() {
                if (fm.getBackStackEntryCount() == 0) {
                    // We need to re-show our UI.
                    controlsContainer.setVisibility(View.VISIBLE);
                }
            }
        });

        // Can we present the share dialog for regular links?
        canPresentShareDialog = FacebookDialog.canPresentShareDialog(this,
                FacebookDialog.ShareDialogFeature.SHARE_DIALOG);
        // Can we present the share dialog for photos?
        canPresentShareDialogWithPhotos = FacebookDialog.canPresentShareDialog(this,
                FacebookDialog.ShareDialogFeature.PHOTOS);

        Log.d("facebookfoo ###############", "OnCreate Exit!");
    }

    @Override
    protected void onResume() {
        super.onResume();
        uiHelper.onResume();

        // Call the 'activateApp' method to log an app event for use in analytics and advertising reporting.  Do so in
        // the onResume methods of the primary Activities that an app may be launched into.
        AppEventsLogger.activateApp(this);

        updateUI();
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        uiHelper.onSaveInstanceState(outState);

        outState.putString(PENDING_ACTION_BUNDLE_KEY, pendingAction.name());
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        uiHelper.onActivityResult(requestCode, resultCode, data, dialogCallback);
    }

    @Override
    public void onPause() {
        super.onPause();
        uiHelper.onPause();

        // Call the 'deactivateApp' method to log an app event for use in analytics and advertising
        // reporting.  Do so in the onPause methods of the primary Activities that an app may be launched into.
        AppEventsLogger.deactivateApp(this);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        uiHelper.onDestroy();
    }

    private void onSessionStateChange(Session session, SessionState state, Exception exception) {
        if (pendingAction != PendingAction.NONE && (exception instanceof FacebookOperationCanceledException
                || exception instanceof FacebookAuthorizationException)) {
            new AlertDialog.Builder(FacebookFooMainActivity.this).setTitle(R.string.cancelled)
                    .setMessage(R.string.permission_not_granted).setPositiveButton(R.string.ok, null).show();
            pendingAction = PendingAction.NONE;
        } else if (state == SessionState.OPENED_TOKEN_UPDATED) {
            handlePendingAction();
        }
        updateUI();
    }

    private void updateUI() {
        Session session = Session.getActiveSession();

        if (session != null)
            userInfoSession = session;

        boolean enableButtons = (session != null && session.isOpened());

        postRegularPostButton.setEnabled(enableButtons);
        postUnpublishedPostButton.setEnabled(enableButtons);
        listAllPostsButton.setEnabled(enableButtons);
        showStatisticsButton.setEnabled(enableButtons);

        if (enableButtons && user != null) {
            profilePictureView.setProfileId(user.getId());
            greeting.setText(getString(R.string.hello_user, user.getFirstName()));
            retriveUserPages();
        } else {
            profilePictureView.setProfileId(null);
            greeting.setText(null);
        }
    }

    @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_PHOTO:
            postPhoto();
            break;
        case POST_PUBLISHED:
            postStatusUpdate(true);//[NJ] a published post
            break;
        case POST_UNPUBLISHED:
            postStatusUpdate(false);//[NJ] an unpublished post
            break;

        }
    }

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

        new AlertDialog.Builder(this).setTitle(title).setMessage(alertMessage).setPositiveButton(R.string.ok, null)
                .show();
    }

    private void onClickPostRegularPost() {
        performPublish(PendingAction.POST_PUBLISHED, canPresentShareDialog);
    }

    private FacebookDialog.ShareDialogBuilder createShareDialogBuilderForLink() {
        return new FacebookDialog.ShareDialogBuilder(this).setName("Hello Nature View FIG")
                .setDescription("The 'FacebookFooApp' application showcases what it needs to do for you")
                .setLink("http://developers.facebook.com/android");
    }

    //[NJ] Doing the actual job to make a request to "/{page_id}/feed" with intended published flag
    private void postStatusUpdate(boolean published) {
        if (user != null && hasPublishPermission()) {
            final String message = getString(R.string.status_update, user.getFirstName(), (new Date().toString()));
            final String graphPath = page_id + "/feed";
            //final String graphPath = "435557046594813/feed";
            Request request = Request.newStatusUpdateRequest(Session.getActiveSession(), graphPath, message,
                    published, new Request.Callback() {
                        @Override
                        public void onCompleted(Response response) {
                            Log.d("facebookfoo ###############", "result: " + response.toString());
                            showPublishResult(message, response.getGraphObject(), response.getError());
                        }
                    });
            request.executeAsync();
        } else {
            pendingAction = PendingAction.POST_PUBLISHED;
        }

    }

    private void onClickPostUnpublishedPost() {
        performPublish(PendingAction.POST_UNPUBLISHED, canPresentShareDialog);
    }

    private FacebookDialog.PhotoShareDialogBuilder createShareDialogBuilderForPhoto(Bitmap... photos) {
        return new FacebookDialog.PhotoShareDialogBuilder(this).addPhotos(Arrays.asList(photos));
    }

    private void postPhoto() {
        Bitmap image = BitmapFactory.decodeResource(this.getResources(), R.drawable.icon);
        if (canPresentShareDialogWithPhotos) {
            FacebookDialog shareDialog = createShareDialogBuilderForPhoto(image).build();
            uiHelper.trackPendingDialogCall(shareDialog.present());
        } else if (hasPublishPermission()) {
            Request request = Request.newUploadPhotoRequest(Session.getActiveSession(), image,
                    new Request.Callback() {
                        @Override
                        public void onCompleted(Response response) {
                            showPublishResult(getString(R.string.photo_post), response.getGraphObject(),
                                    response.getError());
                        }
                    });
            request.executeAsync();
        } else {
            pendingAction = PendingAction.POST_PHOTO;
        }
    }

    private void showPickerFragment(PickerFragment<?> fragment) {
        fragment.setOnErrorListener(new PickerFragment.OnErrorListener() {
            @Override
            public void onError(PickerFragment<?> pickerFragment, FacebookException error) {
                String text = getString(R.string.exception, error.getMessage());
                Toast toast = Toast.makeText(FacebookFooMainActivity.this, text, Toast.LENGTH_SHORT);
                toast.show();
            }
        });

        FragmentManager fm = getSupportFragmentManager();
        fm.beginTransaction().replace(R.id.fragment_container, fragment).addToBackStack(null).commit();

        controlsContainer.setVisibility(View.GONE);

        // We want the fragment fully created so we can use it immediately.
        fm.executePendingTransactions();

        fragment.loadData(true);
    }

    private void showListPostsFragment(ListPostsFragment fragment) {
        FragmentManager fm = getSupportFragmentManager();
        fm.beginTransaction().replace(R.id.fragment_container, fragment).addToBackStack(null).commit();

        controlsContainer.setVisibility(View.GONE);

        // We want the fragment fully created so we can use it immediately.
        fm.executePendingTransactions();

    }

    private void parsePagePosts(GraphObject result, FacebookRequestError error) {
        String title = null;
        String alertMessage = null;

        if (error == null) {
            Log.d("facebookfoo ###############", "retrievig posts success");
            try {
                JSONArray page_posts = result.getInnerJSONObject().getJSONArray("data");

                Log.d("facebookfoo ###############", "retrievig user posts length : " + page_posts.length());

                for (int i = 0; i < page_posts.length(); i++) {
                    Log.d("facebookfoo ##############", "post id : " + i);
                    JSONObject item = page_posts.getJSONObject(i);
                    String post_id = item.getString("id");
                    //Log.d("facebookfoo ##############", "post id : " + post_id);
                    String story = item.getString("story");
                    //Log.d("facebookfoo ##############","story : " + story);
                    String message = item.getString("type");
                    //Log.d("facebookfoo ##############","type : " + message);
                    String updated_time = item.getString("updated_time");
                    // Log.d("facebookfoo ##############","updated_time : " + updated_time);
                    //boolean ispublished = item.getString("")
                    if (!postsTable.containsKey(post_id)) {
                        postsTable.put(post_id, new PostsRecord(post_id, story, message, updated_time, true));
                    }

                    // Log.d("facebookfoo ##############","is_published : " + );

                }
            } catch (Exception e) {
            }

        } else {
            Log.d("facebookfoo ###############", "retrievig page posts fail");
        }

    }

    private void onClickListAllPosts() {

        final ListPostsFragment fragment = new ListPostsFragment();

        fragment.setTargetPageID(page_id);

        fragment.setTitleText(getString(R.string.listpost_title));

        setListPostListeners(fragment);

        showPickerFragment(fragment);

    }

    private void setFriendPickerListeners(final FriendPickerFragment fragment) {
        fragment.setOnDoneButtonClickedListener(new FriendPickerFragment.OnDoneButtonClickedListener() {
            @Override
            public void onDoneButtonClicked(PickerFragment<?> pickerFragment) {
                onFriendPickerDone(fragment);
            }
        });
    }

    private void onFriendPickerDone(FriendPickerFragment fragment) {
        FragmentManager fm = getSupportFragmentManager();
        fm.popBackStack();

        String results = "";

        List<GraphUser> selection = fragment.getSelection();
        tags = selection;
        if (selection != null && selection.size() > 0) {
            ArrayList<String> names = new ArrayList<String>();
            for (GraphUser user : selection) {
                names.add(user.getName());
            }
            results = TextUtils.join(", ", names);
        } else {
            results = getString(R.string.no_friends_selected);
        }

        showAlert(getString(R.string.you_picked), results);
    }

    private void onPlacePickerDone(PlacePickerFragment fragment) {
        FragmentManager fm = getSupportFragmentManager();
        fm.popBackStack();

        String result = "";

        GraphPlace selection = fragment.getSelection();
        if (selection != null) {
            result = selection.getName();
        } else {
            result = getString(R.string.no_place_selected);
        }

        place = selection;

        showAlert(getString(R.string.you_picked), result);
    }

    private void onPostListDone(ListPostsFragment fragment) {
        FragmentManager fm = getSupportFragmentManager();
        fm.popBackStack();

        String result = "";

    }

    private void setListPostListeners(final ListPostsFragment fragment) {
        fragment.setOnDoneButtonClickedListener(new ListPostsFragment.OnDoneButtonClickedListener() {
            @Override
            public void onDoneButtonClicked(PickerFragment<?> pickerFragment) {
                onPostListDone(fragment);
            }
        });
        fragment.setOnSelectionChangedListener(new ListPostsFragment.OnSelectionChangedListener() {
            @Override
            public void onSelectionChanged(PickerFragment<?> pickerFragment) {
                if (fragment.getSelection() != null) {
                    onPostListDone(fragment);
                }
            }
        });
    }

    private void onClickShowStatistics() {

        if (page_id == null)
            return;

        final String graphPath = page_id + "/promotable_posts";
        Request request = Request.newMyPageRequest(userInfoSession, graphPath, new Request.GraphUserCallback() {
            @Override
            public void onCompleted(GraphUser me, Response response) {

                Log.d("facebookfoo ###############", "response " + response.toString());
                parsePagePosts(response.getGraphObject(), response.getError());

            }
        });
        Request.executeBatchAsync(request);

    }

    private void parseUserPages(GraphObject result, FacebookRequestError error) {
        String title = null;
        String alertMessage = null;

        if (error == null) {
            Log.d("facebookfoo ###############", "retrievig user pages success");
            try {
                JSONArray user_pages = result.getInnerJSONObject().getJSONArray("data");

                for (int i = 0; i < user_pages.length(); i++) {
                    JSONObject item = user_pages.getJSONObject(i);
                    page_id = item.getString("id");
                    Log.d("facebookfoo ##############", "id : " + page_id);
                    Log.d("facebookfoo ##############", "category : " + item.getString("category"));
                    Log.d("facebookfoo ##############", "perms : " + item.getString("perms"));
                    String accessToken = item.getString("access_token");

                    if (accessToken != null) {
                        Log.d("facebookfoo ##############", "access_token : " + accessToken);
                        Session session = Session.getActiveSession();
                        AccessToken currentToken = session.getTokenInfo();
                        /*[NJ] Need to use the page access token in the session, with a couple of changes in the facebook sdk
                         1. make setTokenInfo public
                         2. Make AccessToken pubic
                        */
                        session.setTokenInfo(new AccessToken(accessToken, currentToken.getExpires(),
                                currentToken.getPermissions(), currentToken.getDeclinedPermissions(),
                                currentToken.getSource(), currentToken.getLastRefresh()));

                    }

                }
            } catch (Exception e) {
            }

        } else {
            Log.d("facebookfoo ###############", "retrievig user pages fail");
        }

    }

    private void retriveUserPages() {
        Log.d("facebookfoo ###############", "retrievig user pages");

        Request request = Request.newMyAccountsRequest(userInfoSession, new Request.GraphUserCallback() {
            @Override
            public void onCompleted(GraphUser me, Response response) {

                Log.d("facebookfoo ###############", "response " + response.toString());

                parseUserPages(response.getGraphObject(), response.getError());
            }
        });
        Request.executeBatchAsync(request);

    }

    private void setPlacePickerListeners(final PlacePickerFragment fragment) {
        fragment.setOnDoneButtonClickedListener(new PlacePickerFragment.OnDoneButtonClickedListener() {
            @Override
            public void onDoneButtonClicked(PickerFragment<?> pickerFragment) {
                onPlacePickerDone(fragment);
            }
        });
        fragment.setOnSelectionChangedListener(new PlacePickerFragment.OnSelectionChangedListener() {
            @Override
            public void onSelectionChanged(PickerFragment<?> pickerFragment) {
                if (fragment.getSelection() != null) {
                    onPlacePickerDone(fragment);
                }
            }
        });
    }

    private void showAlert(String title, String message) {
        new AlertDialog.Builder(this).setTitle(title).setMessage(message).setPositiveButton(R.string.ok, null)
                .show();
    }

    private boolean hasPublishPermission() {
        Session session = Session.getActiveSession();
        return session != null && session.getPermissions().contains("publish_actions");
    }

    private void performPublish(PendingAction action, boolean allowNoSession) {
        Session session = Session.getActiveSession();
        if (session != null) {
            Log.d("facebookfoo #############", "session not null");
            pendingAction = action;
            if (hasPublishPermission()) {
                // We can do the action right away.
                handlePendingAction();
                return;
            } else if (session.isOpened()) {
                // We need to get new permissions, then complete the action when we get called back.
                session.requestNewPublishPermissions(new Session.NewPermissionsRequest(this, PERMISSION));

                return;
            }
        }

        if (allowNoSession) {
            pendingAction = action;
            handlePendingAction();
        }
    }
}