diff options
Diffstat (limited to 'WordPress/src/main/java/org/wordpress/android/ui/reader/ReaderPostDetailFragment.java')
| -rw-r--r-- | WordPress/src/main/java/org/wordpress/android/ui/reader/ReaderPostDetailFragment.java | 1171 |
1 files changed, 1171 insertions, 0 deletions
diff --git a/WordPress/src/main/java/org/wordpress/android/ui/reader/ReaderPostDetailFragment.java b/WordPress/src/main/java/org/wordpress/android/ui/reader/ReaderPostDetailFragment.java new file mode 100644 index 000000000..da635bfe4 --- /dev/null +++ b/WordPress/src/main/java/org/wordpress/android/ui/reader/ReaderPostDetailFragment.java @@ -0,0 +1,1171 @@ +package org.wordpress.android.ui.reader; + +import android.app.Activity; +import android.app.Fragment; +import android.content.Intent; +import android.os.AsyncTask; +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.text.TextUtils; +import android.view.LayoutInflater; +import android.view.Menu; +import android.view.MenuInflater; +import android.view.MenuItem; +import android.view.View; +import android.view.ViewGroup; +import android.webkit.WebView; +import android.widget.ProgressBar; +import android.widget.TextView; + +import org.wordpress.android.R; +import org.wordpress.android.WordPress; +import org.wordpress.android.analytics.AnalyticsTracker; +import org.wordpress.android.datasets.ReaderLikeTable; +import org.wordpress.android.datasets.ReaderPostTable; +import org.wordpress.android.models.ReaderPost; +import org.wordpress.android.models.ReaderPostDiscoverData; +import org.wordpress.android.models.ReaderTag; +import org.wordpress.android.models.ReaderTagType; +import org.wordpress.android.ui.main.WPMainActivity; +import org.wordpress.android.ui.reader.ReaderActivityLauncher.OpenUrlType; +import org.wordpress.android.ui.reader.ReaderActivityLauncher.PhotoViewerOption; +import org.wordpress.android.ui.reader.ReaderInterfaces.AutoHideToolbarListener; +import org.wordpress.android.ui.reader.ReaderTypes.ReaderPostListType; +import org.wordpress.android.ui.reader.actions.ReaderActions; +import org.wordpress.android.ui.reader.actions.ReaderBlogActions; +import org.wordpress.android.ui.reader.actions.ReaderPostActions; +import org.wordpress.android.ui.reader.models.ReaderBlogIdPostId; +import org.wordpress.android.ui.reader.models.ReaderRelatedPost; +import org.wordpress.android.ui.reader.models.ReaderRelatedPostList; +import org.wordpress.android.ui.reader.utils.ReaderUtils; +import org.wordpress.android.ui.reader.utils.ReaderVideoUtils; +import org.wordpress.android.ui.reader.views.ReaderFollowButton; +import org.wordpress.android.ui.reader.views.ReaderIconCountView; +import org.wordpress.android.ui.reader.views.ReaderLikingUsersView; +import org.wordpress.android.ui.reader.views.ReaderWebView; +import org.wordpress.android.ui.reader.views.ReaderWebView.ReaderCustomViewListener; +import org.wordpress.android.ui.reader.views.ReaderWebView.ReaderWebViewPageFinishedListener; +import org.wordpress.android.ui.reader.views.ReaderWebView.ReaderWebViewUrlClickListener; +import org.wordpress.android.util.AnalyticsUtils; +import org.wordpress.android.util.AniUtils; +import org.wordpress.android.util.AppLog; +import org.wordpress.android.util.AppLog.T; +import org.wordpress.android.util.DateTimeUtils; +import org.wordpress.android.util.DisplayUtils; +import org.wordpress.android.util.GravatarUtils; +import org.wordpress.android.util.NetworkUtils; +import org.wordpress.android.util.PhotonUtils; +import org.wordpress.android.util.ToastUtils; +import org.wordpress.android.util.UrlUtils; +import org.wordpress.android.util.helpers.SwipeToRefreshHelper; +import org.wordpress.android.util.widgets.CustomSwipeRefreshLayout; +import org.wordpress.android.widgets.WPNetworkImageView; +import org.wordpress.android.widgets.WPScrollView; +import org.wordpress.android.widgets.WPScrollView.ScrollDirectionListener; + +import java.util.EnumSet; + +import de.greenrobot.event.EventBus; + +public class ReaderPostDetailFragment extends Fragment + implements WPMainActivity.OnActivityBackPressedListener, + ScrollDirectionListener, + ReaderCustomViewListener, + ReaderWebViewPageFinishedListener, + ReaderWebViewUrlClickListener { + + private long mPostId; + private long mBlogId; + private ReaderPost mPost; + private ReaderPostRenderer mRenderer; + private ReaderPostListType mPostListType; + + private final ReaderPostHistory mPostHistory = new ReaderPostHistory(); + + private SwipeToRefreshHelper mSwipeToRefreshHelper; + private WPScrollView mScrollView; + private ViewGroup mLayoutFooter; + private ReaderWebView mReaderWebView; + private ReaderLikingUsersView mLikingUsersView; + private View mLikingUsersDivider; + private View mLikingUsersLabel; + + private boolean mHasAlreadyUpdatedPost; + private boolean mHasAlreadyRequestedPost; + private boolean mIsLoggedOutReader; + private boolean mIsWebViewPaused; + private boolean mIsRelatedPost; + + private int mToolbarHeight; + private String mErrorMessage; + + private boolean mIsToolbarShowing = true; + private AutoHideToolbarListener mAutoHideToolbarListener; + + // min scroll distance before toggling toolbar + private static final float MIN_SCROLL_DISTANCE_Y = 10; + + public static ReaderPostDetailFragment newInstance(long blogId, long postId) { + return newInstance(blogId, postId, false, null); + } + + public static ReaderPostDetailFragment newInstance(long blogId, + long postId, + boolean isRelatedPost, + ReaderPostListType postListType) { + AppLog.d(T.READER, "reader post detail > newInstance"); + + Bundle args = new Bundle(); + args.putLong(ReaderConstants.ARG_BLOG_ID, blogId); + args.putLong(ReaderConstants.ARG_POST_ID, postId); + args.putBoolean(ReaderConstants.ARG_IS_RELATED_POST, isRelatedPost); + if (postListType != null) { + args.putSerializable(ReaderConstants.ARG_POST_LIST_TYPE, postListType); + } + + ReaderPostDetailFragment fragment = new ReaderPostDetailFragment(); + fragment.setArguments(args); + + return fragment; + } + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + mIsLoggedOutReader = ReaderUtils.isLoggedOutReader(); + if (savedInstanceState != null) { + mPostHistory.restoreInstance(savedInstanceState); + } + } + + @Override + public void setArguments(Bundle args) { + super.setArguments(args); + if (args != null) { + mBlogId = args.getLong(ReaderConstants.ARG_BLOG_ID); + mPostId = args.getLong(ReaderConstants.ARG_POST_ID); + mIsRelatedPost = args.getBoolean(ReaderConstants.ARG_IS_RELATED_POST); + if (args.containsKey(ReaderConstants.ARG_POST_LIST_TYPE)) { + mPostListType = (ReaderPostListType) args.getSerializable(ReaderConstants.ARG_POST_LIST_TYPE); + } + } + } + + @SuppressWarnings("deprecation") + @Override + public void onAttach(Activity activity) { + super.onAttach(activity); + if (activity instanceof AutoHideToolbarListener) { + mAutoHideToolbarListener = (AutoHideToolbarListener) activity; + } + mToolbarHeight = activity.getResources().getDimensionPixelSize(R.dimen.toolbar_height); + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + final View view = inflater.inflate(R.layout.reader_fragment_post_detail, container, false); + + CustomSwipeRefreshLayout swipeRefreshLayout = (CustomSwipeRefreshLayout) view.findViewById(R.id.swipe_to_refresh); + + //this fragment hides/shows toolbar with scrolling, which messes up ptr animation position + //so we have to set it manually + int swipeToRefreshOffset = getResources().getDimensionPixelSize(R.dimen.toolbar_content_offset); + swipeRefreshLayout.setProgressViewOffset(false, 0, swipeToRefreshOffset); + + mSwipeToRefreshHelper = new SwipeToRefreshHelper(getActivity(), swipeRefreshLayout, new SwipeToRefreshHelper.RefreshListener() { + @Override + public void onRefreshStarted() { + if (!isAdded()) { + return; + } + + updatePost(); + } + }); + + mScrollView = (WPScrollView) view.findViewById(R.id.scroll_view_reader); + mScrollView.setScrollDirectionListener(this); + + mLayoutFooter = (ViewGroup) view.findViewById(R.id.layout_post_detail_footer); + mLikingUsersView = (ReaderLikingUsersView) view.findViewById(R.id.layout_liking_users_view); + mLikingUsersDivider = view.findViewById(R.id.layout_liking_users_divider); + mLikingUsersLabel = view.findViewById(R.id.text_liking_users_label); + + // setup the ReaderWebView + mReaderWebView = (ReaderWebView) view.findViewById(R.id.reader_webview); + mReaderWebView.setCustomViewListener(this); + mReaderWebView.setUrlClickListener(this); + mReaderWebView.setPageFinishedListener(this); + + // hide footer and scrollView until the post is loaded + mLayoutFooter.setVisibility(View.INVISIBLE); + mScrollView.setVisibility(View.INVISIBLE); + + return view; + } + + @Override + public void onDestroy() { + super.onDestroy(); + if (mReaderWebView != null) { + mReaderWebView.destroy(); + } + } + + private boolean hasPost() { + return (mPost != null); + } + + @Override + public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) { + super.onCreateOptionsMenu(menu, inflater); + menu.clear(); + inflater.inflate(R.menu.reader_detail, menu); + } + + @Override + public void onPrepareOptionsMenu(Menu menu) { + super.onPrepareOptionsMenu(menu); + + // browse & share require the post to have a URL (some feed-based posts don't have one) + boolean postHasUrl = hasPost() && mPost.hasUrl(); + MenuItem mnuBrowse = menu.findItem(R.id.menu_browse); + if (mnuBrowse != null) { + mnuBrowse.setVisible(postHasUrl); + } + MenuItem mnuShare = menu.findItem(R.id.menu_share); + if (mnuShare != null) { + mnuShare.setVisible(postHasUrl); + } + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + int i = item.getItemId(); + if (i == R.id.menu_browse) { + if (hasPost()) { + ReaderActivityLauncher.openUrl(getActivity(), mPost.getUrl(), OpenUrlType.EXTERNAL); + } + return true; + } else if (i == R.id.menu_share) { + AnalyticsTracker.track(AnalyticsTracker.Stat.SHARED_ITEM); + sharePage(); + return true; + } else { + return super.onOptionsItemSelected(item); + } + } + + private ReaderPostListType getPostListType() { + return (mPostListType != null ? mPostListType : ReaderTypes.DEFAULT_POST_LIST_TYPE); + } + + @Override + public void onSaveInstanceState(Bundle outState) { + outState.putLong(ReaderConstants.ARG_BLOG_ID, mBlogId); + outState.putLong(ReaderConstants.ARG_POST_ID, mPostId); + + outState.putBoolean(ReaderConstants.ARG_IS_RELATED_POST, mIsRelatedPost); + outState.putBoolean(ReaderConstants.KEY_ALREADY_UPDATED, mHasAlreadyUpdatedPost); + outState.putBoolean(ReaderConstants.KEY_ALREADY_REQUESTED, mHasAlreadyRequestedPost); + + outState.putSerializable(ReaderConstants.ARG_POST_LIST_TYPE, getPostListType()); + + mPostHistory.saveInstance(outState); + + if (!TextUtils.isEmpty(mErrorMessage)) { + outState.putString(ReaderConstants.KEY_ERROR_MESSAGE, mErrorMessage); + } + + super.onSaveInstanceState(outState); + } + + @Override + public void onActivityCreated(Bundle savedInstanceState) { + super.onActivityCreated(savedInstanceState); + setHasOptionsMenu(true); + restoreState(savedInstanceState); + } + + private void restoreState(Bundle savedInstanceState) { + if (savedInstanceState != null) { + mBlogId = savedInstanceState.getLong(ReaderConstants.ARG_BLOG_ID); + mPostId = savedInstanceState.getLong(ReaderConstants.ARG_POST_ID); + mIsRelatedPost = savedInstanceState.getBoolean(ReaderConstants.ARG_IS_RELATED_POST); + mHasAlreadyUpdatedPost = savedInstanceState.getBoolean(ReaderConstants.KEY_ALREADY_UPDATED); + mHasAlreadyRequestedPost = savedInstanceState.getBoolean(ReaderConstants.KEY_ALREADY_REQUESTED); + if (savedInstanceState.containsKey(ReaderConstants.ARG_POST_LIST_TYPE)) { + mPostListType = (ReaderPostListType) savedInstanceState.getSerializable(ReaderConstants.ARG_POST_LIST_TYPE); + } + if (savedInstanceState.containsKey(ReaderConstants.KEY_ERROR_MESSAGE)) { + mErrorMessage = savedInstanceState.getString(ReaderConstants.KEY_ERROR_MESSAGE); + } + } + } + + @Override + public void onStart() { + super.onStart(); + EventBus.getDefault().register(this); + if (!hasPost()) { + showPost(); + } + } + + @Override + public void onStop() { + super.onStop(); + EventBus.getDefault().unregister(this); + } + + /* + * called by the activity when user hits the back button - returns true if the back button + * is handled here and should be ignored by the activity + */ + @Override + public boolean onActivityBackPressed() { + return goBackInPostHistory(); + } + + /* + * changes the like on the passed post + */ + private void togglePostLike() { + if (!isAdded() || !hasPost() || !NetworkUtils.checkConnection(getActivity())) { + return; + } + + boolean isAskingToLike = !mPost.isLikedByCurrentUser; + ReaderIconCountView likeCount = (ReaderIconCountView) getView().findViewById(R.id.count_likes); + likeCount.setSelected(isAskingToLike); + ReaderAnim.animateLikeButton(likeCount.getImageView(), isAskingToLike); + + boolean success = ReaderPostActions.performLikeAction(mPost, isAskingToLike); + if (!success) { + likeCount.setSelected(!isAskingToLike); + return; + } + + // get the post again since it has changed, then refresh to show changes + mPost = ReaderPostTable.getPost(mBlogId, mPostId, false); + refreshLikes(); + refreshIconCounts(); + + if (isAskingToLike) { + AnalyticsUtils.trackWithReaderPostDetails(AnalyticsTracker.Stat.READER_ARTICLE_LIKED, mPost); + } else { + AnalyticsUtils.trackWithReaderPostDetails(AnalyticsTracker.Stat.READER_ARTICLE_UNLIKED, mPost); + } + } + + /* + * user tapped follow button to follow/unfollow the blog this post is from + */ + private void togglePostFollowed() { + if (!isAdded() || !hasPost()) { + return; + } + + final boolean isAskingToFollow = !ReaderPostTable.isPostFollowed(mPost); + final ReaderFollowButton followButton = (ReaderFollowButton) getView().findViewById(R.id.follow_button); + + ReaderActions.ActionListener listener = new ReaderActions.ActionListener() { + @Override + public void onActionResult(boolean succeeded) { + if (!isAdded()) { + return; + } + followButton.setEnabled(true); + if (!succeeded) { + int resId = (isAskingToFollow ? R.string.reader_toast_err_follow_blog : R.string.reader_toast_err_unfollow_blog); + ToastUtils.showToast(getActivity(), resId); + followButton.setIsFollowedAnimated(!isAskingToFollow); + } + } + }; + + followButton.setEnabled(false); + + if (ReaderBlogActions.followBlogForPost(mPost, isAskingToFollow, listener)) { + followButton.setIsFollowedAnimated(isAskingToFollow); + } + } + + /* + * display the standard Android share chooser to share this post + */ + private static final int MAX_SHARE_TITLE_LEN = 100; + + private void sharePage() { + if (!isAdded() || !hasPost()) { + return; + } + + final String url = (mPost.hasShortUrl() ? mPost.getShortUrl() : mPost.getUrl()); + final String shareText; + + if (mPost.hasTitle()) { + final String title; + // we don't know where the user will choose to share, so enforce a max title length + // in order to fit a tweet with some extra room for the URL and user edits + if (mPost.getTitle().length() > MAX_SHARE_TITLE_LEN) { + title = mPost.getTitle().substring(0, MAX_SHARE_TITLE_LEN).trim() + "…"; + } else { + title = mPost.getTitle().trim(); + } + shareText = title + " - " + url; + } else { + shareText = url; + } + + Intent intent = new Intent(Intent.ACTION_SEND); + intent.setType("text/plain"); + intent.putExtra(Intent.EXTRA_TEXT, shareText); + intent.putExtra(Intent.EXTRA_SUBJECT, getString(R.string.reader_share_subject, getString(R.string.app_name))); + try { + startActivity(Intent.createChooser(intent, getString(R.string.reader_share_link))); + } catch (android.content.ActivityNotFoundException ex) { + ToastUtils.showToast(getActivity(), R.string.reader_toast_err_share_intent); + } + } + + /* + * replace the current post with the passed one + */ + private void replacePost(long blogId, long postId) { + mBlogId = blogId; + mPostId = postId; + mHasAlreadyRequestedPost = false; + mHasAlreadyUpdatedPost = false; + + // hide views that would show info for the previous post - these will be re-displayed + // with the correct info once the new post loads + getView().findViewById(R.id.container_related_posts).setVisibility(View.GONE); + getView().findViewById(R.id.text_related_posts_label).setVisibility(View.GONE); + + mLikingUsersView.setVisibility(View.GONE); + mLikingUsersDivider.setVisibility(View.GONE); + mLikingUsersLabel.setVisibility(View.GONE); + + // clear the webView - otherwise it will remain scrolled to where the user scrolled to + mReaderWebView.clearContent(); + + // make sure the toolbar and footer are showing + showToolbar(true); + showFooter(true); + + // now show the passed post + showPost(); + } + + /* + * request posts related to the current one - only available for wp.com + */ + private void requestRelatedPosts() { + if (hasPost() && mPost.isWP()) { + ReaderPostActions.requestRelatedPosts(mPost); + } + } + + /* + * related posts were retrieved, so show them + */ + @SuppressWarnings("unused") + public void onEventMainThread(ReaderEvents.RelatedPostsUpdated event) { + if (!isAdded() || !hasPost()) return; + + // make sure this is for the current post + if (event.getSourcePost().postId == mPostId && event.getSourcePost().blogId == mBlogId) { + showRelatedPosts(event.getRelatedPosts()); + } + } + + private void showRelatedPosts(@NonNull ReaderRelatedPostList relatedPosts) { + // locate the related posts container and remove any existing related post views + ViewGroup container = (ViewGroup) getView().findViewById(R.id.container_related_posts); + container.removeAllViews(); + + // add a separate view for each related post + LayoutInflater inflater = LayoutInflater.from(getActivity()); + int imageSize = DisplayUtils.dpToPx(getActivity(), getResources().getDimensionPixelSize(R.dimen.reader_related_post_image_size)); + for (int index = 0; index < relatedPosts.size(); index++) { + final ReaderRelatedPost relatedPost = relatedPosts.get(index); + + View postView = inflater.inflate(R.layout.reader_related_post, container, false); + TextView txtTitle = (TextView) postView.findViewById(R.id.text_related_post_title); + TextView txtByline = (TextView) postView.findViewById(R.id.text_related_post_byline); + WPNetworkImageView imgFeatured = (WPNetworkImageView) postView.findViewById(R.id.image_related_post); + + txtTitle.setText(relatedPost.getTitle()); + txtByline.setText(relatedPost.getByline()); + + imgFeatured.setVisibility(relatedPost.hasFeaturedImage() ? View.VISIBLE : View.GONE); + if (relatedPost.hasFeaturedImage()) { + String imageUrl = PhotonUtils.getPhotonImageUrl(relatedPost.getFeaturedImage(), imageSize, imageSize); + imgFeatured.setImageUrl(imageUrl, WPNetworkImageView.ImageType.PHOTO_ROUNDED); + imgFeatured.setVisibility(View.VISIBLE); + } + + // tapping this view should open the related post detail + postView.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View view) { + showRelatedPostDetail(relatedPost.getBlogId(), relatedPost.getPostId()); + } + }); + + container.addView(postView); + + // add a divider below all but the last related post + if (index < relatedPosts.size() - 1) { + View dividerView = inflater.inflate(R.layout.reader_related_post_divider, container, false); + container.addView(dividerView); + } + } + + View label = getView().findViewById(R.id.text_related_posts_label); + if (label.getVisibility() != View.VISIBLE) { + AniUtils.fadeIn(label, AniUtils.Duration.MEDIUM); + } + if (container.getVisibility() != View.VISIBLE) { + AniUtils.fadeIn(container, AniUtils.Duration.MEDIUM); + } + } + + /* + * user clicked a single related post - if we're already viewing a related post, add it to the + * history stack so the user can back-button through the history - otherwise start a new detail + * activity for this related post + */ + private void showRelatedPostDetail(long blogId, long postId) { + AnalyticsUtils.trackWithReaderPostDetails( + AnalyticsTracker.Stat.READER_RELATED_POST_CLICKED, blogId, postId); + + if (mIsRelatedPost) { + mPostHistory.push(new ReaderBlogIdPostId(mPost.blogId, mPost.postId)); + replacePost(blogId, postId); + } else { + ReaderActivityLauncher.showReaderPostDetail(getActivity(), blogId, postId, true); + } + } + + /* + * if the fragment is maintaining a backstack of posts, navigate to the previous one + */ + protected boolean goBackInPostHistory() { + if (!mPostHistory.isEmpty()) { + ReaderBlogIdPostId ids = mPostHistory.pop(); + replacePost(ids.getBlogId(), ids.getPostId()); + return true; + } else { + return false; + } + } + + /* + * get the latest version of this post + */ + private void updatePost() { + if (!hasPost() || !mPost.isWP()) { + setRefreshing(false); + return; + } + + final int numLikesBefore = ReaderLikeTable.getNumLikesForPost(mPost); + + ReaderActions.UpdateResultListener resultListener = new ReaderActions.UpdateResultListener() { + @Override + public void onUpdateResult(ReaderActions.UpdateResult result) { + if (!isAdded()) { + return; + } + // if the post has changed, reload it from the db and update the like/comment counts + if (result.isNewOrChanged()) { + mPost = ReaderPostTable.getPost(mBlogId, mPostId, false); + refreshIconCounts(); + } + // refresh likes if necessary - done regardless of whether the post has changed + // since it's possible likes weren't stored until the post was updated + if (result != ReaderActions.UpdateResult.FAILED + && numLikesBefore != ReaderLikeTable.getNumLikesForPost(mPost)) { + refreshLikes(); + } + + setRefreshing(false); + } + }; + ReaderPostActions.updatePost(mPost, resultListener); + } + + private void refreshIconCounts() { + if (!isAdded() || !hasPost() || !canShowFooter()) { + return; + } + + final ReaderIconCountView countLikes = (ReaderIconCountView) getView().findViewById(R.id.count_likes); + final ReaderIconCountView countComments = (ReaderIconCountView) getView().findViewById(R.id.count_comments); + + if (canShowCommentCount()) { + countComments.setCount(mPost.numReplies); + countComments.setVisibility(View.VISIBLE); + countComments.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + ReaderActivityLauncher.showReaderComments(getActivity(), mPost.blogId, mPost.postId); + } + }); + } else { + countComments.setVisibility(View.INVISIBLE); + countComments.setOnClickListener(null); + } + + if (canShowLikeCount()) { + countLikes.setCount(mPost.numLikes); + countLikes.setVisibility(View.VISIBLE); + countLikes.setSelected(mPost.isLikedByCurrentUser); + if (mIsLoggedOutReader) { + countLikes.setEnabled(false); + } else if (mPost.canLikePost()) { + countLikes.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View view) { + togglePostLike(); + } + }); + } + // if we know refreshLikes() is going to show the liking users, force liking user + // views to take up space right now + if (mPost.numLikes > 0 && mLikingUsersView.getVisibility() == View.GONE) { + mLikingUsersView.setVisibility(View.INVISIBLE); + mLikingUsersDivider.setVisibility(View.INVISIBLE); + mLikingUsersLabel.setVisibility(View.INVISIBLE); + } + } else { + countLikes.setVisibility(View.INVISIBLE); + countLikes.setOnClickListener(null); + } + } + + /* + * show latest likes for this post + */ + private void refreshLikes() { + if (!isAdded() || !hasPost() || !mPost.canLikePost()) { + return; + } + + // nothing more to do if no likes + if (mPost.numLikes == 0) { + mLikingUsersView.setVisibility(View.GONE); + mLikingUsersDivider.setVisibility(View.GONE); + mLikingUsersLabel.setVisibility(View.GONE); + return; + } + + // clicking likes view shows activity displaying all liking users + mLikingUsersView.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View view) { + ReaderActivityLauncher.showReaderLikingUsers(getActivity(), mPost.blogId, mPost.postId); + } + }); + + mLikingUsersDivider.setVisibility(View.VISIBLE); + mLikingUsersLabel.setVisibility(View.VISIBLE); + mLikingUsersView.setVisibility(View.VISIBLE); + mLikingUsersView.showLikingUsers(mPost); + } + + private boolean showPhotoViewer(String imageUrl, View sourceView, int startX, int startY) { + if (!isAdded() || TextUtils.isEmpty(imageUrl)) { + return false; + } + + // make sure this is a valid web image (could be file: or data:) + if (!imageUrl.startsWith("http")) { + return false; + } + + String postContent = (mRenderer != null ? mRenderer.getRenderedHtml() : null); + boolean isPrivatePost = (mPost != null && mPost.isPrivate); + EnumSet<PhotoViewerOption> options = EnumSet.noneOf(PhotoViewerOption.class); + if (isPrivatePost) { + options.add(ReaderActivityLauncher.PhotoViewerOption.IS_PRIVATE_IMAGE); + } + + ReaderActivityLauncher.showReaderPhotoViewer( + getActivity(), + imageUrl, + postContent, + sourceView, + options, + startX, + startY); + + return true; + } + + /* + * called when the post doesn't exist in local db, need to get it from server + */ + private void requestPost() { + final ProgressBar progress = (ProgressBar) getView().findViewById(R.id.progress_loading); + progress.setVisibility(View.VISIBLE); + progress.bringToFront(); + + ReaderActions.OnRequestListener listener = new ReaderActions.OnRequestListener() { + @Override + public void onSuccess() { + if (isAdded()) { + progress.setVisibility(View.GONE); + showPost(); + } + } + + @Override + public void onFailure(int statusCode) { + if (isAdded()) { + progress.setVisibility(View.GONE); + int errMsgResId; + if (!NetworkUtils.isNetworkAvailable(getActivity())) { + errMsgResId = R.string.no_network_message; + } else { + switch (statusCode) { + case 401: + case 403: + errMsgResId = R.string.reader_err_get_post_not_authorized; + break; + case 404: + errMsgResId = R.string.reader_err_get_post_not_found; + break; + default: + errMsgResId = R.string.reader_err_get_post_generic; + break; + } + } + showError(getString(errMsgResId)); + } + } + }; + ReaderPostActions.requestPost(mBlogId, mPostId, listener); + } + + /* + * shows an error message in the middle of the screen - used when requesting post fails + */ + private void showError(String errorMessage) { + if (!isAdded()) return; + + TextView txtError = (TextView) getView().findViewById(R.id.text_error); + txtError.setText(errorMessage); + if (txtError.getVisibility() != View.VISIBLE) { + AniUtils.fadeIn(txtError, AniUtils.Duration.MEDIUM); + } + mErrorMessage = errorMessage; + } + + private void showPost() { + if (mIsPostTaskRunning) { + AppLog.w(T.READER, "reader post detail > show post task already running"); + return; + } + + new ShowPostTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR); + } + + /* + * AsyncTask to retrieve this post from SQLite and display it + */ + private boolean mIsPostTaskRunning = false; + + private class ShowPostTask extends AsyncTask<Void, Void, Boolean> { + @Override + protected void onPreExecute() { + mIsPostTaskRunning = true; + } + + @Override + protected void onCancelled() { + mIsPostTaskRunning = false; + } + + @Override + protected Boolean doInBackground(Void... params) { + mPost = ReaderPostTable.getPost(mBlogId, mPostId, false); + if (mPost == null) { + return false; + } + + // "discover" Editor Pick posts should open the original (source) post + if (mPost.isDiscoverPost()) { + ReaderPostDiscoverData discoverData = mPost.getDiscoverData(); + if (discoverData != null + && discoverData.getDiscoverType() == ReaderPostDiscoverData.DiscoverType.EDITOR_PICK + && discoverData.getBlogId() != 0 + && discoverData.getPostId() != 0) { + mBlogId = discoverData.getBlogId(); + mPostId = discoverData.getPostId(); + mPost = ReaderPostTable.getPost(mBlogId, mPostId, false); + if (mPost == null) { + return false; + } + } + } + + return true; + } + + @Override + protected void onPostExecute(Boolean result) { + mIsPostTaskRunning = false; + + if (!isAdded()) return; + + // make sure options menu reflects whether we now have a post + getActivity().invalidateOptionsMenu(); + + if (!result) { + // post couldn't be loaded which means it doesn't exist in db, so request it from + // the server if it hasn't already been requested + if (!mHasAlreadyRequestedPost) { + mHasAlreadyRequestedPost = true; + AppLog.i(T.READER, "reader post detail > post not found, requesting it"); + requestPost(); + } else if (!TextUtils.isEmpty(mErrorMessage)) { + // post has already been requested and failed, so restore previous error message + showError(mErrorMessage); + } + return; + } + + mReaderWebView.setIsPrivatePost(mPost.isPrivate); + mReaderWebView.setBlogSchemeIsHttps(UrlUtils.isHttps(mPost.getBlogUrl())); + + TextView txtTitle = (TextView) getView().findViewById(R.id.text_title); + TextView txtBlogName = (TextView) getView().findViewById(R.id.text_blog_name); + TextView txtDomain = (TextView) getView().findViewById(R.id.text_domain); + TextView txtDateline = (TextView) getView().findViewById(R.id.text_dateline); + TextView txtTag = (TextView) getView().findViewById(R.id.text_tag); + + WPNetworkImageView imgBlavatar = (WPNetworkImageView) getView().findViewById(R.id.image_blavatar); + WPNetworkImageView imgAvatar = (WPNetworkImageView) getView().findViewById(R.id.image_avatar); + + ViewGroup layoutHeader = (ViewGroup) getView().findViewById(R.id.layout_post_detail_header); + ReaderFollowButton followButton = (ReaderFollowButton) layoutHeader.findViewById(R.id.follow_button); + + if (!canShowFooter()) { + mLayoutFooter.setVisibility(View.GONE); + } + + // add padding to the scrollView to make room for the top and bottom toolbars - this also + // ensures the scrollbar matches the content so it doesn't disappear behind the toolbars + int topPadding = (mAutoHideToolbarListener != null ? mToolbarHeight : 0); + int bottomPadding = (canShowFooter() ? mLayoutFooter.getHeight() : 0); + mScrollView.setPadding(0, topPadding, 0, bottomPadding); + + // scrollView was hidden in onCreateView, show it now that we have the post + mScrollView.setVisibility(View.VISIBLE); + + // render the post in the webView + mRenderer = new ReaderPostRenderer(mReaderWebView, mPost); + mRenderer.beginRender(); + + txtTitle.setText(mPost.hasTitle() ? mPost.getTitle() : getString(R.string.reader_untitled_post)); + + followButton.setVisibility(mIsLoggedOutReader ? View.GONE : View.VISIBLE); + if (!mIsLoggedOutReader) { + followButton.setIsFollowed(mPost.isFollowedByCurrentUser); + followButton.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + togglePostFollowed(); + } + }); + } + + // clicking the header shows blog preview + if (getPostListType() != ReaderPostListType.BLOG_PREVIEW) { + layoutHeader.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + ReaderActivityLauncher.showReaderBlogPreview(v.getContext(), mPost); + } + }); + } + + if (mPost.hasBlogName()) { + txtBlogName.setText(mPost.getBlogName()); + } else if (mPost.hasAuthorName()) { + txtBlogName.setText(mPost.getAuthorName()); + } else { + txtBlogName.setText(null); + } + + if (mPost.hasBlogUrl()) { + int blavatarSz = getResources().getDimensionPixelSize(R.dimen.avatar_sz_medium); + String imageUrl = GravatarUtils.blavatarFromUrl(mPost.getBlogUrl(), blavatarSz); + imgBlavatar.setImageUrl(imageUrl, WPNetworkImageView.ImageType.BLAVATAR); + txtDomain.setText(UrlUtils.getHost(mPost.getBlogUrl())); + } else { + imgBlavatar.showDefaultBlavatarImage(); + txtDomain.setText(null); + } + + if (mPost.hasPostAvatar()) { + int avatarSz = getResources().getDimensionPixelSize(R.dimen.avatar_sz_tiny); + imgAvatar.setImageUrl(mPost.getPostAvatarForDisplay(avatarSz), WPNetworkImageView.ImageType.AVATAR); + } else { + imgAvatar.showDefaultGravatarImage(); + } + + String timestamp = DateTimeUtils.javaDateToTimeSpan(mPost.getDisplayDate(), WordPress.getContext()); + if (mPost.hasAuthorName()) { + txtDateline.setText(mPost.getAuthorName() + ReaderConstants.UNICODE_BULLET_WITH_SPACE + timestamp); + } else if (mPost.hasBlogName()) { + txtDateline.setText(mPost.getBlogName() + ReaderConstants.UNICODE_BULLET_WITH_SPACE + timestamp); + } else { + txtDateline.setText(timestamp); + } + + final String tagToDisplay = mPost.getTagForDisplay(null); + if (!TextUtils.isEmpty(tagToDisplay)) { + txtTag.setText(ReaderUtils.makeHashTag(tagToDisplay)); + txtTag.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + ReaderTag tag = ReaderUtils.getTagFromTagName(tagToDisplay, ReaderTagType.FOLLOWED); + ReaderActivityLauncher.showReaderTagPreview(v.getContext(), tag); + } + }); + } + + if (canShowFooter() && mLayoutFooter.getVisibility() != View.VISIBLE) { + AniUtils.fadeIn(mLayoutFooter, AniUtils.Duration.LONG); + } + + refreshIconCounts(); + } + } + + /* + * called by the web view when the content finishes loading - likes aren't displayed + * until this is triggered, to avoid having them appear before the webView content + */ + @Override + public void onPageFinished(WebView view, String url) { + if (!isAdded()) { + return; + } + + if (url != null && url.equals("about:blank")) { + // brief delay before showing comments/likes to give page time to render + view.postDelayed(new Runnable() { + @Override + public void run() { + if (!isAdded()) { + return; + } + refreshLikes(); + if (!mHasAlreadyUpdatedPost) { + mHasAlreadyUpdatedPost = true; + updatePost(); + } + requestRelatedPosts(); + } + }, 300); + } else { + AppLog.w(T.READER, "reader post detail > page finished - " + url); + } + } + + /* + * return the container view that should host the full screen video + */ + @Override + public ViewGroup onRequestCustomView() { + if (isAdded()) { + return (ViewGroup) getView().findViewById(R.id.layout_custom_view_container); + } else { + return null; + } + } + + /* + * return the container view that should be hidden when full screen video is shown + */ + @Override + public ViewGroup onRequestContentView() { + if (isAdded()) { + return (ViewGroup) getView().findViewById(R.id.layout_post_detail_container); + } else { + return null; + } + } + + @Override + public void onCustomViewShown() { + // full screen video has just been shown so hide the ActionBar + ActionBar actionBar = getActionBar(); + if (actionBar != null) { + actionBar.hide(); + } + } + + @Override + public void onCustomViewHidden() { + // user returned from full screen video so re-display the ActionBar + ActionBar actionBar = getActionBar(); + if (actionBar != null) { + actionBar.show(); + } + } + + boolean isCustomViewShowing() { + return mReaderWebView != null && mReaderWebView.isCustomViewShowing(); + } + + void hideCustomView() { + if (mReaderWebView != null) { + mReaderWebView.hideCustomView(); + } + } + + @Override + public boolean onUrlClick(String url) { + // if this is a "wordpress://blogpreview?" link, show blog preview for the blog - this is + // used for Discover posts that highlight a blog + if (ReaderUtils.isBlogPreviewUrl(url)) { + long blogId = ReaderUtils.getBlogIdFromBlogPreviewUrl(url); + if (blogId != 0) { + ReaderActivityLauncher.showReaderBlogPreview(getActivity(), blogId); + } + return true; + } + + // open YouTube videos in external app so they launch the YouTube player, open all other + // urls using an AuthenticatedWebViewActivity + final OpenUrlType openUrlType; + if (ReaderVideoUtils.isYouTubeVideoLink(url)) { + openUrlType = OpenUrlType.EXTERNAL; + } else { + openUrlType = OpenUrlType.INTERNAL; + } + ReaderActivityLauncher.openUrl(getActivity(), url, openUrlType); + return true; + } + + @Override + public boolean onImageUrlClick(String imageUrl, View view, int x, int y) { + return showPhotoViewer(imageUrl, view, x, y); + } + + private ActionBar getActionBar() { + if (isAdded() && getActivity() instanceof AppCompatActivity) { + return ((AppCompatActivity) getActivity()).getSupportActionBar(); + } else { + AppLog.w(T.READER, "reader post detail > getActionBar returned null"); + return null; + } + } + + void pauseWebView() { + if (mReaderWebView == null) { + AppLog.w(T.READER, "reader post detail > attempt to pause null webView"); + } else if (!mIsWebViewPaused) { + AppLog.d(T.READER, "reader post detail > pausing webView"); + mReaderWebView.hideCustomView(); + mReaderWebView.onPause(); + mIsWebViewPaused = true; + } + } + + void resumeWebViewIfPaused() { + if (mReaderWebView == null) { + AppLog.w(T.READER, "reader post detail > attempt to resume null webView"); + } else if (mIsWebViewPaused) { + AppLog.d(T.READER, "reader post detail > resuming paused webView"); + mReaderWebView.onResume(); + mIsWebViewPaused = false; + } + } + + @Override + public void onScrollUp(float distanceY) { + if (!mIsToolbarShowing + && -distanceY >= MIN_SCROLL_DISTANCE_Y) { + showToolbar(true); + showFooter(true); + } + } + + @Override + public void onScrollDown(float distanceY) { + if (mIsToolbarShowing + && distanceY >= MIN_SCROLL_DISTANCE_Y + && mScrollView.canScrollDown() + && mScrollView.canScrollUp() + && mScrollView.getScrollY() > mToolbarHeight) { + showToolbar(false); + showFooter(false); + } + } + + @Override + public void onScrollCompleted() { + if (!mIsToolbarShowing + && (!mScrollView.canScrollDown() || !mScrollView.canScrollUp())) { + showToolbar(true); + showFooter(true); + } + } + + private void showToolbar(boolean show) { + mIsToolbarShowing = show; + if (mAutoHideToolbarListener != null) { + mAutoHideToolbarListener.onShowHideToolbar(show); + } + } + + private void showFooter(boolean show) { + if (isAdded() && canShowFooter()) { + AniUtils.animateBottomBar(mLayoutFooter, show); + } + } + + /* + * can we show the footer bar which contains the like & comment counts? + */ + private boolean canShowFooter() { + return canShowLikeCount() || canShowCommentCount(); + } + + private boolean canShowCommentCount() { + if (mPost == null) { + return false; + } + if (mIsLoggedOutReader) { + return mPost.numReplies > 0; + } + return mPost.isWP() + && !mPost.isJetpack + && !mPost.isDiscoverPost() + && (mPost.isCommentsOpen || mPost.numReplies > 0); + } + + private boolean canShowLikeCount() { + if (mPost == null) { + return false; + } + if (mIsLoggedOutReader) { + return mPost.numLikes > 0; + } + return mPost.canLikePost() || mPost.numLikes > 0; + } + + private void setRefreshing(boolean refreshing) { + mSwipeToRefreshHelper.setRefreshing(refreshing); + } + +} |