Изображение post в facebook wall from android sdcard

Question

Я просто хочу размещать изображения с моей Android-карты в facebook wall.I использовал ниже код. Но не смог увидеть изображение на стене FB.

Мой код:

private void fbWallPost() { 
       facebook = new Facebook("My appId"); 
       asyncRunner = new AsyncFacebookRunner(facebook); 
       facebook.authorize(facebook.this, new String[] { "user_status", 
         "user_about_me", "email", "read_stream", 
         "publish_stream" }, new DialogListener() { 

       public void onComplete(Bundle values) { 

        JSONObject jObject; 
        try { 
         jObject = new JSONObject(facebook.request("me")); 
         FileInputStream fis = new FileInputStream(
           "/sdcard/codeofaninja.jpg"); 
         Bitmap bi = BitmapFactory.decodeStream(fis); 
         ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
         bi.compress(Bitmap.CompressFormat.JPEG, 100, baos); 
         data = baos.toByteArray(); 

         Bundle params = new Bundle(); 
         params.putString("method", "photos.upload"); 
         params.putByteArray("picture", data); 

         asyncRunner.request("me/photos", params, "POST", 
           new mRequestListener(), null); 

        } catch (MalformedURLException e) { 

         e.printStackTrace(); 
        } catch (JSONException e) { 

         e.printStackTrace(); 
        } catch (IOException e) { 

         e.printStackTrace(); 
        } 
       } 

       public void onFacebookError(FacebookError error) { 
        Toast.makeText(facebook.this, 
          "Facebook onFacebookError", Toast.LENGTH_LONG) 
          .show(); 
       } 

       public void onError(DialogError e) { 
        Toast.makeText(facebook.this, "Facebook onError", 
          Toast.LENGTH_LONG).show(); 
       } 

       public void onCancel() { 

       } 
      }); 
     } 

    }); 

Answer 1

вы можете использовать этот код для доли изображения формы SDCard

public void shareimage(View v) { 


     Intent share = new Intent(Intent.ACTION_SEND); 
     share.setType("image/jpeg"); 

     share.putExtra(Intent.EXTRA_STREAM,Uri.parse(
     "file:///mnt/sdcard/test/v1327056571768.3gpp")); 

     startActivity(Intent.createChooser(share, "Share Image")); 

} 

А также следует следующим link, я отправил на моем блоге.

Answer 2

Привет, пожалуйста, проверьте следующий код может его поможет вам: -

package com.example.facebookuploadandroid; 

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

import android.app.AlertDialog; 
import android.content.Intent; 
import android.graphics.Bitmap; 
import android.graphics.BitmapFactory; 
import android.graphics.drawable.Drawable.Callback; 
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.AppEventsLogger; 
import com.facebook.FacebookAuthorizationException; 
import com.facebook.FacebookException; 
import com.facebook.FacebookOperationCanceledException; 
import com.facebook.FacebookRequestError; 
import com.facebook.HttpMethod; 
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; 

public class MainActivity 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.facebook.samples.hellofacebook: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<GraphUser> tags; 
    private boolean canPresentShareDialog; 
    private boolean canPresentShareDialogWithPhotos; 

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

     setContentView(R.layout.main); 

     loginButton = (LoginButton) findViewById(R.id.login_button); 
     loginButton.setUserInfoChangedCallback(new LoginButton.UserInfoChangedCallback() { 
      @Override 
      public void onUserInfoFetched(GraphUser user) { 
       MainActivity.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); 
       } 
      } 
     }); 

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

    @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(MainActivity.this).setTitle("Cancle").setMessage("Not Granted").setPositiveButton("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 && session.isOpened()); 

     postStatusUpdateButton.setEnabled(enableButtons || canPresentShareDialog); 
     postPhotoButton.setEnabled(enableButtons || canPresentShareDialogWithPhotos); 
     pickFriendsButton.setEnabled(enableButtons); 
     pickPlaceButton.setEnabled(enableButtons); 

     if (enableButtons && user != null) { 
      profilePictureView.setProfileId(user.getId()); 
      greeting.setText(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 = "success"; 
      String id = result.cast(GraphObjectWithId.class).getId(); 
      alertMessage = "successfully_posted_post"; 
     } else { 
      title = "error"; 
      alertMessage = error.getErrorMessage(); 
     } 

     new AlertDialog.Builder(this).setTitle(title).setMessage(alertMessage).setPositiveButton("Ok", null).show(); 
    } 

    private void onClickPostStatusUpdate() { 
     performPublish(PendingAction.POST_STATUS_UPDATE, canPresentShareDialog); 
    } 

    private FacebookDialog.ShareDialogBuilder createShareDialogBuilderForLink() { 
     return new FacebookDialog.ShareDialogBuilder(this).setName("Hello Facebook") 
       .setDescription("The 'Hello Facebook' sample application showcases simple Facebook integration") 
       .setLink("http://developers.facebook.com/android"); 
    } 

    private void postStatusUpdate() { 
     if (canPresentShareDialog) { 
      FacebookDialog shareDialog = createShareDialogBuilderForLink().build(); 
      uiHelper.trackPendingDialogCall(shareDialog.present()); 
     } else if (user != null && hasPublishPermission()) { 
      final String message = user.getFirstName(); 
      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, canPresentShareDialogWithPhotos); 
    } 

    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.ic_launcher); 
     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("photo_post", response.getGraphObject(), 
      // response.getError()); 
      // } 
      // }); 
      // request.executeAsync(); 
      Request request = newMyUploadPhotoRequest(Session.getActiveSession(), image, "Teste Caption", "teste description", 
        new Request.Callback() { 
         @Override 
         public void onCompleted(Response response) { 
          showPublishResult("POSTED", response.getGraphObject(), response.getError()); 
         } 
        }); 
      Request.executeBatchAsync(request); 
     } else { 
      pendingAction = PendingAction.POST_PHOTO; 
     } 
    } 

    public static Request newMyUploadPhotoRequest(Session session, Bitmap image, String caption, String description, 
      com.facebook.Request.Callback callback2) { 
     Bundle parameters = new Bundle(3); 
     parameters.putParcelable("picture", image); 
     parameters.putString("caption", caption); 
     parameters.putString("description", description); 

     return new Request(session, "me/photos", parameters, HttpMethod.POST, callback2); 

    } 

    // public static Request newMyUploadPhotoRequest(Session session, Bitmap 
    // image, String caption,String description, 
    // Callback callback) { 
    // Bundle parameters = new Bundle(3); 
    // parameters.putParcelable(PICTURE_PARAM, image); 
    // parameters.putString("caption",caption); 
    // parameters.putString("description",description); 
    // 
    // return new Request(session, MY_PHOTOS, parameters, HttpMethod.POST, 
    // callback); 
    // 
    // } 

    private void showPickerFragment(PickerFragment<?> fragment) { 
     fragment.setOnErrorListener(new PickerFragment.OnErrorListener() { 
      @Override 
      public void onError(PickerFragment<?> pickerFragment, FacebookException error) { 
       String text = "Exception"; 
       Toast toast = Toast.makeText(MainActivity.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<?> 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 = "no_friends_selected"; 
     } 

     showAlert("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 = "no_place_selected"; 
     } 

     place = selection; 

     showAlert("you_picked", result); 
    } 

    private void onClickPickPlace() { 
     final PlacePickerFragment fragment = new PlacePickerFragment(); 
     fragment.setLocation(SEATTLE_LOCATION); 
     fragment.setTitleText("pick_seattle_place"); 

     setPlacePickerListeners(fragment); 

     showPickerFragment(fragment); 
    } 

    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("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) { 
      pendingAction = action; 
      if (hasPublishPermission()) { 
       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(); 
     } 
    } 
}