NativeScript/nativescript-core/image-asset/index.android.ts

import { ImageAssetBase, getRequestedImageSize } from "./image-asset-common";
import { path as fsPath, knownFolders } from "../file-system";

export * from "./image-asset-common";

export class ImageAsset extends ImageAssetBase {
	private _android: string; //file name of the image

	constructor(asset: string) {
		super();
		let fileName = typeof asset === "string" ? asset.trim() : "";
		if (fileName.indexOf("~/") === 0) {
			fileName = fsPath.join(
				knownFolders.currentApp().path,
				fileName.replace("~/", "")
			);
		}
		this.android = fileName;
	}

	get android(): string {
		return this._android;
	}

	set android(value: string) {
		this._android = value;
	}

	public getImageAsync(callback: (image, error) => void) {
		let bitmapOptions = new android.graphics.BitmapFactory.Options();
		bitmapOptions.inJustDecodeBounds = true;
		// read only the file size
		let bitmap = android.graphics.BitmapFactory.decodeFile(
			this.android,
			bitmapOptions
		);
		let sourceSize = {
			width: bitmapOptions.outWidth,
			height: bitmapOptions.outHeight,
		};
		let requestedSize = getRequestedImageSize(sourceSize, this.options);

		let sampleSize = org.nativescript.widgets.image.Fetcher.calculateInSampleSize(
			bitmapOptions.outWidth,
			bitmapOptions.outHeight,
			requestedSize.width,
			requestedSize.height
		);

		let finalBitmapOptions = new android.graphics.BitmapFactory.Options();
		finalBitmapOptions.inSampleSize = sampleSize;
		try {
			let error = null;
			// read as minimum bitmap as possible (slightly bigger than the requested size)
			bitmap = android.graphics.BitmapFactory.decodeFile(
				this.android,
				finalBitmapOptions
			);

			if (bitmap) {
				if (
					requestedSize.width !== bitmap.getWidth() ||
					requestedSize.height !== bitmap.getHeight()
				) {
					// scale to exact size
					bitmap = android.graphics.Bitmap.createScaledBitmap(
						bitmap,
						requestedSize.width,
						requestedSize.height,
						true
					);
				}

				const rotationAngle = calculateAngleFromFile(this.android);
				if (rotationAngle !== 0) {
					const matrix = new android.graphics.Matrix();
					matrix.postRotate(rotationAngle);
					bitmap = android.graphics.Bitmap.createBitmap(
						bitmap,
						0,
						0,
						bitmap.getWidth(),
						bitmap.getHeight(),
						matrix,
						true
					);
				}
			}

			if (!bitmap) {
				error = "Asset '" + this.android + "' cannot be found.";
			}

			callback(bitmap, error);
		} catch (ex) {
			callback(null, ex);
		}
	}
}

function calculateAngleFromFile(filename: string) {
	let rotationAngle = 0;
	const ei = new android.media.ExifInterface(filename);
	const orientation = ei.getAttributeInt(
		android.media.ExifInterface.TAG_ORIENTATION,
		android.media.ExifInterface.ORIENTATION_NORMAL
	);

	switch (orientation) {
		case android.media.ExifInterface.ORIENTATION_ROTATE_90:
			rotationAngle = 90;
			break;
		case android.media.ExifInterface.ORIENTATION_ROTATE_180:
			rotationAngle = 180;
			break;
		case android.media.ExifInterface.ORIENTATION_ROTATE_270:
			rotationAngle = 270;
			break;
	}

	return rotationAngle;
}