@akylas/nativescript-app-utils 1.0.0 → 2.1.1

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.1.1](https://github.com/akylas/nativescript-app-utils/compare/v2.1.0...v2.1.1) (2024-10-05)
+
+### Bug Fixes
+
+* **android:** allow to prepare activity without enabling dynamic colors ([103a466](https://github.com/akylas/nativescript-app-utils/commit/103a4669487767b0674dc06a3d1a991717300b5c))
+
+## [2.1.0](https://github.com/akylas/nativescript-app-utils/compare/v2.0.0...v2.1.0) (2024-10-03)
+
+**Note:** Version bump only for package @akylas/nativescript-app-utils
+
+## [2.0.0](https://github.com/akylas/nativescript-app-utils/compare/v1.0.0...v2.0.0) (2024-10-03)
+
+### Features
+
+* new app utils ([00094ad](https://github.com/akylas/nativescript-app-utils/commit/00094ad84b16d13f565747ea235c05520261076d))
+
 ## 1.0.0 (2024-10-03)
 
 **Note:** Version bump only for package @akylas/nativescript-app-utils

package/index.android.d.ts

@@ -1,14 +1,31 @@
+import { ImageSource } from '@nativescript/core';
 export declare namespace AppUtilsAndroid {
     function listenForWindowInsets(onWindowInsetsChange: (result: [number, number, number, number, number]) => void): void;
     function prepareWindow(window: android.view.Window): void;
     function getDimensionFromInt(context: android.content.Context, intToGet: number): number;
     function getColorFromInt(context: android.content.Context, intToGet: number): number;
     function getColorFromName(context: android.content.Context, name: string): number;
-    function restartApp(): any;
-    function prepareActivity(activity: androidx.appcompat.app.AppCompatActivity): any;
+    function prepareActivity(activity: androidx.appcompat.app.AppCompatActivity, applyDynamicColors?: boolean): any;
     function applyDayNight(activity: androidx.appcompat.app.AppCompatActivity, applyDynamicColors: boolean): any;
     function applyDynamicColors(activity: androidx.appcompat.app.AppCompatActivity): any;
 }
+export declare function restartApp(): any;
 export declare function setWorkerContextValue(key: any, value: any): void;
 export declare function getWorkerContextValue(key: any): any;
 export declare function getISO3Language(lang: any): string;
+export declare function loadImageSync(imagePath: any, loadOptions?: {
+    width?: any;
+    height?: any;
+    resizeThreshold?: any;
+    sourceWidth?: any;
+    sourceHeight?: any;
+    jpegQuality?: any;
+}): ImageSource;
+export declare function loadImage(imagePath: any, loadOptions?: {
+    width?: any;
+    height?: any;
+    resizeThreshold?: any;
+    sourceWidth?: any;
+    sourceHeight?: any;
+    jpegQuality?: any;
+}): Promise<any[]>;

package/index.android.js

@@ -1,9 +1,31 @@
-import { Application, Utils } from '@nativescript/core';
+import { Application, ImageSource, Utils } from '@nativescript/core';
+function functionCallbackPromise(onCallback, transformer = (v) => v, errorHandler = (e) => e) {
+    return new Promise((resolve, reject) => {
+        const callback = new com.nativescript.apputils.FunctionCallback({
+            onResult(e, result) {
+                if (e) {
+                    reject(errorHandler(e));
+                }
+                else {
+                    try {
+                        resolve(transformer(result));
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                    finally {
+                    }
+                }
+            }
+        });
+        onCallback(callback);
+    });
+}
 const NWorkerContext = com.nativescript.apputils.WorkersContext.Companion;
+const NUtils = com.nativescript.apputils.Utils;
+const UtilsCompanion = NUtils.Companion;
 export var AppUtilsAndroid;
 (function (AppUtilsAndroid) {
-    const NUtils = com.nativescript.apputils.Utils;
-    const UtilsCompanion = NUtils.Companion;
     function listenForWindowInsets(onWindowInsetsChange) {
         const rootView = Application.getRootView();
         if (rootView) {
@@ -29,12 +51,8 @@ export var AppUtilsAndroid;
         return UtilsCompanion.getColorFromName(context, name);
     }
     AppUtilsAndroid.getColorFromName = getColorFromName;
-    function restartApp() {
-        return UtilsCompanion.restartApp(Utils.android.getApplicationContext(), Application.android.startActivity);
-    }
-    AppUtilsAndroid.restartApp = restartApp;
-    function prepareActivity(activity) {
-        return UtilsCompanion.prepareActivity(activity);
+    function prepareActivity(activity, applyDynamicColors = true) {
+        return UtilsCompanion.prepareActivity(activity, applyDynamicColors);
     }
     AppUtilsAndroid.prepareActivity = prepareActivity;
     function applyDayNight(activity, applyDynamicColors) {
@@ -46,6 +64,9 @@ export var AppUtilsAndroid;
     }
     AppUtilsAndroid.applyDynamicColors = applyDynamicColors;
 })(AppUtilsAndroid || (AppUtilsAndroid = {}));
+export function restartApp() {
+    return UtilsCompanion.restartApp(Utils.android.getApplicationContext(), Application.android.startActivity);
+}
 export function setWorkerContextValue(key, value) {
     NWorkerContext.setValue(key, value);
 }
@@ -56,4 +77,14 @@ export function getISO3Language(lang) {
     const locale = java.util.Locale.forLanguageTag(lang);
     return locale.getISO3Language();
 }
+export function loadImageSync(imagePath, loadOptions = {}) {
+    loadOptions.resizeThreshold ?? (loadOptions.resizeThreshold = 4500);
+    return new ImageSource(com.nativescript.apputils.ImageUtils.Companion.readBitmapFromFileSync(Utils.android.getApplicationContext(), imagePath, JSON.stringify(loadOptions)));
+}
+export function loadImage(imagePath, loadOptions = {}) {
+    loadOptions.resizeThreshold ?? (loadOptions.resizeThreshold = 4500);
+    return functionCallbackPromise((callback) => {
+        com.nativescript.apputils.ImageUtils.Companion.readBitmapFromFile(Utils.android.getApplicationContext(), imagePath, callback, JSON.stringify(loadOptions));
+    }, (e) => new ImageSource(e));
+}
 //# sourceMappingURL=index.android.js.map

package/index.ios.d.ts

@@ -1,14 +1,31 @@
+import { ImageSource } from '@nativescript/core';
 export declare namespace AppUtilsAndroid {
     function listenForWindowInsets(onWindowInsetsChange: (result: [number, number, number, number, number]) => void): void;
     function prepareWindow(window: any): void;
     function getDimensionFromInt(context: any, intToGet: number): void;
     function getColorFromInt(context: any, intToGet: number): void;
     function getColorFromName(context: any, intToGet: number): void;
-    function restartApp(): void;
     function prepareActivity(activity: any): void;
     function applyDayNight(activity: any, applyDynamicColors: boolean): void;
     function applyDynamicColors(activity: any): void;
 }
+export declare function restartApp(): void;
 export declare function setWorkerContextValue(key: any, value: any): void;
 export declare function getWorkerContextValue(key: any): any;
 export declare function getISO3Language(lang: any): any;
+export declare function loadImageSync(imagePath: any, loadOptions?: {
+    width?: any;
+    height?: any;
+    resizeThreshold?: any;
+    sourceWidth?: any;
+    sourceHeight?: any;
+    jpegQuality?: any;
+}): ImageSource;
+export declare function loadImage(imagePath: any, loadOptions?: {
+    width?: any;
+    height?: any;
+    resizeThreshold?: any;
+    sourceWidth?: any;
+    sourceHeight?: any;
+    jpegQuality?: any;
+}): void;

package/index.ios.js

@@ -1,3 +1,55 @@
+import { ImageSource } from '@nativescript/core';
+var NCompletionDelegateImpl = /** @class */ (function (_super) {
+    __extends(NCompletionDelegateImpl, _super);
+    function NCompletionDelegateImpl() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    NCompletionDelegateImpl.prototype.onCompleteError = function (result, error) {
+        if (error) {
+            this.reject(error);
+        }
+        else {
+            if (this.shouldParse && typeof result === 'string') {
+                this.resolve(result ? JSON.parse(result) : null);
+            }
+            else {
+                this.resolve(result);
+            }
+        }
+    };
+    NCompletionDelegateImpl.prototype.onProgress = function (progress) {
+        var _a;
+        (_a = this.progress) === null || _a === void 0 ? void 0 : _a.call(this, progress);
+    };
+    NCompletionDelegateImpl.initWithResolveReject = function (resolve, reject, progress, shouldParse) {
+        if (shouldParse === void 0) { shouldParse = true; }
+        var delegate = NCompletionDelegateImpl.new();
+        delegate.resolve = resolve;
+        delegate.reject = reject;
+        delegate.onProgress = progress;
+        delegate.shouldParse = shouldParse;
+        return delegate;
+    };
+    NCompletionDelegateImpl.ObjCProtocols = [NCompletionDelegate];
+    return NCompletionDelegateImpl;
+}(NSObject));
+function functionCallbackPromise(onCallback, transformer = (v) => v, errorHandler = (e) => e, shouldParse, onProgress) {
+    return new Promise((resolve, reject) => {
+        const delegate = NCompletionDelegateImpl.initWithResolveReject((result) => {
+            try {
+                resolve(transformer(result));
+            }
+            catch (error) {
+                reject(error);
+            }
+            finally {
+            }
+        }, (error) => {
+            reject(errorHandler(error));
+        }, onProgress, shouldParse);
+        onCallback(delegate);
+    });
+}
 export var AppUtilsAndroid;
 (function (AppUtilsAndroid) {
     function listenForWindowInsets(onWindowInsetsChange) { }
@@ -10,8 +62,6 @@ export var AppUtilsAndroid;
     AppUtilsAndroid.getColorFromInt = getColorFromInt;
     function getColorFromName(context, intToGet) { }
     AppUtilsAndroid.getColorFromName = getColorFromName;
-    function restartApp() { }
-    AppUtilsAndroid.restartApp = restartApp;
     function prepareActivity(activity) { }
     AppUtilsAndroid.prepareActivity = prepareActivity;
     function applyDayNight(activity, applyDynamicColors) { }
@@ -19,6 +69,7 @@ export var AppUtilsAndroid;
     function applyDynamicColors(activity) { }
     AppUtilsAndroid.applyDynamicColors = applyDynamicColors;
 })(AppUtilsAndroid || (AppUtilsAndroid = {}));
+export function restartApp() { }
 export function setWorkerContextValue(key, value) {
     NWorkerContext.setValue(key, value);
 }
@@ -28,4 +79,14 @@ export function getWorkerContextValue(key) {
 export function getISO3Language(lang) {
     return NSLocale.alloc().initWithLocaleIdentifier(lang).ISO639_2LanguageCode();
 }
+export function loadImageSync(imagePath, loadOptions = {}) {
+    loadOptions.resizeThreshold ?? (loadOptions.resizeThreshold = 4500);
+    return new ImageSource(ImageUtils.readImageFromFileSync(imagePath, JSON.stringify(loadOptions)));
+}
+export function loadImage(imagePath, loadOptions = {}) {
+    loadOptions.resizeThreshold ?? (loadOptions.resizeThreshold = 4500);
+    functionCallbackPromise((delegate) => {
+        ImageUtils.readImageFromFile(imagePath, delegate, JSON.stringify(loadOptions));
+    }, (e) => new ImageSource(e));
+}
 //# sourceMappingURL=index.ios.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@akylas/nativescript-app-utils",
-    "version": "1.0.0",
+    "version": "2.1.1",
     "description": "Provides API for changing the styles of SystemUI (StatusBar, NavigationBar...) on iOS.",
     "main": "index",
     "sideEffects": false,
@@ -63,5 +63,5 @@
     "bugs": {
         "url": "https://github.com/akylas/nativescript-app-utils/issues"
     },
-    "gitHead": "209db3a7039c188b6cf65b97ab6384f70b6f9515"
+    "gitHead": "23dbebb1eed5374be644bb39f8dd2ede6ed43a86"
 }

package/platforms/android/include.gradle

@@ -3,10 +3,11 @@ dependencies {
     def androidxVersion =  project.hasProperty("androidxVersion") ? project.androidxVersion : "1.2.0"
     def androidXAppCompat =  project.hasProperty("androidXAppCompat") ? project.androidXAppCompat : "1.1.0"
 	def androidXMaterial =  project.hasProperty("androidXMaterial") ? project.androidXMaterial : "1.8.0"
+	def androidXExifInterface =  project.hasProperty("androidXExifInterface") ? project.androidXExifInterface : "1.3.7"
     
 	implementation "com.google.android.material:material:$androidXMaterial"
 	implementation "androidx.appcompat:appcompat:$androidXAppCompat"
     implementation "androidx.core:core-splashscreen:$androidXSplashscreenVersion"
 	implementation "androidx.core:core:$androidxVersion"
-
+    implementation "androidx.exifinterface:exifinterface:$androidXExifInterface"
 }

package/platforms/android/java/com/nativescript/apputils/FunctionCallback.kt

@@ -0,0 +1,5 @@
+package com.nativescript.apputils
+
+interface FunctionCallback {
+    fun onResult(e: Exception?, result: Any?)
+}

package/platforms/android/java/com/nativescript/apputils/ImageUtils.kt

@@ -0,0 +1,419 @@
+package com.nativescript.apputils
+
+import android.content.ContentResolver
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Matrix
+import android.net.Uri
+import android.os.ParcelFileDescriptor
+import android.util.Log
+import androidx.exifinterface.media.ExifInterface
+import org.json.JSONException
+import org.json.JSONObject
+import java.io.FileDescriptor
+import java.io.FileNotFoundException
+import java.io.IOException
+import kotlin.math.floor
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.concurrent.thread
+
+import com.nativescript.apputils.FunctionCallback
+
+/**
+ * This class contains helper functions for processing images
+ *
+ * @constructor creates image util
+ */
+class ImageUtils {
+
+    class LoadImageOptions {
+        var options: JSONObject? = null
+        var sourceWidth = 0
+        var sourceHeight = 0
+        var width = 0
+        var maxWidth = 0
+        var height = 0
+        var maxHeight = 0
+        var keepAspectRatio = true
+        var autoScaleFactor = true
+
+        fun initWithJSON(jsonOpts: JSONObject)
+        {
+            options = jsonOpts
+            if (jsonOpts.has("resizeThreshold")) {
+                maxWidth = jsonOpts.optInt("resizeThreshold", maxWidth)
+                maxHeight = maxWidth
+            } else if (jsonOpts.has("maxSize")) {
+                maxWidth = jsonOpts.optInt("maxSize", maxWidth)
+                maxHeight = maxWidth
+            }
+            if (jsonOpts.has("width")) {
+                width = jsonOpts.optInt("width", width)
+            } else if (jsonOpts.has("maxWidth")) {
+                maxWidth = jsonOpts.optInt("maxWidth", maxWidth)
+            }
+            if (jsonOpts.has("height")) {
+                height = jsonOpts.optInt("height", height)
+            } else if (jsonOpts.has("maxHeight")) {
+                maxHeight = jsonOpts.optInt("maxHeight", maxHeight)
+            }
+            sourceWidth = jsonOpts.optInt("sourceWidth", sourceWidth)
+            sourceHeight = jsonOpts.optInt("sourceHeight", sourceHeight)
+            keepAspectRatio = jsonOpts.optBoolean("keepAspectRatio", keepAspectRatio)
+            autoScaleFactor = jsonOpts.optBoolean("autoScaleFactor", autoScaleFactor)
+
+        }
+        constructor(options: String?) {
+            if (options != null) {
+                try {
+                    val jsonOpts = JSONObject(options)
+                    initWithJSON(jsonOpts)
+                } catch (ignored: JSONException) {
+                }
+            }
+        }
+        constructor(jsonOpts: JSONObject) {
+            initWithJSON(jsonOpts)
+        }
+
+        var resizeThreshold = 0
+            get() { return min(maxWidth, maxHeight)}
+
+
+    }
+
+    class ImageAssetOptions {
+        var width = 0
+        var height = 0
+        var keepAspectRatio = true
+        var autoScaleFactor = true
+
+        constructor(sourceSize: Pair<Int, Int>) {
+            width = sourceSize.first
+            height = sourceSize.second
+        }
+        constructor(sourceSize: Pair<Int, Int>, options: LoadImageOptions?) {
+            width = sourceSize.first
+            height = sourceSize.second
+            if (options != null) {
+                if (options.width > 0) {
+                    width = options.width
+                }
+                if (options.height > 0) {
+                    height = options.height
+                }
+                if (options.maxWidth > 0) {
+                    width = min(
+                        width,
+                        options.maxWidth
+                    )
+                }
+                if (options.maxHeight > 0) {
+                    height = min(
+                        height,
+                        options.maxHeight
+                    )
+                }
+                keepAspectRatio = options.keepAspectRatio
+                autoScaleFactor = options.autoScaleFactor
+            }
+        }
+    }
+    companion object {
+        fun getTargetFormat(format: String?): Bitmap.CompressFormat {
+            return when (format) {
+                "jpeg", "jpg" -> Bitmap.CompressFormat.JPEG
+                else -> Bitmap.CompressFormat.PNG
+            }
+        }
+        /**
+         * Calculate an inSampleSize for use in a [BitmapFactory.Options] object when decoding
+         * bitmaps using the decode* methods from [BitmapFactory]. This implementation calculates
+         * the closest inSampleSize that is a power of 2 and will result in the final decoded bitmap
+         * having a width and height equal to or larger than the requested width and height.
+         *
+         * @param imageWidth  The original width of the resulting bitmap
+         * @param imageHeight The original height of the resulting bitmap
+         * @param reqWidth    The requested width of the resulting bitmap
+         * @param reqHeight   The requested height of the resulting bitmap
+         * @return The value to be used for inSampleSize
+         */
+        fun calculateInSampleSize(
+            imageWidth: Int,
+            imageHeight: Int,
+            reqWidth: Int,
+            reqHeight: Int
+        ): Int {
+            // BEGIN_INCLUDE (calculate_sample_size)
+            // Raw height and width of image
+            var reqWidth = reqWidth
+            var reqHeight = reqHeight
+            reqWidth = if (reqWidth > 0) reqWidth else imageWidth
+            reqHeight = if (reqHeight > 0) reqHeight else imageHeight
+            var inSampleSize = 1
+            if (imageHeight > reqHeight || imageWidth > reqWidth) {
+                val halfHeight = imageHeight / 2
+                val halfWidth = imageWidth / 2
+
+                // Calculate the largest inSampleSize value that is a power of 2 and keeps both
+                // height and width larger than the requested height and width.
+                while (halfHeight / inSampleSize > reqHeight && halfWidth / inSampleSize > reqWidth) {
+                    inSampleSize *= 2
+                }
+
+                // This offers some additional logic in case the image has a strange
+                // aspect ratio. For example, a panorama may have a much larger
+                // width than height. In these cases the total pixels might still
+                // end up being too large to fit comfortably in memory, so we should
+                // be more aggressive with sample down the image (=larger inSampleSize).
+                var totalPixels =
+                    (imageWidth / inSampleSize * (imageHeight / inSampleSize)).toLong()
+
+                // Anything more than 2x the requested pixels we'll sample down further
+                val totalReqPixelsCap = (reqWidth * reqHeight * 2).toLong()
+                while (totalPixels > totalReqPixelsCap) {
+                    inSampleSize *= 2
+                    totalPixels =
+                        (imageWidth / inSampleSize * (imageHeight / inSampleSize)).toLong()
+                }
+            }
+            return inSampleSize
+            // END_INCLUDE (calculate_sample_size)
+        }
+
+        private fun getAspectSafeDimensions(
+            sourceWidth: Int,
+            sourceHeight: Int,
+            reqWidth: Int,
+            reqHeight: Int
+        ): Pair<Int, Int> {
+            val widthCoef = sourceWidth.toDouble() / reqWidth.toDouble()
+            val heightCoef = sourceHeight.toDouble() / reqHeight.toDouble()
+            val imageRatio = sourceWidth.toDouble() / sourceHeight.toDouble()
+//            val aspectCoef = max(widthCoef, heightCoef)
+            if (widthCoef > heightCoef) {
+                return Pair(reqWidth, (reqWidth/imageRatio).toInt())
+            } else {
+                return Pair((reqHeight*imageRatio).toInt(), reqHeight)
+
+            }
+//            return Pair(
+//                ((sourceWidth / aspectCoef)).toInt(),
+//                ((sourceHeight / aspectCoef)).toInt()
+//            )
+        }
+        private fun getRequestedImageSize(
+            src: Pair<Int, Int>,
+            options: ImageAssetOptions
+        ): Pair<Int, Int> {
+            var reqWidth = options.width
+            if (reqWidth <= 0) {
+                reqWidth = src.first
+            }
+            var reqHeight = options.height
+            if (reqHeight <= 0) {
+                reqHeight = src.second
+            }
+            if (options.keepAspectRatio) {
+                val (first, second) = getAspectSafeDimensions(
+                    src.first,
+                    src.second,
+                    reqWidth,
+                    reqHeight
+                )
+                reqWidth = first
+                reqHeight = second
+            }
+            return Pair(reqWidth, reqHeight)
+        }
+
+        private fun closePfd(pfd: ParcelFileDescriptor?) {
+            if (pfd != null) {
+                try {
+                    pfd.close()
+                } catch (ignored: IOException) {
+                }
+            }
+        }
+
+        private fun calculateAngleFromFile(filename: String): Int {
+            var rotationAngle = 0
+            val ei: ExifInterface
+            try {
+                ei = ExifInterface(filename)
+                val orientation = ei.getAttributeInt(
+                    ExifInterface.TAG_ORIENTATION,
+                    ExifInterface.ORIENTATION_NORMAL
+                )
+                when (orientation) {
+                    ExifInterface.ORIENTATION_ROTATE_90 -> rotationAngle = 90
+                    ExifInterface.ORIENTATION_ROTATE_180 -> rotationAngle = 180
+                    ExifInterface.ORIENTATION_ROTATE_270 -> rotationAngle = 270
+                }
+            } catch (ignored: IOException) {
+            }
+            return rotationAngle
+        }
+
+
+        private fun calculateAngleFromFileDescriptor(fd: FileDescriptor): Int {
+            var rotationAngle = 0
+            val ei: ExifInterface
+            try {
+                ei = ExifInterface(fd)
+                val orientation = ei.getAttributeInt(
+                    ExifInterface.TAG_ORIENTATION,
+                    ExifInterface.ORIENTATION_NORMAL
+                )
+                when (orientation) {
+                    ExifInterface.ORIENTATION_ROTATE_90 -> rotationAngle = 90
+                    ExifInterface.ORIENTATION_ROTATE_180 -> rotationAngle = 180
+                    ExifInterface.ORIENTATION_ROTATE_270 -> rotationAngle = 270
+                }
+            } catch (ignored: IOException) {
+            }
+            return rotationAngle
+        }
+        fun getImageSize(context: Context, src: String): IntArray {
+            val bitmapOptions = BitmapFactory.Options()
+            bitmapOptions.inJustDecodeBounds = true
+            var pfd: ParcelFileDescriptor? = null
+            if (src.startsWith("content://")) {
+                val uri = Uri.parse(src)
+                val resolver: ContentResolver = context.getContentResolver()
+                pfd = try {
+                    resolver.openFileDescriptor(uri, "r")
+                } catch (e: FileNotFoundException) {
+                    closePfd(pfd)
+                    throw e;
+                }
+                BitmapFactory.decodeFileDescriptor(pfd!!.fileDescriptor, null, bitmapOptions)
+            } else {
+                BitmapFactory.decodeFile(src, bitmapOptions)
+            }
+            val rotationAngle: Int
+            if (pfd != null) {
+                rotationAngle = calculateAngleFromFileDescriptor(pfd.fileDescriptor)
+                closePfd(pfd)
+            } else {
+                rotationAngle = calculateAngleFromFile(src)
+            }
+            return intArrayOf(bitmapOptions.outWidth, bitmapOptions.outHeight, rotationAngle)
+        }
+
+        fun readBitmapFromFileSync(context: Context, src: String, options: LoadImageOptions?, sourceSize:Pair<Int, Int>?): Bitmap? {
+            //  val start = System.currentTimeMillis()
+            var sourceSize = sourceSize
+            if (sourceSize == null && options?.sourceWidth != 0 && options?.sourceHeight != 0) {
+                sourceSize = Pair(options!!.sourceWidth, options!!.sourceHeight)
+            }
+            var bitmap: Bitmap?
+            val bitmapOptions = BitmapFactory.Options()
+            var pfd: ParcelFileDescriptor? = null
+            if (src.startsWith("content://")) {
+                val uri = Uri.parse(src)
+                val resolver: ContentResolver = context.getContentResolver()
+                pfd = try {
+                    resolver.openFileDescriptor(uri, "r")
+                } catch (e: FileNotFoundException) {
+                    closePfd(pfd)
+                    throw e;
+                }
+            }
+            if (sourceSize == null) {
+                bitmapOptions.inJustDecodeBounds = true
+
+                if (pfd != null) {
+                    BitmapFactory.decodeFileDescriptor(pfd!!.fileDescriptor, null, bitmapOptions)
+                } else {
+                    BitmapFactory.decodeFile(src, bitmapOptions)
+                }
+                sourceSize = Pair(bitmapOptions.outWidth, bitmapOptions.outHeight)
+            }
+            val opts = ImageAssetOptions(sourceSize, options)
+
+            val (first, second) = getRequestedImageSize(sourceSize, opts)
+            val sampleSize: Int = calculateInSampleSize(
+                sourceSize.first, sourceSize.second,
+                first,
+                second
+            )
+            val finalBitmapOptions = BitmapFactory.Options()
+            finalBitmapOptions.inSampleSize = sampleSize
+            if (sampleSize != 1) {
+                finalBitmapOptions.inScaled = true;
+                finalBitmapOptions.inDensity = sourceSize.first;
+                finalBitmapOptions.inTargetDensity =  first * sampleSize;
+            } else {
+                finalBitmapOptions.inScaled = false;
+            }
+            // read as minimum bitmap as possible (slightly bigger than the requested size)
+            bitmap = if (pfd != null) {
+                BitmapFactory.decodeFileDescriptor(pfd.fileDescriptor, null, finalBitmapOptions)
+            } else {
+                BitmapFactory.decodeFile(src, finalBitmapOptions)
+            }
+            // Log.d("ImageAnalysis", "readBitmapFromFile in ${System.currentTimeMillis() - start} ms")
+            if (bitmap != null) {
+                val rotationAngle: Int
+                if (pfd != null) {
+                    rotationAngle = calculateAngleFromFileDescriptor(pfd.fileDescriptor)
+                    closePfd(pfd)
+                } else {
+                    rotationAngle = calculateAngleFromFile(src)
+                }
+//                if (first !== bitmap.getWidth() || second !== bitmap.getHeight()  || rotationAngle != 0) {
+//
+//                    val matrix = Matrix()
+//                    if (first !== bitmap.getWidth() || second !== bitmap.getHeight()) {
+//                        val scale = first.toFloat() / bitmap.width
+//                        matrix.postScale(scale, scale)
+//                    }
+//                    if (rotationAngle != 0) {
+//                        matrix.postRotate(rotationAngle.toFloat())
+//                    }
+//                    bitmap = Bitmap.createBitmap(
+//                        bitmap,
+//                        0,
+//                        0,
+//                        bitmap.getWidth(),
+//                        bitmap.getHeight(),
+//                        matrix,
+//                        false
+//                    )
+//                }
+
+                if (rotationAngle != 0) {
+                    val matrix = Matrix()
+                    matrix.postRotate(rotationAngle.toFloat())
+                    bitmap = Bitmap.createBitmap(
+                        bitmap,
+                        0,
+                        0,
+                        bitmap.getWidth(),
+                        bitmap.getHeight(),
+                        matrix,
+                        true
+                    )
+                }
+                // Log.d("ImageAnalysis", "readBitmapFromFile2 in ${System.currentTimeMillis() - start} ms")
+            }
+            return bitmap
+        }
+
+        fun readBitmapFromFileSync(context: Context, src: String, opts: String?): Bitmap? {
+            return readBitmapFromFileSync(context, src, LoadImageOptions(opts), null)
+        }
+        fun readBitmapFromFile(context: Context, src: String, callback: FunctionCallback, opts: String?) {
+            thread(start = true) {
+                try {
+                    callback.onResult(null, readBitmapFromFileSync(context, src, opts))
+                } catch (e: Exception) {
+                    callback.onResult(e, null)
+                }
+            }
+        }
+    }
+}

package/platforms/android/java/com/nativescript/apputils/Utils.kt

@@ -65,8 +65,11 @@ class Utils {
         val systemLocale: Locale?
             get() = ConfigurationCompat.getLocales(Resources.getSystem().configuration)[0]
 
-        fun prepareActivity(activity: AppCompatActivity) {
-            DynamicColors.applyToActivityIfAvailable(activity)
+        @JvmOverloads
+        fun prepareActivity(activity: AppCompatActivity, applyDynamicColors: Boolean = true) {
+            if (applyDynamicColors) {
+                DynamicColors.applyToActivityIfAvailable(activity)
+            }
             activity.installSplashScreen()
             prepareWindow(activity.window)
         }

package/platforms/ios/src/ImageUtils.swift

@@ -0,0 +1,222 @@
+import Foundation
+import UIKit
+
+extension UIImage.Orientation {
+    init(_ cgOrientation: CGImagePropertyOrientation) {
+        switch cgOrientation {
+            case .up: self = .up
+            case .upMirrored: self = .upMirrored
+            case .down: self = .down
+            case .downMirrored: self = .downMirrored
+            case .left: self = .left
+            case .leftMirrored: self = .leftMirrored
+            case .right: self = .right
+            case .rightMirrored: self = .rightMirrored
+        }
+    }
+}
+@objcMembers
+@objc(ImageUtils)
+class ImageUtils : NSObject {
+  
+  static func toJSON(_ str: String?) -> NSDictionary? {
+    guard let data = str?.data(using: .utf8, allowLossyConversion: false) else { return nil }
+    return try? (JSONSerialization.jsonObject(with: data, options: .mutableContainers) as! NSDictionary?)
+  }
+  class LoadImageOptions {
+    var width = 0.0
+    var maxWidth = 0.0
+    var height = 0.0
+    var maxHeight = 0.0
+    var keepAspectRatio = true
+    var autoScaleFactor = true
+    
+    func initWithJSONOptions(_ jsonOpts:NSDictionary?){
+      if let jsonOpts = jsonOpts {
+        if ((jsonOpts["resizeThreshold"]) != nil) {
+          maxWidth = jsonOpts["resizeThreshold"] as! Double
+          maxHeight = maxWidth
+        } else if ((jsonOpts["maxSize"]) != nil) {
+          maxWidth = jsonOpts["maxSize"] as! Double
+          maxHeight = maxWidth
+        }
+        if ((jsonOpts["width"]) != nil) {
+          width = jsonOpts["width"] as! Double
+        } else if ((jsonOpts["maxWidth"]) != nil) {
+          maxWidth = jsonOpts["maxWidth"] as! Double
+        }
+        if ((jsonOpts["height"]) != nil) {
+          height = jsonOpts["height"] as! Double
+        } else if ((jsonOpts["maxHeight"]) != nil) {
+          maxHeight = jsonOpts["maxHeight"] as! Double
+        }
+        if ((jsonOpts["keepAspectRatio"]) != nil) {
+          keepAspectRatio = jsonOpts["keepAspectRatio"] as! Bool
+        }
+        if ((jsonOpts["autoScaleFactor"]) != nil) {
+          autoScaleFactor = jsonOpts["autoScaleFactor"] as! Bool
+        }
+      }
+    }
+    
+    init(_ optionsStr:String?) {
+      initWithJSONOptions(toJSON(optionsStr))
+    }
+    init( jsonOpts:NSDictionary?) {
+      initWithJSONOptions(jsonOpts)
+    }
+  }
+  class ImageAssetOptions {
+    var width = 0.0
+    var height = 0.0
+    var keepAspectRatio = true
+    var autoScaleFactor = true
+    init (_ size: CGSize, options: LoadImageOptions?) {
+      width = size.width
+      height = size.height
+      if (options != nil) {
+        if (options!.width > 0) {
+          width = options!.width
+        }
+        if (options!.height > 0) {
+          height = options!.height
+        }
+        if (options!.maxWidth > 0) {
+          width = min(
+            width,
+            options!.maxWidth
+          )
+        }
+        if (options!.maxHeight > 0) {
+          height = min(
+            height,
+            options!.maxHeight
+          )
+        }
+        keepAspectRatio = options!.keepAspectRatio
+        autoScaleFactor = options!.autoScaleFactor
+      }
+    }
+  }
+  
+  static func getAspectSafeDimensions(
+    _ sourceWidth: Double,
+    _ sourceHeight: Double,
+    _ reqWidth: Double,
+    _ reqHeight: Double
+  ) -> CGSize {
+    let widthCoef = sourceWidth / reqWidth
+    let heightCoef = sourceHeight / reqHeight
+    let aspectCoef = max(widthCoef, heightCoef)
+    return CGSize(width: floor((sourceWidth / aspectCoef)), height: floor((sourceHeight / aspectCoef)))
+  }
+  static func getRequestedImageSize(_ size: CGSize, _ options: ImageAssetOptions) -> CGSize {
+    var reqWidth = options.width
+    if (reqWidth <= 0) {
+      reqWidth = size.width
+    }
+    var reqHeight = options.height
+    if (reqHeight <= 0) {
+      reqHeight = size.height
+    }
+    if (options.keepAspectRatio) {
+      let size2 = getAspectSafeDimensions(
+        size.width,
+        size.height,
+        reqWidth,
+        reqHeight
+      )
+      reqWidth = size2.width
+      reqHeight = size2.height
+    }
+    return CGSize(width: reqWidth, height: reqHeight)
+  }
+  
+  // this scales an image but also return the image "rotated"
+  // based on imageOrientation
+  static func scaleImage(_ image: UIImage, _ scaledImageSize: CGSize) -> UIImage? {
+    // Create a graphics context
+    UIGraphicsBeginImageContextWithOptions(scaledImageSize, false, image.scale)
+    // Draw the image in the new size
+    image.draw(in: CGRect(
+      origin: .zero,
+      size: scaledImageSize
+    ))
+    // Get the resized, scaled, and rotated image from the context
+    let resizedScaledRotatedImage = UIGraphicsGetImageFromCurrentImageContext()
+    
+    // End the graphics context
+    UIGraphicsEndImageContext()
+    
+    return resizedScaledRotatedImage
+  }
+  
+  static func getImageSize(_ src: String) -> Dictionary<String, Any>? {
+    let url = NSURL.fileURL(withPath: src)
+    let imageSource = CGImageSourceCreateWithURL(url as CFURL, nil);
+    if (imageSource == nil) {
+      // Error loading image
+      return nil;
+    }
+    
+    let options = [kCGImageSourceShouldCache:false];
+    let imageProperties = CGImageSourceCopyPropertiesAtIndex(imageSource!, 0, options as CFDictionary) as! [NSString: Any]? ;
+    var result: Dictionary<String, Any>?;
+    if (imageProperties != nil) {
+      let width = imageProperties![kCGImagePropertyPixelWidth] as! Double;
+      let height = imageProperties![kCGImagePropertyPixelHeight] as! Double;
+      let orientation = imageProperties![kCGImagePropertyOrientation] as! Int;
+      let uiOrientation = UIImage.Orientation.init(CGImagePropertyOrientation(rawValue: UInt32(orientation))!);
+      var degrees: Int = 0
+      switch uiOrientation {
+      case .down, .downMirrored:
+        degrees = 180
+        break
+      case .right, .rightMirrored:
+        degrees = -90
+        break
+      case .left, .leftMirrored:
+        degrees = 90
+        break
+      default:
+        degrees = 0
+      }
+      result = ["width": width, "height": height, "rotation":degrees];
+    }
+    return result;
+  }
+  
+  
+  static func readImageFromFileSync(_ src: String, options: NSDictionary?) -> UIImage? {
+    let image = UIImage(contentsOfFile: src)
+    if let image {
+      let size = image.size
+      let imageOrientation = image.imageOrientation
+      let loadImageOptions = LoadImageOptions(jsonOpts: options)
+      let opts = ImageAssetOptions(size, options: loadImageOptions)
+      let requestedSize = getRequestedImageSize(size, opts)
+      var result: UIImage? = image
+      if (requestedSize.width != size.width || requestedSize.height != size.height || imageOrientation != .up) {
+        result = scaleImage(image, requestedSize )
+      }
+      if (options?["jpegQuality"] != nil) {
+        result = UIImage.init(data: result!.jpegData(compressionQuality: CGFloat((options!["jpegQuality"] as! Int)) / 100.0)!)
+      }
+      
+      return result
+    }
+    return nil
+    
+  }
+  
+  static func readImageFromFileSync(_ src: String, _ stringOptions: String?) -> UIImage? {
+    let options = toJSON(stringOptions)
+    return readImageFromFileSync(src, options: options)
+  }
+  static func readImageFromFile(_ src: String, _ delegate: CompletionDelegate?, _ stringOptions: String?) -> UIImage? {
+     DispatchQueue.global(qos: .userInitiated).async {
+      let options = toJSON(stringOptions)
+      delegate?.onComplete(readImageFromFileSync(src, stringOptions) as NSObject, error: _error as NSError?)
+     }
+  }
+}

package/platforms/ios/src/NCompletionDelegate.swift

@@ -0,0 +1,8 @@
+import ObjectiveC
+import Foundation
+
+@objc(NCompletionDelegate)
+protocol NCompletionDelegate {
+  func onComplete(_ result: NSObject?, error:NSError?)
+  func onProgress(_ progress: Int)
+}