title: Android :: Facebook like button
body: <p>I'm learning how to use the Facebook SDK, and i like to put a like button to the application i'm testing on it, and unfortunately i'm doing something wrong, so can you please show a sample or a code that apply the like button, here is the class that am working on.</p>
  
  <pre><code>/**
   * 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.PACKAGE_NAME;
  
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.List;
  
  import android.app.AlertDialog;
  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.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 com.facebook.widget.WebDialog;
  import com.facebook.widget.WebDialog.OnCompleteListener;
  
  public class FacebookClass extends FragmentActivity {
  
      private static final String PERMISSION = "publish_actions";
      private static final Location SEATTLE_LOCATION = new Location("") {
          {
              setLatitude(47.6097);
              setLongitude(-122.3331);
          }
      };
  
      private final String PENDING_ACTION_BUNDLE_KEY = "com.PACKAGE_NAME:PendingAction";
  
      private Button postStatusUpdateButton;
      // private Button postPhotoButton;
      private Button pickFriendsButton;
      // private Button pickPlaceButton;
      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&lt;GraphUser&gt; tags;
      private boolean canPresentShareDialog;
  
      private enum PendingAction {
          NONE, POST_PHOTO, POST_STATUS_UPDATE
      }
  
      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("HelloFacebook", String.format("Error: %s", error.toString()));
          }
  
          @Override
          public void onComplete(FacebookDialog.PendingCall pendingCall,
                  Bundle data) {
              Log.d("HelloFacebook", "Success!");
          }
      };
  
      @Override
      public void onCreate(Bundle savedInstanceState) {
          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);
          }
  
          // try {
          // PackageInfo info = getPackageManager().getPackageInfo(
          // "com.facebook.samples.hellofacebook",
          // PackageManager.GET_SIGNATURES);
          // for (android.content.pm.Signature signature : info.signatures) {
          // MessageDigest md = MessageDigest.getInstance("SHA");
          // md.update(signature.toByteArray());
          // Log.d("YOURHASH KEY:",
          // Base64.encodeToString(md.digest(), Base64.DEFAULT));
          // }
          // } catch (NameNotFoundException e) {
          // System.out.println();
          // } catch (NoSuchAlgorithmException e) {
          // System.out.println();
          // } catch (Exception e) {
          // // TODO: handle exception
          // System.out.println();
          // }
  
          setContentView(R.layout.activity_more);
  
          loginButton = (LoginButton) findViewById(R.id.login_button);
          loginButton
                  .setUserInfoChangedCallback(new LoginButton.UserInfoChangedCallback() {
                      @Override
                      public void onUserInfoFetched(GraphUser user) {
                          FacebookClass.this.user = user;
                          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);
  
          postStatusUpdateButton = (Button) findViewById(R.id.postStatusUpdateButton);
          postStatusUpdateButton.setOnClickListener(new View.OnClickListener() {
              public void onClick(View view) {
                  onClickPostStatusUpdate();
              }
          });
  
          // postPhotoButton = (Button) findViewById(R.id.postPhotoButton);
          // postPhotoButton.setOnClickListener(new View.OnClickListener() {
          // public void onClick(View view) {
          // onClickPostPhoto();
          // }
          // });
  
          pickFriendsButton = (Button) findViewById(R.id.pickFriendsButton);
          pickFriendsButton.setOnClickListener(new View.OnClickListener() {
              public void onClick(View view) {
                  onClickPickFriends();
              }
          });
  
          // pickPlaceButton = (Button) findViewById(R.id.pickPlaceButton);
          // pickPlaceButton.setOnClickListener(new View.OnClickListener() {
          // public void onClick(View view) {
          // onClickPickPlace();
          // }
          // });
  
          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);
                  }
              }
          });
  
          canPresentShareDialog = FacebookDialog.canPresentShareDialog(this,
                  FacebookDialog.ShareDialogFeature.SHARE_DIALOG);
      }
  
      @Override
      protected void onResume() {
          super.onResume();
          uiHelper.onResume();
  
          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();
      }
  
      @Override
      public void onDestroy() {
          super.onDestroy();
          uiHelper.onDestroy();
      }
  
      private void onSessionStateChange(Session session, SessionState state,
              Exception exception) {
          if (pendingAction != PendingAction.NONE
                  &amp;&amp; (exception instanceof FacebookOperationCanceledException || exception instanceof FacebookAuthorizationException)) {
              new AlertDialog.Builder(FacebookClass.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();
          boolean enableButtons = (session != null &amp;&amp; session.isOpened());
  
          postStatusUpdateButton.setEnabled(enableButtons
                  || canPresentShareDialog);
          // postPhotoButton.setEnabled(enableButtons);
          pickFriendsButton.setEnabled(enableButtons);
          // pickPlaceButton.setEnabled(enableButtons);
  
          if (enableButtons &amp;&amp; user != null) {
              profilePictureView.setProfileId(user.getId());
              greeting.setText(getString(R.string.hello_user, user.getFirstName()));
          } 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_STATUS_UPDATE:
              postStatusUpdate();
              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 onClickPostStatusUpdate() {
          performPublish(PendingAction.POST_STATUS_UPDATE, canPresentShareDialog);
      }
  
      private FacebookDialog.ShareDialogBuilder createShareDialogBuilder() {
  
          return new FacebookDialog.ShareDialogBuilder(this)
                  .setName("Hi")
                  .setDescription("Hello D")
                  .setLink(
                          "LINK")
                  .setPicture(
                          "http://tctechcrunch2011.files.wordpress.com/2013/03/facebook-android-clean1.png?w=259");
      }
  
      // ///////////////////////////////////
      private void publishFeedDialog() {
          Bundle params = new Bundle();
          params.putString("name", "Facebook SDK for Android");
          params.putString("caption",
                  "Build great social apps and get more installs.");
          params.putString(
                  "description",
                  "The Facebook SDK for Android makes it easier and faster to develop Facebook integrated Android apps.");
          params.putString("link", "https://developers.facebook.com/android");
          params.putString("picture",
                  "https://raw.github.com/fbsamples/ios-3.x-howtos/master/Images/iossdk_logo.png");
  
          WebDialog feedDialog = (new WebDialog.FeedDialogBuilder(this,
                  Session.getActiveSession(), params)).setOnCompleteListener(
                  new OnCompleteListener() {
  
                      @Override
                      public void onComplete(Bundle values,
                              FacebookException error) {
                          if (error == null) {
                              // When the story is posted, echo the success
                              // and the post Id.
                              final String postId = values.getString("post_id");
                              if (postId != null) {
                                  Toast.makeText(getApplicationContext(),
                                          "Posted story, id: " + postId,
                                          Toast.LENGTH_SHORT).show();
                              } else {
                                  // User clicked the Cancel button
                                  Toast.makeText(getApplicationContext(),
                                          "Publish cancelled", Toast.LENGTH_SHORT)
                                          .show();
                              }
                          } else if (error instanceof FacebookOperationCanceledException) {
                              // User clicked the "x" button
                              Toast.makeText(getApplicationContext(),
                                      "Publish cancelled", Toast.LENGTH_SHORT)
                                      .show();
                          } else {
                              // Generic, ex: network error
                              Toast.makeText(getApplicationContext(),
                                      "Error posting story", Toast.LENGTH_SHORT)
                                      .show();
                          }
                      }
  
                  }).build();
          feedDialog.show();
      }
  
      // //////////////////////////////////
  
      // private FacebookDialog.OpenGraphActionDialogBuilder
      // createActionDialogBuilder() {
      //
      // new FacebookDialog.OpenGraphActionDialogBuilder(MoreActivity.this,
      // OpenGraphAction.this.setType("me/PROJECT_NAME:start"), "like",
      // "");
      // return null;
      //
      // }
  
      private void postStatusUpdate() {
          if (canPresentShareDialog) {
              // FacebookDialog shareDialog = createActionDialogBuilder().build();
              // publishFeedDialog();
              FacebookDialog shareDialog = createShareDialogBuilder().build();
              uiHelper.trackPendingDialogCall(shareDialog.present());
          } else if (user != null &amp;&amp; hasPublishPermission()) {
              final String message = getString(R.string.status_update,
                      user.getFirstName(), (new Date().toString()));
              Request request = Request.newStatusUpdateRequest(
                      Session.getActiveSession(), message, place, tags,
                      new Request.Callback() {
                          @Override
                          public void onCompleted(Response response) {
                              showPublishResult(message,
                                      response.getGraphObject(),
                                      response.getError());
                          }
                      });
              request.executeAsync();
          } else {
              pendingAction = PendingAction.POST_STATUS_UPDATE;
          }
      }
  
      private void onClickPostPhoto() {
          performPublish(PendingAction.POST_PHOTO, false);
      }
  
      private void postPhoto() {
          if (hasPublishPermission()) {
              Bitmap image = BitmapFactory.decodeResource(this.getResources(),
                      R.drawable.icon);
              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&lt;?&gt; fragment) {
          fragment.setOnErrorListener(new PickerFragment.OnErrorListener() {
              @Override
              public void onError(PickerFragment&lt;?&gt; pickerFragment,
                      FacebookException error) {
                  String text = getString(R.string.exception, error.getMessage());
                  Toast toast = Toast.makeText(FacebookClass.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(false);
      }
  
      private void onClickPickFriends() {
          final FriendPickerFragment fragment = new FriendPickerFragment();
  
          setFriendPickerListeners(fragment);
  
          showPickerFragment(fragment);
      }
  
      private void setFriendPickerListeners(final FriendPickerFragment fragment) {
          fragment.setOnDoneButtonClickedListener(new FriendPickerFragment.OnDoneButtonClickedListener() {
              @Override
              public void onDoneButtonClicked(PickerFragment&lt;?&gt; pickerFragment) {
                  onFriendPickerDone(fragment);
              }
          });
      }
  
      private void onFriendPickerDone(FriendPickerFragment fragment) {
          FragmentManager fm = getSupportFragmentManager();
          fm.popBackStack();
  
          String results = "";
  
          List&lt;GraphUser&gt; selection = fragment.getSelection();
          tags = selection;
          if (selection != null &amp;&amp; selection.size() &gt; 0) {
              ArrayList&lt;String&gt; names = new ArrayList&lt;String&gt;();
              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 onClickPickPlace() {
          final PlacePickerFragment fragment = new PlacePickerFragment();
          fragment.setLocation(SEATTLE_LOCATION);
          fragment.setTitleText(getString(R.string.pick_seattle_place));
  
          setPlacePickerListeners(fragment);
  
          showPickerFragment(fragment);
      }
  
      private void setPlacePickerListeners(final PlacePickerFragment fragment) {
          fragment.setOnDoneButtonClickedListener(new PlacePickerFragment.OnDoneButtonClickedListener() {
              @Override
              public void onDoneButtonClicked(PickerFragment&lt;?&gt; pickerFragment) {
                  onPlacePickerDone(fragment);
              }
          });
          fragment.setOnSelectionChangedListener(new PlacePickerFragment.OnSelectionChangedListener() {
              @Override
              public void onSelectionChanged(PickerFragment&lt;?&gt; 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
                  &amp;&amp; session.getPermissions().contains("publish_actions");
      }
  
      private void performPublish(PendingAction action, boolean allowNoSession) {
          Session session = Session.getActiveSession();
          if (session != 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();
          }
      }
  }
  </code></pre>
  
  <p>Any help??</p>