Restore zooming body image

app/src/main/java/app/insti/fragment/BodyFragmentNew.java

@@ -2,6 +2,11 @@ package app.insti.fragment;
 
 
 import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
+import android.animation.ObjectAnimator;
+import android.graphics.Color;
+import android.graphics.Point;
 import android.graphics.Rect;
 import android.os.Bundle;
 import android.support.annotation.NonNull;
@@ -14,6 +19,7 @@ import android.support.v7.widget.Toolbar;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.animation.DecelerateInterpolator;
 import android.widget.ImageView;
 
 import com.google.gson.Gson;
@@ -93,6 +99,18 @@ public class BodyFragmentNew extends BackHandledFragment implements TransitionTa
 
     @Override
     public boolean onBackPressed() {
+        if (zoomMode) {
+            zoomOut(expandedImageView, startBounds, startScaleFinal, bodyPicture);
+            zoomMode = false;
+
+            /* Show fab if the user has access */
+            if (((MainActivity) getActivity()).editBodyAccess(body)) {
+                final FloatingActionButton fab = getView().findViewById(R.id.edit_fab);
+                fab.show();
+            }
+
+            return true;
+        }
         return false;
     }
 
@@ -183,6 +201,16 @@ public class BodyFragmentNew extends BackHandledFragment implements TransitionTa
             return;
         }
 
+        bodyPicture.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                zoomImageFromThumb(bodyPicture);
+                final FloatingActionButton fab = getView().findViewById(R.id.edit_fab);
+                fab.hide();
+            }
+        });
+        mShortAnimationDuration = getResources().getInteger(android.R.integer.config_shortAnimTime);
+
         final List<Role> roles = body.getBodyRoles();
         final List<User> users = new ArrayList<>();
         for (Role role : roles) {
@@ -210,7 +238,7 @@ public class BodyFragmentNew extends BackHandledFragment implements TransitionTa
 
         /* Show update button if role */
         if (((MainActivity) getActivity()).editBodyAccess(body)) {
-            final FloatingActionButton fab = (FloatingActionButton) getView().findViewById(R.id.edit_fab);
+            final FloatingActionButton fab = getView().findViewById(R.id.edit_fab);
             fab.show();
             recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
                 @Override
@@ -246,4 +274,141 @@ public class BodyFragmentNew extends BackHandledFragment implements TransitionTa
         // Inflate the layout for this fragment
         return inflater.inflate(R.layout.fragment_body_fragment_new, container, false);
     }
+
+    private void zoomImageFromThumb(final ImageView thumbView) {
+        // If there's an animation in progress, cancel it
+        // immediately and proceed with this one.
+        if (mCurrentAnimator != null) {
+            mCurrentAnimator.cancel();
+        }
+
+        // Load the high-resolution "zoomed-in" image.
+        expandedImageView = (ImageView) getView().findViewById(
+                R.id.expanded_image_body);
+        expandedImageView.setImageDrawable(thumbView.getDrawable());
+
+        // Calculate the starting and ending bounds for the zoomed-in image.
+        // This step involves lots of math. Yay, math.
+        startBounds = new Rect();
+        final Rect finalBounds = new Rect();
+        final Point globalOffset = new Point();
+
+        // The start bounds are the global visible rectangle of the thumbnail,
+        // and the final bounds are the global visible rectangle of the container
+        // view. Also set the container view's offset as the origin for the
+        // bounds, since that's the origin for the positioning animation
+        // properties (X, Y).
+        thumbView.getGlobalVisibleRect(startBounds);
+        getActivity().findViewById(R.id.container_body)
+                .getGlobalVisibleRect(finalBounds, globalOffset);
+        startBounds.offset(-globalOffset.x, -globalOffset.y);
+        finalBounds.offset(-globalOffset.x, -globalOffset.y);
+
+        // Adjust the start bounds to be the same aspect ratio as the final
+        // bounds using the "center crop" technique. This prevents undesirable
+        // stretching during the animation. Also calculate the start scaling
+        // factor (the end scaling factor is always 1.0).
+        float startScale;
+        if ((float) finalBounds.width() / finalBounds.height()
+                > (float) startBounds.width() / startBounds.height()) {
+            // Extend start bounds horizontally
+            startScale = (float) startBounds.height() / finalBounds.height();
+            float startWidth = startScale * finalBounds.width();
+            float deltaWidth = (startWidth - startBounds.width()) / 2;
+            startBounds.left -= deltaWidth;
+            startBounds.right += deltaWidth;
+        } else {
+            // Extend start bounds vertically
+            startScale = (float) startBounds.width() / finalBounds.width();
+            float startHeight = startScale * finalBounds.height();
+            float deltaHeight = (startHeight - startBounds.height()) / 2;
+            startBounds.top -= deltaHeight;
+            startBounds.bottom += deltaHeight;
+        }
+
+        // Hide the thumbnail and show the zoomed-in view. When the animation
+        // begins, it will position the zoomed-in view in the place of the
+        // thumbnail.
+        thumbView.setAlpha(0f);
+        expandedImageView.setVisibility(View.VISIBLE);
+
+        // Set the pivot point for SCALE_X and SCALE_Y transformations
+        // to the top-left corner of the zoomed-in view (the default
+        // is the center of the view).
+        expandedImageView.setPivotX(0f);
+        expandedImageView.setPivotY(0f);
+
+        // Construct and run the parallel animation of the four translation and
+        // scale properties (X, Y, SCALE_X, and SCALE_Y).
+        AnimatorSet set = new AnimatorSet();
+        set
+                .play(ObjectAnimator.ofFloat(expandedImageView, View.X,
+                        startBounds.left, finalBounds.left))
+                .with(ObjectAnimator.ofFloat(expandedImageView, View.Y,
+                        startBounds.top, finalBounds.top))
+                .with(ObjectAnimator.ofFloat(expandedImageView, View.SCALE_X,
+                        startScale, 1f))
+                .with(ObjectAnimator.ofFloat(expandedImageView, View.SCALE_Y,
+                        startScale, 1f));
+        set.setDuration(mShortAnimationDuration);
+        set.setInterpolator(new DecelerateInterpolator());
+        set.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                mCurrentAnimator = null;
+                expandedImageView.setBackgroundColor(Color.parseColor("#9E9E9E"));
+            }
+
+            @Override
+            public void onAnimationCancel(Animator animation) {
+                mCurrentAnimator = null;
+            }
+        });
+        set.start();
+        mCurrentAnimator = set;
+
+        startScaleFinal = startScale;
+        zoomMode = true;
+    }
+
+    private void zoomOut(final ImageView expandedImageView, Rect startBounds, float startScaleFinal, final View thumbView) {
+        expandedImageView.setBackgroundColor(0x00000000);
+        if (mCurrentAnimator != null) {
+            mCurrentAnimator.cancel();
+        }
+
+        // Animate the four positioning/sizing properties in parallel,
+        // back to their original values.
+        AnimatorSet set = new AnimatorSet();
+        set.play(ObjectAnimator
+                .ofFloat(expandedImageView, View.X, startBounds.left))
+                .with(ObjectAnimator
+                        .ofFloat(expandedImageView,
+                                View.Y, startBounds.top))
+                .with(ObjectAnimator
+                        .ofFloat(expandedImageView,
+                                View.SCALE_X, startScaleFinal))
+                .with(ObjectAnimator
+                        .ofFloat(expandedImageView,
+                                View.SCALE_Y, startScaleFinal));
+        set.setDuration(mShortAnimationDuration);
+        set.setInterpolator(new DecelerateInterpolator());
+        set.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                thumbView.setAlpha(1f);
+                expandedImageView.setVisibility(View.GONE);
+                mCurrentAnimator = null;
+            }
+
+            @Override
+            public void onAnimationCancel(Animator animation) {
+                thumbView.setAlpha(1f);
+                expandedImageView.setVisibility(View.GONE);
+                mCurrentAnimator = null;
+            }
+        });
+        set.start();
+        mCurrentAnimator = set;
+    }
 }

app/src/main/res/layout/fragment_body_fragment_new.xml

 <?xml version="1.0" encoding="utf-8"?>
 <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools"
+    android:id="@+id/container_body"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
     android:orientation="vertical"
@@ -78,4 +79,11 @@
             android:indeterminate="true"
             android:theme="@style/BlueAccent" />
     </RelativeLayout>
+
+    <app.insti.TouchImageView
+        android:id="@+id/expanded_image_body"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:contentDescription="Zoomed Image"
+        android:visibility="gone" />
 </FrameLayout>
\ No newline at end of file