@nativescript-community/ui-image 4.2.1 → 4.3.2

package/CHANGELOG.md

@@ -3,6 +3,39 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [4.3.2](https://github.com/nativescript-community/ui-image/compare/v4.3.1...v4.3.2) (2022-07-15)
+
+
+### Bug Fixes
+
+* **image:** imageRotation scaling fix ([2f12172](https://github.com/nativescript-community/ui-image/commit/2f12172c022c9e6122420763a43b68a2bc137503))
+
+
+
+
+
+## [4.3.1](https://github.com/nativescript-community/ui-image/compare/v4.3.0...v4.3.1) (2022-07-14)
+
+
+### Bug Fixes
+
+* **image:** make imageRotation work in ListView ([58913bd](https://github.com/nativescript-community/ui-image/commit/58913bde275284ed704fac07b4154c11090bc7b9))
+
+
+
+
+
+# [4.3.0](https://github.com/nativescript-community/ui-image/compare/v4.2.1...v4.3.0) (2022-07-13)
+
+
+### Features
+
+* **image:** imageRotation support (android only for now) ([1f5b597](https://github.com/nativescript-community/ui-image/commit/1f5b59749317ad73e03961c280206fa2523d0b8d))
+
+
+
+
+
 ## [4.2.1](https://github.com/nativescript-community/ui-image/compare/v4.2.0...v4.2.1) (2022-07-08)
 
 **Note:** Version bump only for package @nativescript-community/ui-image

package/index-common.d.ts

@@ -65,6 +65,7 @@ export declare class ImageBase extends View {
     failureImageUri: string;
     stretch: ScaleType;
     fadeDuration: number;
+    imageRotation: number;
     backgroundUri: string;
     progressiveRenderingEnabled: boolean;
     localThumbnailPreviewsEnabled: boolean;
@@ -100,6 +101,7 @@ export declare class ImageBase extends View {
     static roundAsCircleProperty: Property<ImageBase, boolean>;
     static blurRadiusProperty: Property<ImageBase, number>;
     static blurDownSamplingProperty: Property<ImageBase, number>;
+    static imageRotationProperty: Property<ImageBase, number>;
     static autoPlayAnimationsProperty: Property<ImageBase, boolean>;
     static tapToRetryEnabledProperty: Property<ImageBase, boolean>;
     static aspectRatioProperty: Property<ImageBase, number>;

package/index-common.js

@@ -138,6 +138,7 @@ ImageBase.progressBarColorProperty = new Property({ name: 'progressBarColor', de
 ImageBase.roundAsCircleProperty = new Property({ name: 'roundAsCircle', valueConverter: booleanConverter, affectsLayout: isAndroid });
 ImageBase.blurRadiusProperty = new Property({ name: 'blurRadius', valueConverter: (v) => parseFloat(v) });
 ImageBase.blurDownSamplingProperty = new Property({ name: 'blurDownSampling', valueConverter: (v) => parseFloat(v) });
+ImageBase.imageRotationProperty = new Property({ name: 'imageRotation', valueConverter: (v) => parseFloat(v) });
 ImageBase.autoPlayAnimationsProperty = new Property({ name: 'autoPlayAnimations', valueConverter: booleanConverter });
 ImageBase.tapToRetryEnabledProperty = new Property({ name: 'tapToRetryEnabled', valueConverter: booleanConverter });
 ImageBase.aspectRatioProperty = new Property({ name: 'aspectRatio', affectsLayout: true, valueConverter: (v) => parseFloat(v) });
@@ -187,6 +188,7 @@ ImageBase.roundBottomLeftRadiusProperty.register(ImageBase);
 ImageBase.roundBottomRightRadiusProperty.register(ImageBase);
 ImageBase.blurRadiusProperty.register(ImageBase);
 ImageBase.blurDownSamplingProperty.register(ImageBase);
+ImageBase.imageRotationProperty.register(ImageBase);
 ImageBase.autoPlayAnimationsProperty.register(ImageBase);
 ImageBase.tapToRetryEnabledProperty.register(ImageBase);
 ImageBase.aspectRatioProperty.register(ImageBase);

package/index.android.js

@@ -310,6 +310,12 @@ export class Img extends ImageBase {
     [ImageBase.roundTopLeftRadiusProperty.setNative]() {
         this.updateHierarchy();
     }
+    [ImageBase.imageRotationProperty.setNative](value) {
+        var _e;
+        const scaleType = this.nativeImageViewProtected.getHierarchy().getActualImageScaleType();
+        (_e = scaleType['setImageRotation']) === null || _e === void 0 ? void 0 : _e.call(scaleType, value);
+        this.nativeImageViewProtected.invalidate();
+    }
     [ImageBase.roundTopRightRadiusProperty.setNative]() {
         this.updateHierarchy();
     }
@@ -566,7 +572,7 @@ export class Img extends ImageBase {
                 builder.setPlaceholderImage(placeholderImageDrawable, this.stretch);
             }
             if (this.stretch) {
-                builder.setActualImageScaleType(this.stretch);
+                builder.setActualImageScaleType(this.stretch, this.imageRotation);
             }
             if (this.fadeDuration) {
                 builder.setFadeDuration(this.fadeDuration);
@@ -702,11 +708,15 @@ class GenericDraweeHierarchyBuilder {
         }
         return this;
     }
-    setActualImageScaleType(scaleType) {
+    setActualImageScaleType(scaleType, imageRotation) {
         if (!this.nativeBuilder) {
             return this;
         }
-        this.nativeBuilder.setActualImageScaleType(getScaleType(scaleType));
+        const nativeScaleType = getScaleType(scaleType);
+        if (nativeScaleType['setImageRotation']) {
+            nativeScaleType['setImageRotation'](imageRotation);
+        }
+        this.nativeBuilder.setActualImageScaleType(nativeScaleType);
         return this;
     }
     build() {
@@ -762,24 +772,24 @@ function getScaleType(scaleType) {
     if (isString(scaleType)) {
         switch (scaleType) {
             case ScaleType.Center:
-                return com.facebook.drawee.drawable.ScalingUtils.ScaleType.CENTER;
+                return new com.nativescript.image.ScalingUtils.ScaleTypeCenter();
             case ScaleType.AspectFill:
             case ScaleType.CenterCrop:
-                return com.facebook.drawee.drawable.ScalingUtils.ScaleType.CENTER_CROP;
+                return new com.nativescript.image.ScalingUtils.ScaleTypeCenterCrop();
             case ScaleType.CenterInside:
-                return com.facebook.drawee.drawable.ScalingUtils.ScaleType.CENTER_INSIDE;
+                return new com.nativescript.image.ScalingUtils.ScaleTypeCenterInside();
             case ScaleType.FitCenter:
             case ScaleType.AspectFit:
-                return com.facebook.drawee.drawable.ScalingUtils.ScaleType.FIT_CENTER;
+                return new com.nativescript.image.ScalingUtils.ScaleTypeFitCenter();
             case ScaleType.FitEnd:
-                return com.facebook.drawee.drawable.ScalingUtils.ScaleType.FIT_END;
+                return new com.nativescript.image.ScalingUtils.ScaleTypeFitEnd();
             case ScaleType.FitStart:
-                return com.facebook.drawee.drawable.ScalingUtils.ScaleType.FIT_START;
+                return new com.nativescript.image.ScalingUtils.ScaleTypeFitStart();
             case ScaleType.Fill:
             case ScaleType.FitXY:
-                return com.facebook.drawee.drawable.ScalingUtils.ScaleType.FIT_XY;
+                return new com.nativescript.image.ScalingUtils.ScaleTypeFitXY();
             case ScaleType.FocusCrop:
-                return com.facebook.drawee.drawable.ScalingUtils.ScaleType.FOCUS_CROP;
+                return new com.nativescript.image.ScalingUtils.ScaleTypeFocusCrop();
             default:
                 break;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nativescript-community/ui-image",
-    "version": "4.2.1",
+    "version": "4.3.2",
     "description": "Advanced and efficient image display plugin which uses Fresco (Android) and SDWebImage (iOS) to implement caching, placeholders, image effects, and much more.",
     "main": "./index",
     "sideEffects": false,
@@ -44,5 +44,5 @@
     },
     "license": "Apache-2.0",
     "readmeFilename": "README.md",
-    "gitHead": "7ae707fd4b614e66d757d0f54a207f311702e826"
+    "gitHead": "0c463c971b84b168d620d8b500025b3b908e9710"
 }

package/platforms/android/java/com/nativescript/image/ScalingUtils.java

@@ -0,0 +1,492 @@
+package com.nativescript.image;
+
+import android.graphics.Matrix;
+import android.graphics.PointF;
+import android.graphics.Rect;
+import android.util.Log;
+
+/** Performs scale type calculations. */
+public class ScalingUtils {
+
+  /**
+   * Options for scaling the child bounds to the parent bounds.
+   *
+   * <p>Similar to {@link android.widget.ImageView.ScaleType}, but ScaleType.MATRIX is not
+   * supported. To use matrix scaling, use a {@link MatrixDrawable}. An additional scale type
+   * (FOCUS_CROP) is provided.
+   *
+   * <p>
+   */
+  public interface ScaleType {
+
+    /**
+     * Scales width and height independently, so that the child matches the parent exactly. This may
+     * change the aspect ratio of the child.
+     */
+    com.facebook.drawee.drawable.ScalingUtils.ScaleType FIT_XY = ScaleTypeFitXY.INSTANCE;
+
+    /**
+     * Scales the child so that the child's width fits exactly. The height will be cropped if it
+     * exceeds parent's bounds. Aspect ratio is preserved. Child is centered within the parent's
+     * bounds.
+     */
+    com.facebook.drawee.drawable.ScalingUtils.ScaleType FIT_X = ScaleTypeFitX.INSTANCE;
+
+    /**
+     * Scales the child so that the child's height fits exactly. The width will be cropped if it
+     * exceeds parent's bounds. Aspect ratio is preserved. Child is centered within the parent's
+     * bounds.
+     */
+    com.facebook.drawee.drawable.ScalingUtils.ScaleType FIT_Y = ScaleTypeFitY.INSTANCE;
+
+    /**
+     * Scales the child so that it fits entirely inside the parent. At least one dimension (width or
+     * height) will fit exactly. Aspect ratio is preserved. Child is aligned to the top-left corner
+     * of the parent.
+     */
+    com.facebook.drawee.drawable.ScalingUtils.ScaleType FIT_START = ScaleTypeFitStart.INSTANCE;
+
+    /**
+     * Scales the child so that it fits entirely inside the parent. At least one dimension (width or
+     * height) will fit exactly. Aspect ratio is preserved. Child is centered within the parent's
+     * bounds.
+     */
+    com.facebook.drawee.drawable.ScalingUtils.ScaleType FIT_CENTER = ScaleTypeFitCenter.INSTANCE;
+
+    /**
+     * Scales the child so that it fits entirely inside the parent. At least one dimension (width or
+     * height) will fit exactly. Aspect ratio is preserved. Child is aligned to the bottom-right
+     * corner of the parent.
+     */
+    com.facebook.drawee.drawable.ScalingUtils.ScaleType FIT_END = ScaleTypeFitEnd.INSTANCE;
+
+    /** Performs no scaling. Child is centered within parent's bounds. */
+    com.facebook.drawee.drawable.ScalingUtils.ScaleType CENTER = ScaleTypeCenter.INSTANCE;
+
+    /**
+     * Scales the child so that it fits entirely inside the parent. Unlike FIT_CENTER, if the child
+     * is smaller, no up-scaling will be performed. Aspect ratio is preserved. Child is centered
+     * within parent's bounds.
+     */
+    com.facebook.drawee.drawable.ScalingUtils.ScaleType CENTER_INSIDE = ScaleTypeCenterInside.INSTANCE;
+
+    /**
+     * Scales the child so that both dimensions will be greater than or equal to the corresponding
+     * dimension of the parent. At least one dimension (width or height) will fit exactly. Child is
+     * centered within parent's bounds.
+     */
+    com.facebook.drawee.drawable.ScalingUtils.ScaleType CENTER_CROP = ScaleTypeCenterCrop.INSTANCE;
+
+    /**
+     * Scales the child so that both dimensions will be greater than or equal to the corresponding
+     * dimension of the parent. At least one dimension (width or height) will fit exactly. The
+     * child's focus point will be centered within the parent's bounds as much as possible without
+     * leaving empty space. It is guaranteed that the focus point will be visible and centered as
+     * much as possible. If the focus point is set to (0.5f, 0.5f), result will be equivalent to
+     * CENTER_CROP.
+     */
+    com.facebook.drawee.drawable.ScalingUtils.ScaleType FOCUS_CROP = ScaleTypeFocusCrop.INSTANCE;
+
+    /**
+     * Scales the child so that it fits entirely inside the parent. At least one dimension (width or
+     * height) will fit exactly. Aspect ratio is preserved. Child is aligned to the bottom-left
+     * corner of the parent.
+     */
+    com.facebook.drawee.drawable.ScalingUtils.ScaleType FIT_BOTTOM_START = ScaleTypeFitBottomStart.INSTANCE;
+
+    /**
+     * Gets transformation matrix based on the scale type.
+     *
+     * @param outTransform out matrix to store result
+     * @param parentBounds parent bounds
+     * @param childWidth child width
+     * @param childHeight child height
+     * @param focusX focus point x coordinate, relative [0...1]
+     * @param focusY focus point y coordinate, relative [0...1]
+     * @return same reference to the out matrix for convenience
+     */
+    Matrix getTransform(
+        Matrix outTransform,
+        Rect parentBounds,
+        int childWidth,
+        int childHeight,
+        float focusX,
+        float focusY);
+  }
+
+  
+
+  /** A convenience base class that has some common logic. */
+  public abstract static class AbstractScaleType implements com.facebook.drawee.drawable.ScalingUtils.ScaleType, com.facebook.drawee.drawable.ScalingUtils.StatefulScaleType {
+    protected Matrix _imageMatrix = null;
+    protected float _imageRotation = 0;
+    public void setImageMatrix(Matrix matrix) {
+        _imageMatrix = matrix;
+    }
+    public void setImageRotation(float rotation) {
+        _imageRotation = rotation;
+    }
+
+    @Override
+    public Object getState() {
+        if (_imageMatrix != null) {
+            return _imageMatrix;
+        }
+        return _imageRotation;
+    }
+    @Override
+    public Matrix getTransform(
+        Matrix outTransform,
+        Rect parentRect,
+        int childWidth,
+        int childHeight,
+        float focusX,
+        float focusY) {
+        float sX = (float) parentRect.width() / (float) childWidth;
+        float sY = (float) parentRect.height() / (float) childHeight;
+        float rotationDelta = (90 - (_imageRotation % 180))/90.0f;
+        if (rotationDelta != 1) {
+            float destSX = (float) parentRect.width() / (float) childHeight;
+            float destSY = (float) parentRect.height() / (float) childWidth;
+          if (rotationDelta < 0) {
+            sX = destSX + rotationDelta * (destSX - sX);
+            sY = destSY + rotationDelta * (destSY - sY);
+          } else {
+            sX = sX + (1 - rotationDelta) * (destSX - sX);
+            sY = sY + (1 - rotationDelta) * (destSY - sY);
+          }
+            
+        }
+        getTransformImpl(outTransform, parentRect, childWidth, childHeight, focusX, focusY, sX, sY);
+        if (_imageMatrix != null) {
+            outTransform.preConcat(_imageMatrix);
+        } else if (_imageRotation != 0) {
+            outTransform.preRotate(_imageRotation, childWidth / 2.0f, childHeight / 2.0f);
+        }
+      
+      return outTransform;
+    }
+
+    public abstract void getTransformImpl(
+        Matrix outTransform,
+        Rect parentRect,
+        int childWidth,
+        int childHeight,
+        float focusX,
+        float focusY,
+        float scaleX,
+        float scaleY);
+  }
+
+  public static class ScaleTypeFitXY extends AbstractScaleType {
+
+    public static final com.facebook.drawee.drawable.ScalingUtils.ScaleType INSTANCE = new ScaleTypeFitXY();
+
+    @Override
+    public void getTransformImpl(
+        Matrix outTransform,
+        Rect parentRect,
+        int childWidth,
+        int childHeight,
+        float focusX,
+        float focusY,
+        float scaleX,
+        float scaleY) {
+      float dx = parentRect.left;
+      float dy = parentRect.top;
+      outTransform.setScale(scaleX, scaleY);
+      outTransform.postTranslate((int) (dx + 0.5f), (int) (dy + 0.5f));
+    }
+
+    @Override
+    public String toString() {
+      return "fit_xy";
+    }
+  }
+
+  public static class ScaleTypeFitStart extends AbstractScaleType {
+
+    public static final com.facebook.drawee.drawable.ScalingUtils.ScaleType INSTANCE = new ScaleTypeFitStart();
+
+    @Override
+    public void getTransformImpl(
+        Matrix outTransform,
+        Rect parentRect,
+        int childWidth,
+        int childHeight,
+        float focusX,
+        float focusY,
+        float scaleX,
+        float scaleY) {
+      float scale = Math.min(scaleX, scaleY);
+      float dx = parentRect.left;
+      float dy = parentRect.top;
+      outTransform.setScale(scale, scale);
+      outTransform.postTranslate((int) (dx + 0.5f), (int) (dy + 0.5f));
+    }
+
+    @Override
+    public String toString() {
+      return "fit_start";
+    }
+  }
+
+  public static class ScaleTypeFitBottomStart extends AbstractScaleType {
+
+    public static final com.facebook.drawee.drawable.ScalingUtils.ScaleType INSTANCE = new ScaleTypeFitBottomStart();
+
+    @Override
+    public void getTransformImpl(
+        Matrix outTransform,
+        Rect parentRect,
+        int childWidth,
+        int childHeight,
+        float focusX,
+        float focusY,
+        float scaleX,
+        float scaleY) {
+      float scale = Math.min(scaleX, scaleY);
+      float dx = parentRect.left;
+      float dy = parentRect.top + (parentRect.height() - childHeight * scale);
+      outTransform.setScale(scale, scale);
+      outTransform.postTranslate((int) (dx + 0.5f), (int) (dy + 0.5f));
+    }
+
+    @Override
+    public String toString() {
+      return "fit_bottom_start";
+    }
+  }
+
+  public static class ScaleTypeFitCenter extends AbstractScaleType {
+
+    public static final com.facebook.drawee.drawable.ScalingUtils.ScaleType INSTANCE = new ScaleTypeFitCenter();
+
+    @Override
+    public void getTransformImpl(
+        Matrix outTransform,
+        Rect parentRect,
+        int childWidth,
+        int childHeight,
+        float focusX,
+        float focusY,
+        float scaleX,
+        float scaleY) {
+      float scale =  Math.min(scaleX, scaleY);
+      float dx = parentRect.left + (parentRect.width() - childWidth * scale) * 0.5f;
+      float dy = parentRect.top + (parentRect.height() - childHeight * scale) * 0.5f;
+      outTransform.setScale(scale, scale);
+      outTransform.postTranslate((int) (dx + 0.5f), (int) (dy + 0.5f));
+    }
+
+    @Override
+    public String toString() {
+      return "fit_center";
+    }
+  }
+
+  public static class ScaleTypeFitEnd extends AbstractScaleType {
+
+    public static final com.facebook.drawee.drawable.ScalingUtils.ScaleType INSTANCE = new ScaleTypeFitEnd();
+
+    @Override
+    public void getTransformImpl(
+        Matrix outTransform,
+        Rect parentRect,
+        int childWidth,
+        int childHeight,
+        float focusX,
+        float focusY,
+        float scaleX,
+        float scaleY) {
+      float scale = Math.min(scaleX, scaleY);
+      float dx = parentRect.left + (parentRect.width() - childWidth * scale);
+      float dy = parentRect.top + (parentRect.height() - childHeight * scale);
+      outTransform.setScale(scale, scale);
+      outTransform.postTranslate((int) (dx + 0.5f), (int) (dy + 0.5f));
+    }
+
+    @Override
+    public String toString() {
+      return "fit_end";
+    }
+  }
+
+  public static class ScaleTypeCenter extends AbstractScaleType {
+
+    public static final com.facebook.drawee.drawable.ScalingUtils.ScaleType INSTANCE = new ScaleTypeCenter();
+
+    @Override
+    public void getTransformImpl(
+        Matrix outTransform,
+        Rect parentRect,
+        int childWidth,
+        int childHeight,
+        float focusX,
+        float focusY,
+        float scaleX,
+        float scaleY) {
+      float dx = parentRect.left + (parentRect.width() - childWidth) * 0.5f;
+      float dy = parentRect.top + (parentRect.height() - childHeight) * 0.5f;
+      outTransform.setTranslate((int) (dx + 0.5f), (int) (dy + 0.5f));
+    }
+
+    @Override
+    public String toString() {
+      return "center";
+    }
+  }
+
+  public static class ScaleTypeCenterInside extends AbstractScaleType {
+
+    public static final com.facebook.drawee.drawable.ScalingUtils.ScaleType INSTANCE = new ScaleTypeCenterInside();
+
+    @Override
+    public void getTransformImpl(
+        Matrix outTransform,
+        Rect parentRect,
+        int childWidth,
+        int childHeight,
+        float focusX,
+        float focusY,
+        float scaleX,
+        float scaleY) {
+      float scale = Math.min(Math.min(scaleX, scaleY), 1.0f);
+      float dx = parentRect.left + (parentRect.width() - childWidth * scale) * 0.5f;
+      float dy = parentRect.top + (parentRect.height() - childHeight * scale) * 0.5f;
+      outTransform.setScale(scale, scale);
+      outTransform.postTranslate((int) (dx + 0.5f), (int) (dy + 0.5f));
+    }
+
+    @Override
+    public String toString() {
+      return "center_inside";
+    }
+  }
+
+  public static class ScaleTypeCenterCrop extends AbstractScaleType {
+
+    public static final com.facebook.drawee.drawable.ScalingUtils.ScaleType INSTANCE = new ScaleTypeCenterCrop();
+
+    @Override
+    public void getTransformImpl(
+        Matrix outTransform,
+        Rect parentRect,
+        int childWidth,
+        int childHeight,
+        float focusX,
+        float focusY,
+        float scaleX,
+        float scaleY) {
+      float scale, dx, dy;
+      if (scaleY > scaleX) {
+        scale = scaleY;
+        dx = parentRect.left + (parentRect.width() - childWidth * scale) * 0.5f;
+        dy = parentRect.top;
+      } else {
+        scale = scaleX;
+        dx = parentRect.left;
+        dy = parentRect.top + (parentRect.height() - childHeight * scale) * 0.5f;
+      }
+      outTransform.setScale(scale, scale);
+      outTransform.postTranslate((int) (dx + 0.5f), (int) (dy + 0.5f));
+    }
+
+    @Override
+    public String toString() {
+      return "center_crop";
+    }
+  }
+
+  public static class ScaleTypeFocusCrop extends AbstractScaleType {
+
+    public static final com.facebook.drawee.drawable.ScalingUtils.ScaleType INSTANCE = new ScaleTypeFocusCrop();
+
+    @Override
+    public void getTransformImpl(
+        Matrix outTransform,
+        Rect parentRect,
+        int childWidth,
+        int childHeight,
+        float focusX,
+        float focusY,
+        float scaleX,
+        float scaleY) {
+      float scale, dx, dy;
+      if (scaleY > scaleX) {
+        scale = scaleY;
+        dx = parentRect.width() * 0.5f - childWidth * scale * focusX;
+        dx = parentRect.left + Math.max(Math.min(dx, 0), parentRect.width() - childWidth * scale);
+        dy = parentRect.top;
+      } else {
+        scale = scaleX;
+        dx = parentRect.left;
+        dy = parentRect.height() * 0.5f - childHeight * scale * focusY;
+        dy = parentRect.top + Math.max(Math.min(dy, 0), parentRect.height() - childHeight * scale);
+      }
+      outTransform.setScale(scale, scale);
+      outTransform.postTranslate((int) (dx + 0.5f), (int) (dy + 0.5f));
+    }
+
+    @Override
+    public String toString() {
+      return "focus_crop";
+    }
+  }
+
+  public static class ScaleTypeFitX extends AbstractScaleType {
+
+    public static final com.facebook.drawee.drawable.ScalingUtils.ScaleType INSTANCE = new ScaleTypeFitX();
+
+    @Override
+    public void getTransformImpl(
+        Matrix outTransform,
+        Rect parentRect,
+        int childWidth,
+        int childHeight,
+        float focusX,
+        float focusY,
+        float scaleX,
+        float scaleY) {
+      float scale, dx, dy;
+      scale = scaleX;
+      dx = parentRect.left;
+      dy = parentRect.top + (parentRect.height() - childHeight * scale) * 0.5f;
+      outTransform.setScale(scale, scale);
+      outTransform.postTranslate((int) (dx + 0.5f), (int) (dy + 0.5f));
+    }
+
+    @Override
+    public String toString() {
+      return "fit_x";
+    }
+  }
+
+  public static class ScaleTypeFitY extends AbstractScaleType {
+
+    public static final com.facebook.drawee.drawable.ScalingUtils.ScaleType INSTANCE = new ScaleTypeFitY();
+
+    @Override
+    public void getTransformImpl(
+        Matrix outTransform,
+        Rect parentRect,
+        int childWidth,
+        int childHeight,
+        float focusX,
+        float focusY,
+        float scaleX,
+        float scaleY) {
+      float scale, dx, dy;
+      scale = scaleY;
+      dx = parentRect.left + (parentRect.width() - childWidth * scale) * 0.5f;
+      dy = parentRect.top;
+      outTransform.setScale(scale, scale);
+      outTransform.postTranslate((int) (dx + 0.5f), (int) (dy + 0.5f));
+    }
+
+    @Override
+    public String toString() {
+      return "fit_y";
+    }
+  }
+}