New Crowdin updates

quickstep/src/com/android/launcher3/QuickstepTransitionManager.java

@@ -643,13 +643,16 @@ private Pair<AnimatorSet, Runnable> getLauncherContentAnimator(boolean isAppOpen
             ObjectAnimator alpha = ObjectAnimator.ofFloat(appsView, View.ALPHA, alphas);
             alpha.setDuration(CONTENT_ALPHA_DURATION);
             alpha.setInterpolator(LINEAR);
-            appsView.setLayerType(View.LAYER_TYPE_HARDWARE, null);
-            alpha.addListener(new AnimatorListenerAdapter() {
-                @Override
-                public void onAnimationEnd(Animator animation) {
-                    appsView.setLayerType(View.LAYER_TYPE_NONE, null);
-                }
-            });
+
+            if (!mDeviceProfile.getDeviceProperties().isTablet()) {
+                appsView.setLayerType(View.LAYER_TYPE_HARDWARE, null);
+                alpha.addListener(new AnimatorListenerAdapter() {
+                    @Override
+                    public void onAnimationEnd(Animator animation) {
+                        appsView.setLayerType(View.LAYER_TYPE_NONE, null);
+                    }
+                });
+            }
 
             if (!skipAllAppsScale) {
                 SCALE_PROPERTY.set(appsView, scales[0]);
@@ -774,8 +777,11 @@ private Animator getOpeningWindowAnimators(View v,
                 wallpaperTargets, nonAppTargets, MODE_OPENING);
         int rotationChange = getRotationChange(appTargets);
         Rect windowTargetBounds = getWindowTargetBounds(appTargets, rotationChange);
+        final int displayWidth = mDeviceProfile.getDeviceProperties().getWidthPx();
+        final int displayHeight = mDeviceProfile.getDeviceProperties().getHeightPx();
         final int[] bottomInsetPos = new int[]{
                 mSystemUiProxy.getHomeVisibilityState().getNavbarInsetPosition()};
+        final int[] cachedNavbarInset = new int[]{bottomInsetPos[0]};
         final RemoteAnimationTarget target = openingTargets.getFirstAppTarget();
         final boolean cropToInset = shouldCropToInset(target);
         if (cropToInset) {
@@ -794,6 +800,7 @@ private Animator getOpeningWindowAnimators(View v,
                 true /* isOpening */);
         Rect crop = new Rect();
         Matrix matrix = new Matrix();
+        Rect closingTargetCrop = new Rect();
 
         SurfaceTransactionApplier surfaceApplier =
                 new SurfaceTransactionApplier(floatingView);
@@ -815,6 +822,9 @@ private Animator getOpeningWindowAnimators(View v,
             hasSplashScreen = false;
         }
 
+        final int windowIconSize = ResourceUtils.getDimenByName("starting_surface_icon_size",
+                mLauncher.getResources(), 108);
+
         AnimOpenProperties prop = new AnimOpenProperties(mLauncher.getResources(), mDeviceProfile,
                 windowTargetBounds, launcherIconBounds, v, dragLayerBounds[0], dragLayerBounds[1],
                 hasSplashScreen, floatingView.isDifferentFromAppIcon());
@@ -918,37 +928,31 @@ private boolean newShouldShowEduOnAppLaunch() {
 
             @Override
             public void onUpdate(float percent, boolean initOnly) {
-                if (cropToInset && bottomInsetPos[0] != mSystemUiProxy.getHomeVisibilityState()
-                        .getNavbarInsetPosition()) {
-                    final RemoteAnimationTarget target = openingTargets.getFirstAppTarget();
-                    bottomInsetPos[0] = mSystemUiProxy.getHomeVisibilityState()
+                if (cropToInset && bottomInsetPos[0] != cachedNavbarInset[0]) {
+                    cachedNavbarInset[0] = mSystemUiProxy.getHomeVisibilityState()
                             .getNavbarInsetPosition();
+                    bottomInsetPos[0] = cachedNavbarInset[0];
+                    final RemoteAnimationTarget target = openingTargets.getFirstAppTarget();
                     final Rect bounds = target != null
                             ? target.screenSpaceBounds : windowTargetBounds;
                     // Animate to above the taskbar.
                     int bottomLevel = Math.min(bottomInsetPos[0], bounds.bottom);
                     windowTargetBounds.bottom = bottomLevel;
                     final int endHeight = bottomLevel - bounds.top;
 
-                    AnimOpenProperties prop = new AnimOpenProperties(mLauncher.getResources(),
-                            mDeviceProfile, windowTargetBounds, launcherIconBounds, v,
-                            dragLayerBounds[0], dragLayerBounds[1], hasSplashScreen,
-                            floatingView.isDifferentFromAppIcon());
-                    mCropRectCenterY = new FloatProp(prop.cropCenterYStart, prop.cropCenterYEnd,
-                            mOpeningInterpolator);
-                    mCropRectHeight = new FloatProp(prop.cropHeightStart, prop.cropHeightEnd,
-                            mOpeningInterpolator);
-                    mDy = new FloatProp(0, prop.dY, mOpeningInterpolator);
-                    mIconScaleToFitScreen = new FloatProp(prop.initialAppIconScale,
-                            prop.finalAppIconScale, mOpeningInterpolator);
+                    float smallestSize = Math.min(windowTargetBounds.height(),
+                            windowTargetBounds.width());
+                    float maxIconScale = Math.max(smallestSize / launcherIconBounds.width(),
+                            smallestSize / launcherIconBounds.height());
+                    float newDY = windowTargetBounds.centerY() - dragLayerBounds[1]
+                            - launcherIconBounds.centerY();
                     float interpolatedPercent = mOpeningInterpolator.getInterpolation(percent);
-                    mCropRectHeight.value = Utilities.mapRange(interpolatedPercent,
-                            prop.cropHeightStart, prop.cropHeightEnd);
-                    mCropRectCenterY.value = Utilities.mapRange(interpolatedPercent,
-                            prop.cropCenterYStart, prop.cropCenterYEnd);
-                    mDy.value = Utilities.mapRange(interpolatedPercent, 0, prop.dY);
-                    mIconScaleToFitScreen.value = Utilities.mapRange(interpolatedPercent,
-                            prop.initialAppIconScale, prop.finalAppIconScale);
+                    mCropRectCenterY.value = windowTargetBounds.centerY();
+                    mCropRectHeight.value = windowIconSize
+                            + interpolatedPercent * (windowTargetBounds.height() - windowIconSize);
+                    mDy.value = interpolatedPercent * newDY;
+                    mIconScaleToFitScreen.value = prop.initialAppIconScale
+                            + interpolatedPercent * (maxIconScale - prop.initialAppIconScale);
                 }
 
                 // Calculate the size of the scaled icon.
@@ -964,8 +968,8 @@ public void onUpdate(float percent, boolean initOnly) {
                 final int windowCropWidth = crop.width();
                 final int windowCropHeight = crop.height();
                 if (rotationChange != 0) {
-                    Utilities.rotateBounds(crop, mDeviceProfile.getDeviceProperties().getWidthPx(),
-                            mDeviceProfile.getDeviceProperties().getHeightPx(), rotationChange);
+                    Utilities.rotateBounds(crop, displayWidth,
+                            displayHeight, rotationChange);
                 }
 
                 // Scale the size of the icon to match the size of the window crop.
@@ -1012,14 +1016,14 @@ public void onUpdate(float percent, boolean initOnly) {
                         matrix.setScale(scale, scale);
                         if (rotationChange == 1) {
                             matrix.postTranslate(windowTransY0,
-                                    mDeviceProfile.getDeviceProperties().getWidthPx() - (windowTransX0 + scaledCropWidth));
+                                    displayWidth - (windowTransX0 + scaledCropWidth));
                         } else if (rotationChange == 2) {
                             matrix.postTranslate(
-                                    mDeviceProfile.getDeviceProperties().getWidthPx() - (windowTransX0 + scaledCropWidth),
-                                    mDeviceProfile.getDeviceProperties().getHeightPx() - (windowTransY0 + scaledCropHeight));
+                                    displayWidth - (windowTransX0 + scaledCropWidth),
+                                    displayHeight - (windowTransY0 + scaledCropHeight));
                         } else if (rotationChange == 3) {
                             matrix.postTranslate(
-                                    mDeviceProfile.getDeviceProperties().getHeightPx() - (windowTransY0 + scaledCropHeight),
+                                    displayHeight - (windowTransY0 + scaledCropHeight),
                                     windowTransX0);
                         } else {
                             matrix.postTranslate(windowTransX0, windowTransY0);
@@ -1038,20 +1042,20 @@ public void onUpdate(float percent, boolean initOnly) {
                         } else {
                             tmpPos.set(target.position.x, target.position.y);
                         }
-                        final Rect crop = new Rect(target.screenSpaceBounds);
-                        crop.offsetTo(0, 0);
+                        closingTargetCrop.set(target.screenSpaceBounds);
+                        closingTargetCrop.offsetTo(0, 0);
 
                         if ((rotationChange % 2) == 1) {
-                            int tmp = crop.right;
-                            crop.right = crop.bottom;
-                            crop.bottom = tmp;
+                            int tmp = closingTargetCrop.right;
+                            closingTargetCrop.right = closingTargetCrop.bottom;
+                            closingTargetCrop.bottom = tmp;
                             tmp = tmpPos.x;
                             tmpPos.x = tmpPos.y;
                             tmpPos.y = tmp;
                         }
                         matrix.setTranslate(tmpPos.x, tmpPos.y);
                         builder.setMatrix(matrix)
-                                .setWindowCrop(crop)
+                                .setWindowCrop(closingTargetCrop)
                                 .setAlpha(1f);
                     }
                 }
@@ -1671,6 +1675,8 @@ private Animator getFallbackClosingWindowAnimators(RemoteAnimationTarget[] appTa
         Matrix matrix = new Matrix();
         Point tmpPos = new Point();
         Rect tmpRect = new Rect();
+        Rect fallbackCrop = new Rect();
+        SurfaceTransaction transaction = new SurfaceTransaction();
         ValueAnimator closingAnimator = ValueAnimator.ofFloat(0, 1);
         int duration = CLOSING_TRANSITION_DURATION_MS;
         float windowCornerRadius = getWindowCornerRadius(mLauncher);
@@ -1690,7 +1696,6 @@ private Animator getFallbackClosingWindowAnimators(RemoteAnimationTarget[] appTa
 
             @Override
             public void onUpdate(float percent, boolean initOnly) {
-                SurfaceTransaction transaction = new SurfaceTransaction();
                 for (int i = appTargets.length - 1; i >= 0; i--) {
                     RemoteAnimationTarget target = appTargets[i];
                     SurfaceProperties builder = transaction.forSurface(target.leash);
@@ -1701,29 +1706,29 @@ public void onUpdate(float percent, boolean initOnly) {
                         tmpPos.set(target.position.x, target.position.y);
                     }
 
-                    final Rect crop = new Rect(target.localBounds);
-                    crop.offsetTo(0, 0);
+                    fallbackCrop.set(target.localBounds);
+                    fallbackCrop.offsetTo(0, 0);
                     if (target.mode == MODE_CLOSING) {
                         tmpRect.set(target.screenSpaceBounds);
                         if ((rotationChange % 2) != 0) {
-                            final int right = crop.right;
-                            crop.right = crop.bottom;
-                            crop.bottom = right;
+                            final int right = fallbackCrop.right;
+                            fallbackCrop.right = fallbackCrop.bottom;
+                            fallbackCrop.bottom = right;
                         }
                         matrix.setScale(mScale.value, mScale.value,
                                 tmpRect.centerX(),
                                 tmpRect.centerY());
                         matrix.postTranslate(0, mDy.value);
                         matrix.postTranslate(tmpPos.x, tmpPos.y);
                         builder.setMatrix(matrix)
-                                .setWindowCrop(crop)
+                                .setWindowCrop(fallbackCrop)
                                 .setAlpha(mAlpha.value)
                                 .setCornerRadius(windowCornerRadius)
                                 .setShadowRadius(mShadowRadius.value);
                     } else if (target.mode == MODE_OPENING) {
                         matrix.setTranslate(tmpPos.x, tmpPos.y);
                         builder.setMatrix(matrix)
-                                .setWindowCrop(crop)
+                                .setWindowCrop(fallbackCrop)
                                 .setAlpha(1f);
                     }
                 }
@@ -2353,6 +2358,7 @@ private class SpringAnimRunner implements RectFSpringAnim.OnUpdateListener {
         private final Rect mWindowOriginalBounds = new Rect();
 
         private final Rect mTmpRect = new Rect();
+        private final SurfaceTransaction mTransaction = new SurfaceTransaction();
 
         /**
          * Constructor for SpringAnimRunner
@@ -2395,15 +2401,14 @@ private class SpringAnimRunner implements RectFSpringAnim.OnUpdateListener {
         }
 
         public float getCornerRadius(float progress) {
-            return Utilities.mapRange(progress, mStartRadius, mEndRadius);
+            return mStartRadius + progress * (mEndRadius - mStartRadius);
         }
 
         @Override
         public void onUpdate(RectF currentRectF, float progress) {
-            SurfaceTransaction transaction = new SurfaceTransaction();
             for (int i = mAppTargets.length - 1; i >= 0; i--) {
                 RemoteAnimationTarget target = mAppTargets[i];
-                SurfaceProperties builder = transaction.forSurface(target.leash);
+                SurfaceProperties builder = mTransaction.forSurface(target.leash);
 
                 if (target.localBounds != null) {
                     mTmpPos.set(target.localBounds.left, target.localBounds.top);
@@ -2449,7 +2454,7 @@ public void onUpdate(RectF currentRectF, float progress) {
                             .setAlpha(1f);
                 }
             }
-            mSurfaceApplier.scheduleApply(transaction);
+            mSurfaceApplier.scheduleApply(mTransaction);
         }
 
         protected float getWindowAlpha(float progress) {

quickstep/src/com/android/quickstep/AbsSwipeUpHandler.java

@@ -2719,9 +2719,11 @@ private boolean isKeyboardTaskFocusPending() {
     }
 
     private void onRecentsViewScroll() {
-        if (moveWindowWithRecentsScroll()) {
-            onCurrentShiftUpdated();
+        if (!moveWindowWithRecentsScroll()) return;
+        if (mRecentsView != null && mRecentsView.isOverlapStyleActive()) {
+            return;
         }
+        onCurrentShiftUpdated();
     }
 
     protected void startNewTask(@Nullable TaskView taskToLaunch, Consumer<Boolean> resultCallback) {

quickstep/src/com/android/quickstep/util/MultiValueUpdateListener.java

@@ -18,8 +18,6 @@
 import android.animation.ValueAnimator;
 import android.view.animation.Interpolator;
 
-import com.android.launcher3.Utilities;
-
 import java.util.ArrayList;
 
 /**
@@ -37,7 +35,7 @@ public final void onAnimationUpdate(ValueAnimator animator) {
         for (int i = mAllProperties.size() - 1; i >= 0; i--) {
             FloatProp prop = mAllProperties.get(i);
             float interpolatedPercent = prop.mInterpolator.getInterpolation(percent);
-            prop.value = Utilities.mapRange(interpolatedPercent, prop.mStart, prop.mEnd);
+            prop.value = prop.mStart + interpolatedPercent * (prop.mEnd - prop.mStart);
         }
         onUpdate(percent, false /* initOnly */);
     }