@nativescript/core 9.0.0-next-09-24-2025-17985801416 → 9.0.0-next-10-06-2025-18277360121

package/platforms/android/java/org/nativescript/widgets/GridUnitType.java

@@ -0,0 +1,10 @@
+package org.nativescript.widgets;
+
+/**
+ * @author hhristov
+ */
+public enum GridUnitType {
+	auto,
+	pixel,
+	star
+}

package/platforms/android/java/org/nativescript/widgets/HorizontalScrollView.java

@@ -0,0 +1,256 @@
+package org.nativescript.widgets;
+
+import android.content.Context;
+import android.graphics.Rect;
+import android.os.Parcelable;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+
+/**
+ * @author hhristov
+ */
+public class HorizontalScrollView extends android.widget.HorizontalScrollView {
+
+	private final Rect mTempRect = new Rect();
+
+	private int contentMeasuredWidth = 0;
+	private int contentMeasuredHeight = 0;
+	private int scrollableLength = 0;
+	private ScrollSavedState mSavedState;
+	private boolean isFirstLayout = true;
+	private boolean scrollEnabled = true;
+
+	/**
+	 * True when the layout has changed but the traversal has not come through yet.
+	 * Ideally the view hierarchy would keep track of this for us.
+	 */
+	private boolean mIsLayoutDirty = true;
+
+	/**
+	 * The child to give focus to in the event that a child has requested focus while the
+	 * layout is dirty. This prevents the scroll from being wrong if the child has not been
+	 * laid out before requesting focus.
+	 */
+	private View mChildToScrollTo = null;
+
+	public HorizontalScrollView(Context context) {
+		super(context);
+	}
+
+	public int getScrollableLength() {
+		return this.scrollableLength;
+	}
+
+	public boolean getScrollEnabled() {
+		return this.scrollEnabled;
+	}
+
+	public void setScrollEnabled(boolean value) {
+		this.scrollEnabled = value;
+	}
+
+	@Override
+	public boolean onInterceptTouchEvent(MotionEvent ev) {
+		// Do nothing with intercepted touch events if we are not scrollable
+		if (!this.scrollEnabled) {
+			return false;
+		}
+
+		return super.onInterceptTouchEvent(ev);
+	}
+
+	@Override
+	public boolean onTouchEvent(MotionEvent ev) {
+		if (!this.scrollEnabled && (ev.getAction() == MotionEvent.ACTION_DOWN || ev.getAction() == MotionEvent.ACTION_MOVE)) {
+			return false;
+		}
+
+		return super.onTouchEvent(ev);
+	}
+
+	@Override
+	public void requestLayout() {
+		this.mIsLayoutDirty = true;
+		super.requestLayout();
+	}
+
+	@Override
+	protected CommonLayoutParams generateDefaultLayoutParams() {
+		return new CommonLayoutParams();
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	public CommonLayoutParams generateLayoutParams(AttributeSet attrs) {
+		return new CommonLayoutParams();
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	protected boolean checkLayoutParams(ViewGroup.LayoutParams p) {
+		return p instanceof CommonLayoutParams;
+	}
+
+	@Override
+	protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams from) {
+		if (from instanceof CommonLayoutParams)
+			return new CommonLayoutParams((CommonLayoutParams) from);
+
+		if (from instanceof FrameLayout.LayoutParams)
+			return new CommonLayoutParams((FrameLayout.LayoutParams) from);
+
+		if (from instanceof ViewGroup.MarginLayoutParams)
+			return new CommonLayoutParams((ViewGroup.MarginLayoutParams) from);
+
+		return new CommonLayoutParams(from);
+	}
+
+	@Override
+	public void requestChildFocus(View child, View focused) {
+		if (!mIsLayoutDirty) {
+			this.scrollToChild(focused);
+		} else {
+			// The child may not be laid out yet, we can't compute the scroll yet
+			mChildToScrollTo = focused;
+		}
+		super.requestChildFocus(child, focused);
+	}
+
+	@Override
+	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+		CommonLayoutParams.adjustChildrenLayoutParams(this, widthMeasureSpec, heightMeasureSpec);
+
+		// Don't call measure because it will measure content twice.
+		// ScrollView is expected to have single child so we measure only the first child.
+		View child = this.getChildCount() > 0 ? this.getChildAt(0) : null;
+		if (child == null) {
+			this.scrollableLength = 0;
+			this.contentMeasuredWidth = 0;
+			this.contentMeasuredHeight = 0;
+		} else {
+			CommonLayoutParams.measureChild(child, MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED), heightMeasureSpec);
+			this.contentMeasuredWidth = CommonLayoutParams.getDesiredWidth(child);
+			this.contentMeasuredHeight = CommonLayoutParams.getDesiredHeight(child);
+
+			// Android ScrollView does not account to child margins so we set them as paddings. Otherwise you can never scroll to bottom.
+			CommonLayoutParams lp = (CommonLayoutParams) child.getLayoutParams();
+			this.setPadding(lp.leftMargin, lp.topMargin, lp.rightMargin, lp.bottomMargin);
+		}
+
+		// Don't add in our paddings because they are already added as child margins. (we will include them twice if we add them).
+		// Check the previous line - this.setPadding(lp.leftMargin, lp.topMargin, lp.rightMargin, lp.bottomMargin);
+		//this.contentMeasuredWidth += this.getPaddingLeft() + this.getPaddingRight();
+		//this.contentMeasuredHeight += this.getPaddingTop() + this.getPaddingBottom();
+
+		// Check against our minimum height
+		this.contentMeasuredWidth = Math.max(this.contentMeasuredWidth, this.getSuggestedMinimumWidth());
+		this.contentMeasuredHeight = Math.max(this.contentMeasuredHeight, this.getSuggestedMinimumHeight());
+
+		int widthSizeAndState = resolveSizeAndState(this.contentMeasuredWidth, widthMeasureSpec, 0);
+		int heightSizeAndState = resolveSizeAndState(this.contentMeasuredHeight, heightMeasureSpec, 0);
+
+		this.setMeasuredDimension(widthSizeAndState, heightSizeAndState);
+	}
+
+	@Override
+	protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+		int childWidth = 0;
+		if (this.getChildCount() > 0) {
+			View child = this.getChildAt(0);
+			childWidth = child.getMeasuredWidth();
+
+			int width = right - left;
+			int height = bottom - top;
+
+			this.scrollableLength = this.contentMeasuredWidth - width;
+			CommonLayoutParams.layoutChild(child, 0, 0, Math.max(this.contentMeasuredWidth, width), height);
+			this.scrollableLength = Math.max(0, this.scrollableLength);
+		}
+
+		this.mIsLayoutDirty = false;
+		// Give a child focus if it needs it
+		if (this.mChildToScrollTo != null && Utils.isViewDescendantOf(this.mChildToScrollTo, this)) {
+			this.scrollToChild(this.mChildToScrollTo);
+		}
+
+		this.mChildToScrollTo = null;
+
+		int scrollX = this.getScrollX();
+		int scrollY = this.getScrollY();
+
+		if (this.isFirstLayout) {
+			this.isFirstLayout = false;
+
+			final int scrollRange = Math.max(0, childWidth - (right - left - this.getPaddingLeft() - this.getPaddingRight()));
+			if (this.mSavedState != null) {
+				scrollX = this.isLayoutRtl() ? scrollRange - mSavedState.scrollOffsetFromStart : mSavedState.scrollOffsetFromStart;
+				mSavedState = null;
+			} else {
+				if (this.isLayoutRtl()) {
+					scrollX = scrollRange - scrollX;
+				} // mScrollX default value is "0" for LTR
+			}
+			// Don't forget to clamp
+			if (scrollX > scrollRange) {
+				scrollX = scrollRange;
+			} else if (scrollX < 0) {
+				scrollX = 0;
+			}
+		}
+
+		// Calling this with the present values causes it to re-claim them
+		this.scrollTo(scrollX, scrollY);
+		CommonLayoutParams.restoreOriginalParams(this);
+	}
+
+	@Override
+	protected void onAttachedToWindow() {
+		super.onAttachedToWindow();
+		this.isFirstLayout = true;
+	}
+
+	@Override
+	protected void onDetachedFromWindow() {
+		super.onDetachedFromWindow();
+		this.isFirstLayout = true;
+	}
+
+	@Override
+	protected void onRestoreInstanceState(Parcelable state) {
+		ScrollSavedState ss = (ScrollSavedState) state;
+		super.onRestoreInstanceState(ss.getSuperState());
+		this.mSavedState = ss;
+		this.requestLayout();
+	}
+
+	@Override
+	protected Parcelable onSaveInstanceState() {
+		Parcelable superState = super.onSaveInstanceState();
+		ScrollSavedState ss = new ScrollSavedState(superState);
+		ss.scrollOffsetFromStart = isLayoutRtl() ? -this.getScrollX() : this.getScrollX();
+		return ss;
+	}
+
+	private void scrollToChild(View child) {
+		child.getDrawingRect(mTempRect);
+
+		/* Offset from child's local coordinates to ScrollView coordinates */
+		offsetDescendantRectToMyCoords(child, mTempRect);
+
+		int scrollDelta = computeScrollDeltaToGetChildRectOnScreen(mTempRect);
+		if (scrollDelta != 0) {
+			this.scrollBy(scrollDelta, 0);
+		}
+	}
+
+	private boolean isLayoutRtl() {
+		return (this.getLayoutDirection() == LAYOUT_DIRECTION_RTL);
+	}
+}

package/platforms/android/java/org/nativescript/widgets/ImageView.java

@@ -0,0 +1,423 @@
+package org.nativescript.widgets;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapShader;
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.Matrix;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.graphics.Shader;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.os.Build;
+
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.AppCompatDelegate;
+
+import org.nativescript.widgets.image.BitmapOwner;
+import org.nativescript.widgets.image.Fetcher;
+import org.nativescript.widgets.image.Worker;
+
+/**
+ * @author hhristov
+ */
+public class ImageView extends androidx.appcompat.widget.AppCompatImageView implements BitmapOwner {
+	private static final double EPSILON = 1E-05;
+
+	private final Path path = new Path();
+	private final RectF rect = new RectF();
+	private final Paint paint = new Paint();
+
+	private double scaleW = 1;
+	private double scaleH = 1;
+
+	private float rotationAngle;
+
+	private final Matrix mMatrix;
+	private Bitmap mBitmap;
+	private String mUri;
+	private int mDecodeWidth;
+	private int mDecodeHeight;
+	private boolean mKeepAspectRatio;
+	private boolean mUseCache;
+	private boolean mAsync;
+	private Worker.OnImageLoadedListener mListener;
+	private boolean mAttachedToWindow = false;
+
+	static {
+		AppCompatDelegate.setCompatVectorFromResourcesEnabled(true);
+	}
+
+	public float getRotationAngle() {
+		return rotationAngle;
+	}
+
+	public void setRotationAngle(float rotationAngle) {
+		this.rotationAngle = rotationAngle;
+		invalidate();
+	}
+
+	public ImageView(Context context) {
+		super(context);
+		this.mMatrix = new Matrix();
+		this.setScaleType(ScaleType.FIT_CENTER);
+	}
+
+	@Override
+	protected void onAttachedToWindow() {
+		mAttachedToWindow = true;
+		super.onAttachedToWindow();
+		this.loadImage();
+	}
+
+	@Override
+	protected void onDetachedFromWindow() {
+		mAttachedToWindow = false;
+		super.onDetachedFromWindow();
+		if (mUri != null) {
+			// Clear the bitmap as we are not in the visual tree.
+			this.setImageBitmap(null);
+		}
+	}
+
+	@Override
+	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+
+		int width = MeasureSpec.getSize(widthMeasureSpec);
+		int widthMode = MeasureSpec.getMode(widthMeasureSpec);
+
+		int height = MeasureSpec.getSize(heightMeasureSpec);
+		int heightMode = MeasureSpec.getMode(heightMeasureSpec);
+
+		Drawable drawable = this.getDrawable();
+		int measureWidth;
+		int measureHeight;
+		if (drawable != null) {
+			measureWidth = drawable.getIntrinsicWidth();
+			measureHeight = drawable.getIntrinsicHeight();
+		} else {
+			measureWidth = 0;
+			measureHeight = 0;
+		}
+
+		boolean finiteWidth = widthMode != MeasureSpec.UNSPECIFIED;
+		boolean finiteHeight = heightMode != MeasureSpec.UNSPECIFIED;
+
+		if (measureWidth != 0 && measureHeight != 0 && (finiteWidth || finiteHeight)) {
+			this.computeScaleFactor(width, height, finiteWidth, finiteHeight, measureWidth, measureHeight);
+			int resultW = (int) Math.round(measureWidth * this.scaleW);
+			int resultH = (int) Math.round(measureHeight * this.scaleH);
+
+			measureWidth = finiteWidth ? Math.min(resultW, width) : resultW;
+			measureHeight = finiteHeight ? Math.min(resultH, height) : resultH;
+		}
+
+		measureWidth += this.getPaddingLeft() + this.getPaddingRight();
+		measureHeight += this.getPaddingTop() + this.getPaddingBottom();
+
+		measureWidth = Math.max(measureWidth, getSuggestedMinimumWidth());
+		measureHeight = Math.max(measureHeight, getSuggestedMinimumHeight());
+
+		if (CommonLayoutParams.debuggable > 0) {
+			StringBuilder sb = CommonLayoutParams.getStringBuilder();
+			sb.append("ImageView onMeasure: ");
+			sb.append(MeasureSpec.toString(widthMeasureSpec));
+			sb.append(", ");
+			sb.append(MeasureSpec.toString(heightMeasureSpec));
+			sb.append(", stretch: ");
+			sb.append(this.getScaleType());
+			sb.append(", measureWidth: ");
+			sb.append(measureWidth);
+			sb.append(", measureHeight: ");
+			sb.append(measureHeight);
+
+			CommonLayoutParams.log(CommonLayoutParams.TAG, sb.toString());
+		}
+
+		int widthSizeAndState = resolveSizeAndState(measureWidth, widthMeasureSpec, 0);
+		int heightSizeAndState = resolveSizeAndState(measureHeight, heightMeasureSpec, 0);
+
+		this.setMeasuredDimension(widthSizeAndState, heightSizeAndState);
+	}
+
+	private void computeScaleFactor(int measureWidth, int measureHeight, boolean widthIsFinite, boolean heightIsFinite, double nativeWidth, double nativeHeight) {
+
+		this.scaleW = 1;
+		this.scaleH = 1;
+
+		ScaleType scale = this.getScaleType();
+		if ((scale == ScaleType.CENTER_CROP || scale == ScaleType.FIT_CENTER || scale == ScaleType.FIT_XY) &&
+			(widthIsFinite || heightIsFinite)) {
+
+			this.scaleW = (nativeWidth > 0) ? measureWidth / nativeWidth : 0d;
+			this.scaleH = (nativeHeight > 0) ? measureHeight / nativeHeight : 0d;
+
+			if (!widthIsFinite) {
+				this.scaleW = scaleH;
+			} else if (!heightIsFinite) {
+				this.scaleH = scaleW;
+			} else {
+				// No infinite dimensions.
+				switch (scale) {
+					case FIT_CENTER:
+						this.scaleH = Math.min(this.scaleW, this.scaleH);
+						this.scaleW = this.scaleH;
+						break;
+					case CENTER_CROP:
+						this.scaleH = Math.max(this.scaleW, this.scaleH);
+						this.scaleW = this.scaleH;
+						break;
+					default:
+						break;
+				}
+			}
+		}
+	}
+
+	public void setUri(String uri, int decodeWidth, int decodeHeight, boolean useCache, boolean async) {
+		this.setUri(uri, decodeWidth, decodeHeight, false, useCache, async);
+	}
+
+	public void setUri(String uri, int decodeWidth, int decodeHeight, boolean keepAspectRatio, boolean useCache, boolean async) {
+		mUri = uri;
+		mDecodeWidth = decodeWidth;
+		mDecodeHeight = decodeHeight;
+		mKeepAspectRatio = keepAspectRatio;
+		mUseCache = useCache;
+		mAsync = async;
+
+		// Clear current bitmap only if we set empty URI.
+		// We support setting bitmap through ImageSource (e.g. Bitmap).
+		if (uri == null || uri.trim().equals("")) {
+			this.setImageBitmap(null);
+		}
+
+		// Begin loading image only if we are attached to window.
+		if (mAttachedToWindow) {
+			loadImage();
+		}
+	}
+
+	public void setImageLoadedListener(Worker.OnImageLoadedListener listener) {
+		mListener = listener;
+	}
+
+	private void loadImage() {
+		Fetcher fetcher = Fetcher.getInstance(this.getContext());
+		if (mUri != null && fetcher != null) {
+			// Get the Bitmap from cache.
+			fetcher.loadImage(mUri, this, mDecodeWidth, mDecodeHeight, mKeepAspectRatio, mUseCache, mAsync, mListener);
+		}
+	}
+
+	private boolean mSettingBitmap = false;
+
+	@Override
+	public void setImageBitmap(Bitmap bm) {
+		Fetcher fetcher = Fetcher.getInstance(this.getContext());
+		// if we have existing bitmap from uri notify fetcher that this bitmap is not shown in this ImageView instance.
+		// This is needed so that fetcher inner cache could reuse the bitmap only when no other ImageView shows it.
+		if (mUseCache && mUri != null && mBitmap != null && fetcher != null) {
+			fetcher.removeBitmap(mUri);
+		}
+		mSettingBitmap = true;
+		super.setImageBitmap(bm);
+		this.mBitmap = bm;
+		if (bm != null) {
+			bitmapWidth = bm.getWidth();
+			bitmapHeight = bm.getHeight();
+			bitmapShader = new BitmapShader(mBitmap, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);
+		} else {
+			bitmapWidth = -1;
+			bitmapHeight = -1;
+		}
+		mSettingBitmap = false;
+	}
+
+	@Override
+	public void setImageDrawable(@Nullable Drawable drawable) {
+		super.setImageDrawable(drawable);
+		setBitmapShader();
+	}
+
+
+	private final Canvas canvas = new Canvas();
+	private BitmapShader bitmapShader = null;
+	private int bitmapWidth = -1;
+	private int bitmapHeight = -1;
+
+	private void setBitmapShader() {
+		if (mSettingBitmap) {
+			return;
+		}
+		Bitmap mBitmap = null;
+		Drawable drawable = getDrawable();
+		if (drawable != null) {
+
+			if (drawable instanceof BitmapDrawable) {
+				mBitmap = ((BitmapDrawable) drawable).getBitmap();
+			} else {
+				Bitmap bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
+				canvas.setBitmap(bitmap);
+				Rect previousBounds = null;
+
+				if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+					previousBounds = drawable.getBounds();
+					drawable.setBounds(0, 0, drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight());
+				}
+
+				drawable.draw(canvas);
+
+				if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+					drawable.setBounds(previousBounds);
+				}
+				mBitmap = bitmap;
+			}
+		} else {
+			bitmapShader = null;
+		}
+
+		if (mBitmap != null) {
+			bitmapWidth = mBitmap.getWidth();
+			bitmapHeight = mBitmap.getHeight();
+			bitmapShader = new BitmapShader(mBitmap, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);
+		} else {
+			bitmapWidth = -1;
+			bitmapHeight = -1;
+		}
+
+	}
+
+
+	@Override
+	protected void onDraw(Canvas canvas) {
+		BorderDrawable background = this.getBackground() instanceof BorderDrawable ? (BorderDrawable) this.getBackground() : null;
+		if (this.mBitmap == null && this.getDrawable() != null) {
+			super.onDraw(canvas);
+		}
+		if (this.mBitmap != null) {
+			float borderTopLeftRadius, borderTopRightRadius, borderBottomRightRadius, borderBottomLeftRadius;
+
+			if (background != null) {
+				background.draw(canvas);
+
+				borderTopLeftRadius = background.getBorderTopLeftRadius();
+				borderTopRightRadius = background.getBorderTopRightRadius();
+				borderBottomRightRadius = background.getBorderBottomRightRadius();
+				borderBottomLeftRadius = background.getBorderBottomLeftRadius();
+			} else {
+				borderTopLeftRadius = borderTopRightRadius = borderBottomRightRadius = borderBottomLeftRadius = 0;
+			}
+
+			// Padding?
+			float borderTopWidth = this.getPaddingTop();
+			float borderRightWidth = this.getPaddingRight();
+			float borderBottomWidth = this.getPaddingBottom();
+			float borderLeftWidth = this.getPaddingLeft();
+
+			float innerWidth, innerHeight;
+
+			float rotationDegree = this.getRotationAngle();
+			boolean swap = Math.abs(rotationDegree % 180) > 45 && Math.abs(rotationDegree % 180) < 135;
+
+			innerWidth = this.getWidth() - borderLeftWidth - borderRightWidth;
+			innerHeight = this.getHeight() - borderTopWidth - borderBottomWidth;
+
+			// TODO: Capture all created objects here in locals and update them instead...
+			path.reset();
+			paint.reset();
+
+			float[] radii = {
+				Math.max(0, borderTopLeftRadius - borderLeftWidth), Math.max(0, borderTopLeftRadius - borderTopWidth),
+				Math.max(0, borderTopRightRadius - borderRightWidth), Math.max(0, borderTopRightRadius - borderTopWidth),
+				Math.max(0, borderBottomRightRadius - borderRightWidth), Math.max(0, borderBottomRightRadius - borderBottomWidth),
+				Math.max(0, borderBottomLeftRadius - borderLeftWidth), Math.max(0, borderBottomLeftRadius - borderBottomWidth)
+			};
+
+			rect.setEmpty();
+			rect.set(borderLeftWidth, borderTopWidth, borderLeftWidth + innerWidth, borderTopWidth + innerHeight);
+
+			path.addRoundRect(rect, radii, Path.Direction.CW);
+
+
+			float bitmapWidth = (float) mBitmap.getWidth();
+			float bitmapHeight = (float) mBitmap.getHeight();
+
+			Matrix matrix = this.mMatrix;
+			matrix.reset();
+
+			matrix.postRotate(rotationDegree, bitmapWidth / 2, bitmapHeight / 2);
+			if (swap) {
+				matrix.postTranslate((bitmapHeight - bitmapWidth) / 2, (bitmapWidth - bitmapHeight) / 2);
+				float temp = bitmapWidth;
+				bitmapWidth = bitmapHeight;
+				bitmapHeight = temp;
+			}
+
+			float fittingScaleX = innerWidth / bitmapWidth;
+			float fittingScaleY = innerHeight / bitmapHeight;
+
+			float uniformScale;
+			float pivotX, pivotY;
+			switch (this.getScaleType()) {
+				case FIT_CENTER: // aspectFit
+					uniformScale = Math.min(fittingScaleX, fittingScaleY);
+					matrix.postTranslate((innerWidth - bitmapWidth) / 2, (innerHeight - bitmapHeight) / 2);
+					matrix.postScale(uniformScale, uniformScale, innerWidth / 2, innerHeight / 2);
+					canvas.clipRect(
+						borderLeftWidth + (innerWidth - bitmapWidth * uniformScale) / 2,
+						borderTopWidth + (innerHeight - bitmapHeight * uniformScale) / 2,
+						borderLeftWidth + (innerWidth + bitmapWidth * uniformScale) / 2,
+						borderTopWidth + (innerHeight + bitmapHeight * uniformScale) / 2
+					);
+					break;
+				case CENTER_CROP: // aspectFill
+					uniformScale = Math.max(fittingScaleX, fittingScaleY);
+					matrix.postTranslate((innerWidth - bitmapWidth) / 2, (innerHeight - bitmapHeight) / 2);
+					matrix.postScale(uniformScale, uniformScale, innerWidth / 2, innerHeight / 2);
+					canvas.clipRect(
+						borderLeftWidth + (innerWidth - bitmapWidth * uniformScale) / 2,
+						borderTopWidth + (innerHeight - bitmapHeight * uniformScale) / 2,
+						borderLeftWidth + (innerWidth + bitmapWidth * uniformScale) / 2,
+						borderTopWidth + (innerHeight + bitmapHeight * uniformScale) / 2
+					);
+					break;
+				case FIT_XY: // fill
+					matrix.postScale(fittingScaleX, fittingScaleY);
+					break;
+				case MATRIX: // none
+					canvas.clipRect(
+						borderLeftWidth,
+						borderTopWidth,
+						borderLeftWidth + bitmapWidth,
+						borderTopWidth + bitmapHeight
+					);
+					break;
+			}
+			matrix.postTranslate(borderLeftWidth, borderTopWidth);
+			bitmapShader.setLocalMatrix(matrix);
+			paint.setAntiAlias(true);
+			paint.setFilterBitmap(true);
+			paint.setShader(bitmapShader);
+			ColorFilter filter = this.getColorFilter();
+			if (filter != null) {
+				paint.setColorFilter(filter);
+			}
+			canvas.drawPath(path, paint);
+		}
+	}
+
+	@Override
+	public void setBitmap(Bitmap value) {
+		this.setImageBitmap(value);
+	}
+
+	@Override
+	public void setDrawable(Drawable asyncDrawable) {
+		this.setImageDrawable(asyncDrawable);
+	}
+}