From 22ca09595d4b6f4301414f26d6d502eb0e989a88 Mon Sep 17 00:00:00 2001
From: Winson Chung <winsonc@google.com>
Date: Thu, 20 Oct 2011 19:44:32 -0700
Subject: [PATCH] Last update for screenshot animations for MR0. (Bug: 5333706)

- Also adding proper border asset

Change-Id: I423389d1a68498b2e470e6d483f5b7542a814c31
---
 .../global_screenshot_background.9.png        | Bin 358 -> 0 bytes
 .../res/drawable-hdpi/screenshot_panel.9.png  | Bin 0 -> 595 bytes
 .../global_screenshot_background.9.png        | Bin 358 -> 0 bytes
 .../res/drawable-mdpi/screenshot_panel.9.png  | Bin 0 -> 404 bytes
 .../global_screenshot_background.9.png        | Bin 671 -> 0 bytes
 .../res/drawable-xhdpi/screenshot_panel.9.png | Bin 0 -> 797 bytes
 .../SystemUI/res/layout/global_screenshot.xml |   7 +-
 packages/SystemUI/res/values/dimens.xml       |   5 +-
 .../systemui/screenshot/GlobalScreenshot.java | 153 +++++++++++-------
 9 files changed, 99 insertions(+), 66 deletions(-)
 delete mode 100644 packages/SystemUI/res/drawable-hdpi/global_screenshot_background.9.png
 create mode 100644 packages/SystemUI/res/drawable-hdpi/screenshot_panel.9.png
 delete mode 100644 packages/SystemUI/res/drawable-mdpi/global_screenshot_background.9.png
 create mode 100644 packages/SystemUI/res/drawable-mdpi/screenshot_panel.9.png
 delete mode 100644 packages/SystemUI/res/drawable-xhdpi/global_screenshot_background.9.png
 create mode 100644 packages/SystemUI/res/drawable-xhdpi/screenshot_panel.9.png

diff --git a/packages/SystemUI/res/drawable-hdpi/global_screenshot_background.9.png b/packages/SystemUI/res/drawable-hdpi/global_screenshot_background.9.png
deleted file mode 100644
index e14111dae1689a5742a0425ae7b41b23e869e790..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 358
zcmV-s0h#`ZP)<h;3K|Lk000e1NJLTq001Na001Ni1^@s6;Q*MJ0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUz2uVaiRCwC#m@x~&Fc5{kR0>L`;^5>z
z@z?uLoE)T6Q7E?YMP4L@Y#uSgJ$PKXA^p-^A$Q`v-)Klgu#}gd7t#XKQrK45-RBv0
za071{9rKzBUtob}_{F#|zXA#XExdy}#+G?a1%L^D!Xx9v{0gWgNDm(wJLWYt5oCaG
zj3e_apgnwmPsm-0)QiX&;R@g3$A&c$)$o}5f;HUpo!_!Zfn0KIr4&oT<$xq9>{5z9
zjpTr;kO3Kx0U6NWfx=C%A|CHluAPb(0IMMbG9Ux03CJf+Tq(r{(dU4cq=_q~*dQ)B
zpqXv$P!MR~JLlZ6p}JPOx?w{V<Cy9OR+>O63%vyx01l0AE}g9;;s5{u07*qoM6N<$
Ef?(>CDF6Tf

diff --git a/packages/SystemUI/res/drawable-hdpi/screenshot_panel.9.png b/packages/SystemUI/res/drawable-hdpi/screenshot_panel.9.png
new file mode 100644
index 0000000000000000000000000000000000000000..9447e01d8af5fe70608637102c86133ee9a1c468
GIT binary patch
literal 595
zcmV-Z0<8UsP)<h;3K|Lk000e1NJLTq001ul001%w1^@s6%x{9}00004b3#c}2nYxW
zd<bNS00009a7bBm000Y#000Y#0XNCZtpET4^+`lQRA_<in$d28FcgNrB2G;flilp?
z_WsFkwmBD3(e9$>NG+hdu+V1wN#jA=@=<;oJx8pyM3VK|<0p^DJ&eqaV-vK#F^`lD
z;;y@QiMyZ*iDwee<hUR%xDR)h*OSC2?|tn<84N6>l|X5&-3$PGQ^uGzP)md60$T7!
z-g^QTgV5dA3fN10^gr<7)hZ<p{CN<x`%;dx*IKqwUq9ilHYNCzv>NZZE4)tr$}dR^
zeu?AK%>!t|tLNu3AO$UPJSD-lT?8F<x0#d91G~WSDBDFLyjn-?lY-PPSC)acZTxr^
zpX*Nwp?hu9>X3*!dHUe9&;&o0Cit;5!H=cv;dA{NZnIzcY&BFyAcjo#E1#_<_^~v>
zkEIEIEcL;s_I;<5r|9XRx$zXFxp~zk4p&~GHL00`Y8s}iI}m2YG=+Qw_Qseu;1zfQ
z*0}6(%uHGh?0^mM0ledK^GA=Z6JBdSwREn4Z(Pb7;DAedw$g47lHT<S_yIoU{FU(3
z1of#9UhPr=+W>qe$1&4@Cpp(nz`ul}qOnge{Mj3<kO!G)L6h{1318!^q6@eco&#Q0
zqzm33tds3=DdstiWn$Sz8ICm8-3i0ZmDdUUs+)SSq$z90mX<HI0(kJ^tKBB+I&9Vz
h@JW;YopS!O&@V9*uLL`%n==3a002ovPDHLkV1gJc7?l73

literal 0
HcmV?d00001

diff --git a/packages/SystemUI/res/drawable-mdpi/global_screenshot_background.9.png b/packages/SystemUI/res/drawable-mdpi/global_screenshot_background.9.png
deleted file mode 100644
index e14111dae1689a5742a0425ae7b41b23e869e790..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 358
zcmV-s0h#`ZP)<h;3K|Lk000e1NJLTq001Na001Ni1^@s6;Q*MJ0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUz2uVaiRCwC#m@x~&Fc5{kR0>L`;^5>z
z@z?uLoE)T6Q7E?YMP4L@Y#uSgJ$PKXA^p-^A$Q`v-)Klgu#}gd7t#XKQrK45-RBv0
za071{9rKzBUtob}_{F#|zXA#XExdy}#+G?a1%L^D!Xx9v{0gWgNDm(wJLWYt5oCaG
zj3e_apgnwmPsm-0)QiX&;R@g3$A&c$)$o}5f;HUpo!_!Zfn0KIr4&oT<$xq9>{5z9
zjpTr;kO3Kx0U6NWfx=C%A|CHluAPb(0IMMbG9Ux03CJf+Tq(r{(dU4cq=_q~*dQ)B
zpqXv$P!MR~JLlZ6p}JPOx?w{V<Cy9OR+>O63%vyx01l0AE}g9;;s5{u07*qoM6N<$
Ef?(>CDF6Tf

diff --git a/packages/SystemUI/res/drawable-mdpi/screenshot_panel.9.png b/packages/SystemUI/res/drawable-mdpi/screenshot_panel.9.png
new file mode 100644
index 0000000000000000000000000000000000000000..7f1aea1da7f3172f20cbfa367127cccade6302c4
GIT binary patch
literal 404
zcmV;F0c-w=P)<h;3K|Lk000e1NJLTq001BW001Hg1^@s6KC;{Y00004b3#c}2nYxW
zd<bNS00009a7bBm000Y#000Y#0XNCZtpET4Hc3Q5R9J=Wm|bgwKoCXGt__ktq=Y{A
zxAn*8tx!rVRK)7^!Mmv+Nn6}*%!3yO+-046oJE`!Gb2K#n0K=o?##Tqa2+GNa6K{e
zicH}nL4sKeG>TSX0C&B`UgO-%jx!B^lymL@sDMww44%*fIj~D%F74#u<#_^tuH;)_
zpAcX#k1R}#0j^bn2|(C_jR;d|E042V5XPH?0Kt4<80319N)wN91+K0YU<L3*d`|yC
zb`upy`QHB~cM}y@0akz@BeKo@gC-v13ba6-5TKUFNuevYo_Xn<dj_6>N8p~gw)_Kl
z1r9*jgP64C4PDDz056&==z6#qfC@M&XQ6Qu7K{N(;7#LqzI(VBfLeJA<u3aG{luAo
yavA508pxRdVQVXy4-O`aAI%m&oUUT&9~57KU0_{tfD{}60000<MNUMnLSTXz^PqG9

literal 0
HcmV?d00001

diff --git a/packages/SystemUI/res/drawable-xhdpi/global_screenshot_background.9.png b/packages/SystemUI/res/drawable-xhdpi/global_screenshot_background.9.png
deleted file mode 100644
index db116b125046e79bc01638bdef482da273c48bd0..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 671
zcmV;Q0$}}#P)<h;3K|Lk000e1NJLTq001ul001ut1^@s6b0?Fm00009a7bBm000Y#
z000Y#0XNCZtpET5QAtEWRA_<inoF+QFcgMAW0MP|y+YjrLShFUp^mzPF0dQugr#&)
zsoeqs(Siyoeso|POnBVMjRRGF$w~+bd>kL!$@#%KN6o6`3o>xmD{<lVwHDv6^CzdD
z?{2ii$?1M4G*xNwcrH1>gr<Rg*xJw>0W2!QcY!CMAKFtmCOPk^x?}=y3G9Gv*#0Gn
zeidE?*mnW^ZL(jGC;BdcZ-EW4#s?0Lkq0ir_ksRwHv2ppjXsoR+0|MrV~ljpWr@6$
z(kP{LQ55^tYV~tEoqpk%KKqy82b0O<<9Iy&lmqsb7K_CX;48<}IrM&-25H(nZ#El~
z6Y`pNyIl!913fC^t_mLqY+q}g_DW+i#z=fN#7X0z>HzG76N+$A<FeKY{A8gxU31PN
zAGe)cgYzW?j+ibdOey?5-z;2Y%eiX4x?1?A)WSEV7QQL9@J*?OZ%Q5R`<~{OT!(xQ
z)vqn_@M-g~YT=tw3*VGl_@?yVz(3qdd#!GBH}^Y22&gzBQPs4Gj>KL{c^8FNA%w-3
zwGBya9?l~l9f_?{N@pXyAt|NBm$&yMmJVEoFM;)7Fu03CYp>TU@a{;7Hy94^X&Kvv
zH+R5hKA(RZ4u|ifD`Kq`If}1B2!s$;N@<l+dbwPF2Y%zDA5ArXZgQQ(my+M$y{PBV
zQcp@!|6s0qQojQH8u)|n0Rz_~PuSmvi@O}_<8><?du3pVmd;7q-11?&9NmbE_3;`N
zT|dpK4;yD37lBh%UGMZUG4~=C=XT2#2mG=1sQ>x^_y^3{(>a0ar~d!|002ovPDHLk
FV1o7)G|K=0

diff --git a/packages/SystemUI/res/drawable-xhdpi/screenshot_panel.9.png b/packages/SystemUI/res/drawable-xhdpi/screenshot_panel.9.png
new file mode 100644
index 0000000000000000000000000000000000000000..e5cfc364cc23c1d06e33abf88661877328965bf6
GIT binary patch
literal 797
zcmV+&1LFLNP)<h;3K|Lk000e1NJLTq002G!002S=1^@s64<Tj#00004b3#c}2nYxW
zd<bNS00009a7bBm000Y#000Y#0XNCZtpET5zez+vRCt{2o57BoFc5}614-Jn+EZVz
z?|<o`irR#b1ovPM9t>=>Y6xNNU$Sr<@Xp7~n1~%?tz`k(s6F?OFT?yAG9UQ<-np+L
zJJIhchKWI?718IhYnPH$M`<nNsnqqWiOC9elxBcZjlU9j>-#tV+4!+m^?Mov*RT~(
zSZfb67(APdF>g57D*?I(U&Pm_@dD@J&5SnAr47z@;eaSYwa0ZnSN_7UtP^|>TzvmV
zKkO|GLtVfHegkZuVd;Y<HeYa{1<?v0gA4Q)2fYWr%xmK;`VQ2%95?=Gaoz{|IUYa0
zB)`|{ah>P!qj)sbOFzEFd3*m1OCPK~&cj<=ZkK#;Rj-(S*1xjE?#Wd>2A44%>bn^Y
zoJ%{#A8DP&Jg!%ExdCgF2G%*=Y0Tr$U*OgXt{1j}rocsmJGBzswfi3Ur&R_|O&L5j
zW$@IL!BbNPPfbaKr}!T<o3zK1RMOyUe9`c~GD&+pNoDZVl)+O|22V{HJT+zT)N~Jg
zk?P_H=&s#U;8G@eLsbf`NMg6tv<?)5>mpcbYX#Q~g9sQa?9sp%;B1Wf348;7;3}cs
z2&G_4trIQKcpDG6y0%}yU*PP=^$qAL2A8`cCtrPQaG<riZsWgu1@PLp#y7EBL%-{B
zss0n#8uy0gK&TDf0w)6eQg3jqx9N)Was&MKwjBvK;z}sz?o>q+=^U3(FA1LB__3By
zOSUAqc=m*YJQ09(s1J(vV~<OPZ{tro`ia4L`slCO5h{z81eewOjI;BIv;7Yt?8Q;N
zJRb{no!=7PH6dIoKcSR^Ee+lhLcaF>Mvdu}z0+8z$CdpuK}lG}Co2Y@Ed2zM#qLJP
zZSC!MLtXFZfc_p2nLMr-TvG9G4sqBe8kciBP3=Nj`(~UNdH|p7_N!z!++}5DWqnSi
bx^ey=;4KQ}^q(IZ00000NkvXXu0mjfezbGI

literal 0
HcmV?d00001

diff --git a/packages/SystemUI/res/layout/global_screenshot.xml b/packages/SystemUI/res/layout/global_screenshot.xml
index 6d70135d51879..d416af9296802 100644
--- a/packages/SystemUI/res/layout/global_screenshot.xml
+++ b/packages/SystemUI/res/layout/global_screenshot.xml
@@ -26,11 +26,16 @@
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:layout_gravity="center"
-        android:background="@drawable/global_screenshot_background"
+        android:background="@drawable/screenshot_panel"
         android:visibility="gone">
         <ImageView android:id="@+id/global_screenshot"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:adjustViewBounds="true" />
     </FrameLayout>
+    <ImageView android:id="@+id/global_screenshot_flash"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:background="#FFFFFFFF"
+        android:visibility="gone" />
 </FrameLayout>
diff --git a/packages/SystemUI/res/values/dimens.xml b/packages/SystemUI/res/values/dimens.xml
index bf192868ffe7b..55b722b12473c 100644
--- a/packages/SystemUI/res/values/dimens.xml
+++ b/packages/SystemUI/res/values/dimens.xml
@@ -89,9 +89,6 @@
     <dimen name="collapse_accel">2000dp</dimen>
 
     <!-- The padding on the global screenshot background image -->
-    <dimen name="global_screenshot_bg_padding">0dp</dimen>
-    <!-- The top-left offset for the screenshot drop animation target bounds -->
-    <dimen name="global_screenshot_drop_offset_x">6dp</dimen>
-    <dimen name="global_screenshot_drop_offset_y">0dp</dimen>
+    <dimen name="global_screenshot_bg_padding">20dp</dimen>
 
 </resources>
diff --git a/packages/SystemUI/src/com/android/systemui/screenshot/GlobalScreenshot.java b/packages/SystemUI/src/com/android/systemui/screenshot/GlobalScreenshot.java
index cc1b8ed12c91e..6549610fe6824 100644
--- a/packages/SystemUI/src/com/android/systemui/screenshot/GlobalScreenshot.java
+++ b/packages/SystemUI/src/com/android/systemui/screenshot/GlobalScreenshot.java
@@ -34,7 +34,6 @@ import android.graphics.Canvas;
 import android.graphics.Matrix;
 import android.graphics.PixelFormat;
 import android.graphics.PointF;
-import android.graphics.RectF;
 import android.net.Uri;
 import android.os.AsyncTask;
 import android.os.Environment;
@@ -52,6 +51,7 @@ import android.view.ViewGroup;
 import android.view.WindowManager;
 import android.view.animation.AccelerateInterpolator;
 import android.view.animation.DecelerateInterpolator;
+import android.view.animation.Interpolator;
 import android.widget.FrameLayout;
 import android.widget.ImageView;
 
@@ -229,15 +229,18 @@ class SaveImageInBackgroundTask extends AsyncTask<SaveImageInBackgroundData, Voi
 class GlobalScreenshot {
     private static final String TAG = "GlobalScreenshot";
     private static final int SCREENSHOT_NOTIFICATION_ID = 789;
-    private static final int SCREENSHOT_FADE_IN_DURATION = 250;
-    private static final int SCREENSHOT_FADE_OUT_DELAY = 750;
-    private static final int SCREENSHOT_FADE_OUT_DURATION = 500;
-    private static final int SCREENSHOT_FAST_FADE_OUT_DURATION = 350;
-    private static final float BACKGROUND_ALPHA = 0.65f;
-    private static final float SCREENSHOT_SCALE_FUDGE = 0.075f; // To account for the border padding
-    private static final float SCREENSHOT_SCALE = 0.55f;
-    private static final float SCREENSHOT_FADE_IN_MIN_SCALE = SCREENSHOT_SCALE * 0.975f;
-    private static final float SCREENSHOT_FADE_OUT_MIN_SCALE = SCREENSHOT_SCALE * 0.925f;
+    private static final int SCREENSHOT_FLASH_TO_PEAK_DURATION = 130;
+    private static final int SCREENSHOT_DROP_IN_DURATION = 430;
+    private static final int SCREENSHOT_DROP_OUT_DELAY = 500;
+    private static final int SCREENSHOT_DROP_OUT_DURATION = 430;
+    private static final int SCREENSHOT_DROP_OUT_SCALE_DURATION = 370;
+    private static final int SCREENSHOT_FAST_DROP_OUT_DURATION = 320;
+    private static final float BACKGROUND_ALPHA = 0.5f;
+    private static final float SCREENSHOT_SCALE = 1f;
+    private static final float SCREENSHOT_DROP_IN_MIN_SCALE = SCREENSHOT_SCALE * 0.725f;
+    private static final float SCREENSHOT_DROP_OUT_MIN_SCALE = SCREENSHOT_SCALE * 0.45f;
+    private static final float SCREENSHOT_FAST_DROP_OUT_MIN_SCALE = SCREENSHOT_SCALE * 0.6f;
+    private static final float SCREENSHOT_DROP_OUT_MIN_SCALE_OFFSET = 0f;
 
     private Context mContext;
     private LayoutInflater mLayoutInflater;
@@ -254,13 +257,11 @@ class GlobalScreenshot {
     private ImageView mBackgroundView;
     private FrameLayout mScreenshotContainerView;
     private ImageView mScreenshotView;
+    private ImageView mScreenshotFlash;
 
     private AnimatorSet mScreenshotAnimation;
 
-    private int mStatusBarIconSize;
     private int mNotificationIconSize;
-    private float mDropOffsetX;
-    private float mDropOffsetY;
     private float mBgPadding;
     private float mBgPaddingScale;
 
@@ -280,6 +281,7 @@ class GlobalScreenshot {
         mBackgroundView = (ImageView) mScreenshotLayout.findViewById(R.id.global_screenshot_background);
         mScreenshotContainerView = (FrameLayout) mScreenshotLayout.findViewById(R.id.global_screenshot_container);
         mScreenshotView = (ImageView) mScreenshotLayout.findViewById(R.id.global_screenshot);
+        mScreenshotFlash = (ImageView) mScreenshotLayout.findViewById(R.id.global_screenshot_flash);
         mScreenshotLayout.setFocusable(true);
         mScreenshotLayout.setOnTouchListener(new View.OnTouchListener() {
             @Override
@@ -309,16 +311,12 @@ class GlobalScreenshot {
         mDisplay.getRealMetrics(mDisplayMetrics);
 
         // Get the various target sizes
-        mStatusBarIconSize =
-            r.getDimensionPixelSize(com.android.internal.R.dimen.status_bar_icon_size);
         mNotificationIconSize =
             r.getDimensionPixelSize(android.R.dimen.notification_large_icon_height);
-        mDropOffsetX = r.getDimensionPixelSize(R.dimen.global_screenshot_drop_offset_x);
-        mDropOffsetY = r.getDimensionPixelSize(R.dimen.global_screenshot_drop_offset_y);
 
         // Scale has to account for both sides of the bg
         mBgPadding = (float) r.getDimensionPixelSize(R.dimen.global_screenshot_bg_padding);
-        mBgPaddingScale = (2f * mBgPadding) /  mDisplayMetrics.widthPixels;
+        mBgPaddingScale = mBgPadding /  mDisplayMetrics.widthPixels;
     }
 
     /**
@@ -413,11 +411,11 @@ class GlobalScreenshot {
         }
 
         mWindowManager.addView(mScreenshotLayout, mWindowLayoutParams);
-        ValueAnimator screenshotFadeInAnim = createScreenshotFadeInAnimation();
-        ValueAnimator screenshotFadeOutAnim = createScreenshotFadeOutAnimation(w, h,
+        ValueAnimator screenshotDropInAnim = createScreenshotDropInAnimation();
+        ValueAnimator screenshotFadeOutAnim = createScreenshotDropOutAnimation(w, h,
                 statusBarVisible, navBarVisible);
         mScreenshotAnimation = new AnimatorSet();
-        mScreenshotAnimation.play(screenshotFadeInAnim).before(screenshotFadeOutAnim);
+        mScreenshotAnimation.playSequentially(screenshotDropInAnim, screenshotFadeOutAnim);
         mScreenshotAnimation.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationEnd(Animator animation) {
@@ -435,42 +433,71 @@ class GlobalScreenshot {
             }
         });
     }
-    private ValueAnimator createScreenshotFadeInAnimation() {
+    private ValueAnimator createScreenshotDropInAnimation() {
+        final float flashPeakDurationPct = ((float) (SCREENSHOT_FLASH_TO_PEAK_DURATION)
+                / SCREENSHOT_DROP_IN_DURATION);
+        final float flashDurationPct = 2f * flashPeakDurationPct;
+        final Interpolator flashAlphaInterpolator = new Interpolator() {
+            @Override
+            public float getInterpolation(float x) {
+                // Flash the flash view in and out quickly
+                if (x <= flashDurationPct) {
+                    return (float) Math.sin(Math.PI * (x / flashDurationPct));
+                }
+                return 0;
+            }
+        };
+        final Interpolator scaleInterpolator = new Interpolator() {
+            @Override
+            public float getInterpolation(float x) {
+                // We start scaling when the flash is at it's peak
+                if (x < flashPeakDurationPct) {
+                    return 0;
+                }
+                return (x - flashDurationPct) / (1f - flashDurationPct);
+            }
+        };
         ValueAnimator anim = ValueAnimator.ofFloat(0f, 1f);
-        anim.setInterpolator(new AccelerateInterpolator(1.5f));
-        anim.setDuration(SCREENSHOT_FADE_IN_DURATION);
+        anim.setDuration(SCREENSHOT_DROP_IN_DURATION);
         anim.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationStart(Animator animation) {
                 mBackgroundView.setAlpha(0f);
                 mBackgroundView.setVisibility(View.VISIBLE);
+                mScreenshotContainerView.setAlpha(0f);
                 mScreenshotContainerView.setTranslationX(0f);
                 mScreenshotContainerView.setTranslationY(0f);
-                mScreenshotContainerView.setScaleX(SCREENSHOT_FADE_IN_MIN_SCALE);
-                mScreenshotContainerView.setScaleY(SCREENSHOT_FADE_IN_MIN_SCALE);
-                mScreenshotContainerView.setAlpha(0f);
+                mScreenshotContainerView.setScaleX(SCREENSHOT_SCALE + mBgPaddingScale);
+                mScreenshotContainerView.setScaleY(SCREENSHOT_SCALE + mBgPaddingScale);
                 mScreenshotContainerView.setVisibility(View.VISIBLE);
+                mScreenshotFlash.setAlpha(0f);
+                mScreenshotFlash.setVisibility(View.VISIBLE);
+            }
+            @Override
+            public void onAnimationEnd(android.animation.Animator animation) {
+                mScreenshotFlash.setVisibility(View.GONE);
             }
         });
         anim.addUpdateListener(new AnimatorUpdateListener() {
             @Override
             public void onAnimationUpdate(ValueAnimator animation) {
                 float t = ((Float) animation.getAnimatedValue()).floatValue();
-                float scaleT = (SCREENSHOT_FADE_IN_MIN_SCALE)
-                    + (float) t * (SCREENSHOT_SCALE - SCREENSHOT_FADE_IN_MIN_SCALE);
-                mBackgroundView.setAlpha(t * BACKGROUND_ALPHA);
+                float scaleT = (SCREENSHOT_SCALE + mBgPaddingScale)
+                    - (float) scaleInterpolator.getInterpolation(t)
+                        * (SCREENSHOT_SCALE - SCREENSHOT_DROP_IN_MIN_SCALE);
+                mBackgroundView.setAlpha(scaleInterpolator.getInterpolation(t) * BACKGROUND_ALPHA);
+                mScreenshotContainerView.setAlpha(t);
                 mScreenshotContainerView.setScaleX(scaleT);
                 mScreenshotContainerView.setScaleY(scaleT);
-                mScreenshotContainerView.setAlpha(t);
+                mScreenshotFlash.setAlpha(flashAlphaInterpolator.getInterpolation(t));
             }
         });
         return anim;
     }
-    private ValueAnimator createScreenshotFadeOutAnimation(int w, int h, boolean statusBarVisible,
+    private ValueAnimator createScreenshotDropOutAnimation(int w, int h, boolean statusBarVisible,
             boolean navBarVisible) {
         ValueAnimator anim = ValueAnimator.ofFloat(0f, 1f);
-        anim.setInterpolator(new DecelerateInterpolator(0.5f));
-        anim.setStartDelay(SCREENSHOT_FADE_OUT_DELAY);
+        anim.setStartDelay(SCREENSHOT_DROP_OUT_DELAY);
         anim.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationEnd(Animator animation) {
@@ -482,54 +509,58 @@ class GlobalScreenshot {
 
         if (!statusBarVisible || !navBarVisible) {
             // There is no status bar/nav bar, so just fade the screenshot away in place
-            anim.setDuration(SCREENSHOT_FAST_FADE_OUT_DURATION);
+            anim.setDuration(SCREENSHOT_FAST_DROP_OUT_DURATION);
             anim.addUpdateListener(new AnimatorUpdateListener() {
                 @Override
                 public void onAnimationUpdate(ValueAnimator animation) {
                     float t = ((Float) animation.getAnimatedValue()).floatValue();
-                    float scaleT = (SCREENSHOT_FADE_OUT_MIN_SCALE)
-                            + (float) (1f - t) * (SCREENSHOT_SCALE - SCREENSHOT_FADE_OUT_MIN_SCALE);
+                    float scaleT = (SCREENSHOT_DROP_IN_MIN_SCALE + mBgPaddingScale)
+                            - (float) t * (SCREENSHOT_DROP_IN_MIN_SCALE
+                                    - SCREENSHOT_FAST_DROP_OUT_MIN_SCALE);
                     mBackgroundView.setAlpha((1f - t) * BACKGROUND_ALPHA);
-                    mScreenshotContainerView.setAlpha((1f - t) * BACKGROUND_ALPHA);
+                    mScreenshotContainerView.setAlpha(1f - t);
                     mScreenshotContainerView.setScaleX(scaleT);
                     mScreenshotContainerView.setScaleY(scaleT);
                 }
             });
         } else {
+            // In the case where there is a status bar, animate to the origin of the bar (top-left)
+            final float scaleDurationPct = (float) SCREENSHOT_DROP_OUT_SCALE_DURATION
+                    / SCREENSHOT_DROP_OUT_DURATION;
+            final Interpolator scaleInterpolator = new Interpolator() {
+                @Override
+                public float getInterpolation(float x) {
+                    if (x < scaleDurationPct) {
+                        // Decelerate, and scale the input accordingly
+                        return (float) (1f - Math.pow(1f - (x / scaleDurationPct), 2f));
+                    }
+                    return 1f;
+                }
+            };
+
             // Determine the bounds of how to scale
             float halfScreenWidth = (w - 2f * mBgPadding) / 2f;
             float halfScreenHeight = (h - 2f * mBgPadding) / 2f;
-            final RectF finalBounds = new RectF(mDropOffsetX, mDropOffsetY,
-                    mDropOffsetX + mStatusBarIconSize,
-                    mDropOffsetY + mStatusBarIconSize);
-            final PointF currentPos = new PointF(0f, 0f);
-            final PointF finalPos = new PointF(-halfScreenWidth + finalBounds.centerX(),
-                    -halfScreenHeight + finalBounds.centerY());
-            final DecelerateInterpolator d = new DecelerateInterpolator(2f);
-            // Note: since the scale origin is in the center of the view, divide difference by 2
-            float tmpMinScale = 0f;
-            if (w > h) {
-                tmpMinScale = finalBounds.width() / (2f * w);
-            } else {
-                tmpMinScale = finalBounds.height() / (2f * h);
-            }
-            final float minScale = tmpMinScale;
+            final float offsetPct = SCREENSHOT_DROP_OUT_MIN_SCALE_OFFSET;
+            final PointF finalPos = new PointF(
+                -halfScreenWidth + (SCREENSHOT_DROP_OUT_MIN_SCALE + offsetPct) * halfScreenWidth,
+                -halfScreenHeight + (SCREENSHOT_DROP_OUT_MIN_SCALE + offsetPct) * halfScreenHeight);
 
             // Animate the screenshot to the status bar
-            anim.setDuration(SCREENSHOT_FADE_OUT_DURATION);
+            anim.setDuration(SCREENSHOT_DROP_OUT_DURATION);
             anim.addUpdateListener(new AnimatorUpdateListener() {
                 @Override
                 public void onAnimationUpdate(ValueAnimator animation) {
                     float t = ((Float) animation.getAnimatedValue()).floatValue();
-                    float scaleT = minScale
-                            + (float) (1f - t) * (SCREENSHOT_SCALE - minScale - mBgPaddingScale)
-                            + mBgPaddingScale;
-                    mScreenshotContainerView.setAlpha(d.getInterpolation(1f - t));
-                    mScreenshotContainerView.setTranslationX(d.getInterpolation(t) * finalPos.x);
-                    mScreenshotContainerView.setTranslationY(d.getInterpolation(t) * finalPos.y);
+                    float scaleT = (SCREENSHOT_DROP_IN_MIN_SCALE + mBgPaddingScale)
+                        - (float) scaleInterpolator.getInterpolation(t)
+                            * (SCREENSHOT_DROP_IN_MIN_SCALE - SCREENSHOT_DROP_OUT_MIN_SCALE);
+                    mBackgroundView.setAlpha((1f - t) * BACKGROUND_ALPHA);
+                    mScreenshotContainerView.setAlpha(1f - scaleInterpolator.getInterpolation(t));
                     mScreenshotContainerView.setScaleX(scaleT);
                     mScreenshotContainerView.setScaleY(scaleT);
-                    mBackgroundView.setAlpha((1f - t) * BACKGROUND_ALPHA);
+                    mScreenshotContainerView.setTranslationX(t * finalPos.x);
+                    mScreenshotContainerView.setTranslationY(t * finalPos.y);
                 }
             });
         }