@nativescript-community/ui-image 4.6.6 → 5.0.0

package/index.android.js

@@ -1,179 +1,198 @@
-var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
+var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
 export * from './index-common';
-import { Application, ImageAsset, ImageSource, Trace, Utils, backgroundInternalProperty, knownFolders, path } from '@nativescript/core';
+import { ImageAsset, ImageSource, Trace, Utils, backgroundInternalProperty, knownFolders, path } from '@nativescript/core';
 import { isString } from '@nativescript/core/utils/types';
 import { layout } from '@nativescript/core/utils/layout-helper';
-import { CLog, CLogTypes, EventData, ImageBase, ScaleType, aspectRatioProperty, backgroundUriProperty, blurDownSamplingProperty, blurRadiusProperty, fadeDurationProperty, failureImageUriProperty, headersProperty, imageRotationProperty, lowerResSrcProperty, needRequestImage, noRatioEnforceProperty, placeholderImageUriProperty, progressBarColorProperty, roundAsCircleProperty, roundBottomLeftRadiusProperty, roundBottomRightRadiusProperty, roundTopLeftRadiusProperty, roundTopRightRadiusProperty, showProgressBarProperty, srcProperty, stretchProperty, tintColorProperty, wrapNativeException } from './index-common';
+import { CLog, CLogTypes, ImageBase, ScaleType, aspectRatioProperty, backgroundUriProperty, blurDownSamplingProperty, blurRadiusProperty, decodeHeightProperty, decodeWidthProperty, fadeDurationProperty, failureImageUriProperty, headersProperty, imageRotationProperty, lowerResSrcProperty, needRequestImage, noRatioEnforceProperty, placeholderImageUriProperty, roundAsCircleProperty, roundBottomLeftRadiusProperty, roundBottomRightRadiusProperty, roundTopLeftRadiusProperty, roundTopRightRadiusProperty, srcProperty, stretchProperty, tintColorProperty, wrapNativeException } from './index-common';
 let initialized = false;
-let initializeConfig;
+let glideInstance;
+// global signature to invalidate all cache if needed by plugin
+let signature;
+const globalSignatureKey = 'v1';
 export function initialize(config) {
     if (!initialized) {
         const context = Utils.android.getApplicationContext();
         if (!context) {
-            initializeConfig = config;
             return;
         }
-        let builder;
-        const useOkhttp = config?.useOkhttp !== false;
-        if (useOkhttp) {
-            //@ts-ignore
-            let client;
-            //@ts-ignore
-            if (useOkhttp instanceof okhttp3.OkHttpClient) {
-                client = useOkhttp;
-            }
-            else {
-                //@ts-ignore
-                client = new okhttp3.OkHttpClient();
-            }
-            builder = com.facebook.imagepipeline.backends.okhttp3.OkHttpImagePipelineConfigFactory.newBuilder(context, client);
-            builder.setNetworkFetcher(new com.nativescript.image.OkHttpNetworkFetcher(client));
-        }
-        else {
-            builder = com.facebook.imagepipeline.core.ImagePipelineConfig.newBuilder(context);
+        if (config?.usePersistentCacheKeyStore) {
+            const sharedStore = new com.nativescript.image.SharedPrefCacheKeyStore(context.getApplicationContext());
+            com.nativescript.image.EvictionManager.get().setPersistentStore(sharedStore);
         }
-        builder.setDownsampleEnabled(config?.isDownsampleEnabled === true);
-        if (config?.leakTracker) {
-            builder.setCloseableReferenceLeakTracker(config.leakTracker);
-        }
-        // builder.experiment().setNativeCodeDisabled(true);
-        const imagePipelineConfig = builder.build();
-        com.facebook.drawee.backends.pipeline.Fresco.initialize(context, imagePipelineConfig);
+        // bumping `v1` will invalidate all cache
+        signature = new com.bumptech.glide.signature.ObjectKey(config?.globalSignatureKey ?? globalSignatureKey);
         initialized = true;
-        initializeConfig = null;
-    }
-}
-let imagePineLine;
-export function getImagePipeline() {
-    if (!imagePineLine) {
-        if (Application.android.nativeApp) {
-            const nativePipe = com.facebook.drawee.backends.pipeline.Fresco.getImagePipeline();
-            imagePineLine = new ImagePipeline();
-            imagePineLine.android = nativePipe;
-        }
-    }
-    return imagePineLine;
-}
-export function shutDown() {
-    if (!initialized) {
-        return;
-    }
-    initialized = false;
-    com.facebook.drawee.view.SimpleDraweeView.shutDown();
-    com.facebook.drawee.backends.pipeline.Fresco.shutDown();
-}
-function getUri(src, asNative = true) {
-    let uri;
-    let imagePath;
-    if (src instanceof ImageAsset) {
-        imagePath = src.android;
-    }
-    else {
-        imagePath = src;
-    }
-    if (Utils.isFileOrResourcePath(imagePath)) {
-        if (imagePath.indexOf(Utils.RESOURCE_PREFIX) === 0) {
-            const resName = imagePath.substring(Utils.RESOURCE_PREFIX.length);
-            const identifier = Utils.android.resources.getDrawableId(resName);
-            if (0 < identifier) {
-                const netUri = new android.net.Uri.Builder().scheme(com.facebook.common.util.UriUtil.LOCAL_RESOURCE_SCHEME).path(java.lang.String.valueOf(identifier)).build();
-                if (asNative) {
-                    return netUri;
-                }
-                uri = netUri.toString();
-            }
-        }
-        else if (imagePath.indexOf('~/') === 0) {
-            uri = `file:${path.join(knownFolders.currentApp().path, imagePath.replace('~/', ''))}`;
-        }
-        else if (imagePath.indexOf('/') === 0) {
-            uri = `file:${imagePath}`;
-        }
+        glideInstance = com.bumptech.glide.Glide.get(context);
+        com.nativescript.image.EvictionManager.get().clearAll();
+        // this is needed for further buildKey to trigger ...
+        com.bumptech.glide.Glide.with(context)
+            .load('toto?ts=' + Date().valueOf())
+            .apply(new com.bumptech.glide.request.RequestOptions().signature(new com.bumptech.glide.signature.ObjectKey(Date().valueOf())))
+            .preload();
+        // com.nativescript.image.EngineKeyFactoryMethodDumper.dumpKeyFactoryMethods(glideInstance);
+        // com.nativescript.image.ForcePreloadTest.forcePreloadAfterInjection(context, 'https://example.com/test-image.png');
     }
-    else {
-        uri = imagePath;
-    }
-    return asNative ? android.net.Uri.parse(uri) : uri;
-}
-function isVectorDrawable(context, resId) {
-    const resources = context.getResources();
-    // VectorDrawable resources are usually stored as "drawable" in XML format
-    const value = new android.util.TypedValue();
-    resources.getValue(resId, value, true);
-    if (value.string.toString().endsWith('.xml')) {
-        // It's most likely a VectorDrawable
-        return true;
-    }
-    // If it's not a vector, it's probably a BitmapDrawable or another type
-    return false;
-}
-function getBitmapFromVectorDrawable(context, drawableId) {
-    const drawable = Utils.android.getApplicationContext().getDrawable(drawableId);
-    const bitmap = android.graphics.Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), android.graphics.Bitmap.Config.ARGB_8888);
-    const canvas = new android.graphics.Canvas(bitmap);
-    drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
-    drawable.draw(canvas);
-    console.log('getBitmapFromVectorDrawable', bitmap, bitmap.getWidth(), bitmap.getHeight);
-    return new android.graphics.drawable.BitmapDrawable(context.getResources(), bitmap);
 }
 export class ImagePipeline {
     toUri(value) {
         if (value instanceof android.net.Uri) {
-            return value;
+            return value.toString();
         }
-        return android.net.Uri.parse(value);
+        return value;
     }
     getCacheKey(uri, context) {
-        // iOS only
         return uri;
     }
     isInDiskCache(uri) {
-        return this._android.isInDiskCacheSync(this.toUri(uri));
+        const url = this.toUri(uri);
+        return new Promise((resolve, reject) => {
+            com.nativescript.image.EvictionManager.get().isInDiskCacheAsync(url, new com.nativescript.image.EvictionManager.DiskPresenceCallback({
+                onResult(source, transform) {
+                    resolve(source || transform);
+                }
+            }));
+        });
     }
     isInBitmapMemoryCache(uri) {
-        return this._android.isInBitmapMemoryCache(this.toUri(uri));
+        // Still not directly accessible, but we can check if it's registered
+        const url = this.toUri(uri);
+        return com.nativescript.image.EvictionManager.get().isInMemoryCache(url);
     }
     evictFromMemoryCache(uri) {
-        this._android.evictFromMemoryCache(this.toUri(uri));
+        const url = this.toUri(uri);
+        return new Promise((resolve, reject) => {
+            com.nativescript.image.EvictionManager.get().evictMemoryForId(url, new com.nativescript.image.EvictionManager.EvictionCallback({
+                onComplete(success, error) {
+                    if (success) {
+                        resolve();
+                    }
+                    else {
+                        if (Trace.isEnabled()) {
+                            CLog(CLogTypes.error, error);
+                        }
+                        reject(error);
+                    }
+                }
+            }));
+        });
     }
-    async evictFromDiskCache(uri) {
-        this._android.evictFromDiskCache(this.toUri(uri));
+    evictFromDiskCache(uri) {
+        const url = this.toUri(uri);
+        return new Promise((resolve, reject) => {
+            com.nativescript.image.EvictionManager.get().evictDiskForId(url, new com.nativescript.image.EvictionManager.EvictionCallback({
+                onComplete(success, error) {
+                    if (success) {
+                        resolve();
+                    }
+                    else {
+                        if (Trace.isEnabled()) {
+                            CLog(CLogTypes.error, error);
+                        }
+                        reject(error);
+                    }
+                }
+            }));
+        });
     }
-    async evictFromCache(uri) {
-        this._android.evictFromCache(this.toUri(uri));
+    evictFromCache(uri) {
+        const url = this.toUri(uri);
+        return new Promise((resolve, reject) => {
+            com.nativescript.image.EvictionManager.get().evictAllForId(url, new com.nativescript.image.EvictionManager.EvictionCallback({
+                onComplete(success, error) {
+                    if (success) {
+                        resolve();
+                    }
+                    else {
+                        if (Trace.isEnabled()) {
+                            CLog(CLogTypes.error, error);
+                        }
+                        reject(error);
+                    }
+                }
+            }));
+        });
     }
     clearCaches() {
-        this._android.clearCaches();
+        return new Promise((resolve, reject) => {
+            com.nativescript.image.EvictionManager.get().clearAll(new com.nativescript.image.EvictionManager.EvictionCallback({
+                onComplete(success, error) {
+                    if (success) {
+                        resolve();
+                    }
+                    else {
+                        if (Trace.isEnabled()) {
+                            CLog(CLogTypes.error, error);
+                        }
+                        reject(error);
+                    }
+                }
+            }));
+        });
     }
     clearMemoryCaches() {
-        this._android.clearMemoryCaches();
+        return new Promise((resolve, reject) => {
+            com.nativescript.image.EvictionManager.get().clearMemory(new com.nativescript.image.EvictionManager.EvictionCallback({
+                onComplete(success, error) {
+                    if (success) {
+                        resolve();
+                    }
+                    else {
+                        if (Trace.isEnabled()) {
+                            CLog(CLogTypes.error, error);
+                        }
+                        reject(error);
+                    }
+                }
+            }));
+        });
     }
     clearDiskCaches() {
-        this._android.clearDiskCaches();
+        return new Promise((resolve, reject) => {
+            com.nativescript.image.EvictionManager.get().clearDiskCache(new com.nativescript.image.EvictionManager.EvictionCallback({
+                onComplete(success, error) {
+                    if (success) {
+                        resolve();
+                    }
+                    else {
+                        if (Trace.isEnabled()) {
+                            CLog(CLogTypes.error, error);
+                        }
+                        reject(error);
+                    }
+                }
+            }));
+        });
     }
     prefetchToDiskCache(uri) {
         return this.prefetchToCache(uri, true);
     }
     prefetchToMemoryCache(uri) {
-        return this.prefetchToCache(uri, false);
+        return new Promise((resolve, reject) => {
+            try {
+                const context = Utils.android.getApplicationContext();
+                const requestManager = com.bumptech.glide.Glide.with(context);
+                // Preload into memory cache
+                requestManager.asBitmap().load(uri).preload();
+                // Give Glide time to load into memory
+                setTimeout(() => resolve(), 100);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
     }
     prefetchToCache(uri, toDiskCache) {
         return new Promise((resolve, reject) => {
             try {
-                const nativeUri = android.net.Uri.parse(uri);
-                const request = com.facebook.imagepipeline.request.ImageRequestBuilder.newBuilderWithSource(nativeUri).build();
-                let datasource;
+                const context = Utils.android.getApplicationContext();
+                const requestManager = com.bumptech.glide.Glide.with(context);
                 if (toDiskCache) {
-                    datasource = this._android.prefetchToDiskCache(request, uri);
+                    requestManager.downloadOnly().load(uri).submit();
                 }
                 else {
-                    datasource = this._android.prefetchToBitmapCache(request, uri);
+                    requestManager.asBitmap().load(uri).submit();
                 }
-                // initializeBaseDataSubscriber();
-                datasource.subscribe(new com.nativescript.image.BaseDataSubscriber(new com.nativescript.image.BaseDataSubscriberListener({
-                    onFailure: reject,
-                    onNewResult: resolve
-                })), com.facebook.common.executors.CallerThreadExecutor.getInstance());
+                resolve();
             }
             catch (error) {
                 reject(error);
@@ -181,49 +200,55 @@ export class ImagePipeline {
         });
     }
     get android() {
-        return this._android;
-    }
-    set android(value) {
-        this._android = value;
-    }
-    fetchImage() {
-        //         ImagePipeline imagePipeline = Fresco.getImagePipeline();
-        // ImageRequest imageRequest = ImageRequestBuilder
-        //        .newBuilderWithSource(imageUri)
-        //        .setRequestPriority(Priority.HIGH)
-        //        .setLowestPermittedRequestLevel(ImageRequest.RequestLevel.FULL_FETCH)
-        //        .build();
-        // DataSource<CloseableReference<CloseableImage>> dataSource =
-        //        imagePipeline.fetchDecodedImage(imageRequest, mContext);
-        // try {
-        //    dataSource.subscribe(new BaseBitmapDataSubscriber() {
-        //        @Override
-        //        public void onNewResultImpl(Bitmap bitmap) {
-        //            if (bitmap == null) {
-        //                Log.d(TAG, "Bitmap data source returned success, but bitmap null.");
-        //                return;
-        //            }
-        //            // The bitmap provided to this method is only guaranteed to be around
-        //            // for the lifespan of this method. The image pipeline frees the
-        //            // bitmap's memory after this method has completed.
-        //            //
-        //            // This is fine when passing the bitmap to a system process as
-        //            // Android automatically creates a copy.
-        //            //
-        //            // If you need to keep the bitmap around, look into using a
-        //            // BaseDataSubscriber instead of a BaseBitmapDataSubscriber.
-        //        }
-        //        @Override
-        //        public void onFailureImpl(DataSource dataSource) {
-        //            // No cleanup required here
-        //        }
-        //    }, CallerThreadExecutor.getInstance());
-        // } finally {
-        //    if (dataSource != null) {
-        //        dataSource.close();
-        //    }
-        // }
+        return glideInstance;
+    }
+}
+let imagePipeLine;
+export function getImagePipeline() {
+    if (!imagePipeLine) {
+        imagePipeLine = new ImagePipeline();
+    }
+    return imagePipeLine;
+}
+export function shutDown() {
+    if (!initialized) {
+        return;
+    }
+    initialized = false;
+    // Glide cleanup
+    const context = Utils.android.getApplicationContext();
+    if (context) {
+        com.bumptech.glide.Glide.get(context).clearMemory();
+    }
+}
+function getUri(src, asNative = true) {
+    let uri;
+    let imagePath;
+    if (src instanceof ImageAsset) {
+        imagePath = src.android;
+    }
+    else {
+        imagePath = src;
+    }
+    if (Utils.isFileOrResourcePath(imagePath)) {
+        if (imagePath.indexOf(Utils.RESOURCE_PREFIX) === 0) {
+            const resName = imagePath.substring(Utils.RESOURCE_PREFIX.length);
+            const identifier = Utils.android.resources.getDrawableId(resName);
+            if (0 < identifier) {
+                return `android.resource://${Utils.android.getApplicationContext().getPackageName()}/${identifier}`;
+            }
+        }
+        else if (imagePath.indexOf('~/') === 0) {
+            uri = `file://${path.join(knownFolders.currentApp().path, imagePath.replace('~/', ''))}`;
+        }
+        else if (imagePath.indexOf('/') === 0) {
+            uri = `file://${imagePath}`;
+        }
     }
+    else {
+        uri = imagePath;
+    }
+    return uri;
 }
 export class ImageError {
     constructor(throwable) {
@@ -242,42 +267,22 @@ export class ImageError {
     }
 }
 export class ImageInfo {
-    constructor(imageInfo) {
-        this._nativeImageInfo = imageInfo;
+    constructor(width, height) {
+        this._width = width;
+        this._height = height;
     }
     getHeight() {
-        return this._nativeImageInfo.getHeight();
+        return this._height;
     }
     getWidth() {
-        return this._nativeImageInfo.getWidth();
+        return this._width;
     }
     getQualityInfo() {
-        return this._nativeImageInfo.getQualityInfo();
-    }
-}
-export class FinalEventData extends EventData {
-    get imageInfo() {
-        return this._imageInfo;
-    }
-    set imageInfo(value) {
-        this._imageInfo = value;
-    }
-    get animatable() {
-        return this._animatable;
-    }
-    set animatable(value) {
-        this._animatable = value;
-    }
-    get android() {
-        return this._animatable;
-    }
-}
-export class IntermediateEventData extends EventData {
-    get imageInfo() {
-        return this._imageInfo;
-    }
-    set imageInfo(value) {
-        this._imageInfo = value;
+        return {
+            getQuality: () => 1,
+            isOfFullQuality: () => true,
+            isOfGoodEnoughQuality: () => true
+        };
     }
 }
 export const needUpdateHierarchy = function (targetOrNeedsLayout, propertyKey, descriptor) {
@@ -313,13 +318,15 @@ export const needUpdateHierarchy = function (targetOrNeedsLayout, propertyKey, d
 export class Img extends ImageBase {
     constructor() {
         super(...arguments);
-        this.isLoading = false;
         this.mCanUpdateHierarchy = true;
         this.mNeedUpdateHierarchy = false;
         this.mNeedUpdateLayout = false;
+        this.currentTarget = null;
+        this.isNetworkRequest = false;
+        this.progressCallback = null;
+        this.loadSourceCallback = null;
     }
     onResumeNativeUpdates() {
-        // {N} suspends properties update on `_suspendNativeUpdates`. So we only need to do this in onResumeNativeUpdates
         this.mCanUpdateHierarchy = false;
         super.onResumeNativeUpdates();
         this.mCanUpdateHierarchy = true;
@@ -334,40 +341,13 @@ export class Img extends ImageBase {
     }
     createNativeView() {
         if (!initialized) {
-            initialize(initializeConfig);
+            initialize();
         }
-        const view = new com.nativescript.image.DraweeView(this._context);
-        // (view as any).setClipToBounds(false);
-        return view;
+        return new com.nativescript.image.MatrixImageView(this._context);
     }
-    updateViewSize(imageInfo) {
-        const draweeView = this.nativeImageViewProtected;
-        if (!draweeView) {
-            return;
-        }
-        if (imageInfo != null) {
-            draweeView.imageWidth = imageInfo.getWidth();
-            draweeView.imageHeight = imageInfo.getHeight();
-        }
-        if (!this.aspectRatio && imageInfo != null) {
-            const ratio = imageInfo.getWidth() / imageInfo.getHeight();
-            draweeView.setAspectRatio(ratio);
-        }
-        else if (this.aspectRatio) {
-            draweeView.setAspectRatio(this.aspectRatio);
-        }
-        else {
-            draweeView.setAspectRatio(0);
-        }
-    }
-    // public initNativeView(): void {
-    //     this.initDrawee();
-    //     this.updateHierarchy();
-    // }
     disposeNativeView() {
-        this.controllerListener = null;
-        this.requestListener = null;
-        // this.nativeImageViewProtected.setImageURI(null, null);
+        this.progressCallback = null;
+        this.loadSourceCallback = null;
     }
     get cacheKey() {
         const src = this.src;
@@ -381,10 +361,7 @@ export class Img extends ImageBase {
         const imagePipeLine = getImagePipeline();
         const cacheKey = this.cacheKey;
         if (cacheKey) {
-            // const isInCache = imagePipeLine.isInBitmapMemoryCache(uri);
-            // // if (isInCache) {
             await imagePipeLine.evictFromCache(cacheKey);
-            // }
         }
         this.handleImageSrc(null);
         this.initImage();
@@ -395,437 +372,468 @@ export class Img extends ImageBase {
     [_b = failureImageUriProperty.setNative]() {
         this.updateHierarchy();
     }
-    [_c = stretchProperty.setNative]() {
-        this.updateHierarchy();
+    [stretchProperty.setNative]() {
+        // Scale type
+        if (this.stretch) {
+            const scaleType = getScaleType(this.stretch);
+            if (scaleType) {
+                this.nativeViewProtected.setScaleType(scaleType);
+            }
+        }
     }
-    [_d = fadeDurationProperty.setNative]() {
+    [_c = fadeDurationProperty.setNative]() {
         this.updateHierarchy();
     }
-    [_e = backgroundUriProperty.setNative]() {
+    [_d = backgroundUriProperty.setNative]() {
         this.updateHierarchy();
     }
-    [_f = showProgressBarProperty.setNative]() {
+    [_e = roundAsCircleProperty.setNative](value) {
         this.updateHierarchy();
     }
-    [_g = progressBarColorProperty.setNative]() {
+    [_f = roundTopLeftRadiusProperty.setNative]() {
         this.updateHierarchy();
     }
-    [_h = roundAsCircleProperty.setNative]() {
-        this.updateHierarchy();
+    [imageRotationProperty.setNative](value) {
+        this.nativeImageViewProtected?.setImageRotation(value);
     }
-    [_j = roundTopLeftRadiusProperty.setNative]() {
+    [_g = roundTopRightRadiusProperty.setNative]() {
         this.updateHierarchy();
     }
-    [_k = imageRotationProperty.setNative](value) {
-        const scaleType = this.nativeImageViewProtected.getHierarchy().getActualImageScaleType();
-        scaleType['setImageRotation']?.(value);
-        this.nativeImageViewProtected.invalidate();
-    }
-    [_l = roundTopRightRadiusProperty.setNative]() {
+    [_h = roundBottomLeftRadiusProperty.setNative]() {
         this.updateHierarchy();
     }
-    [_m = roundBottomLeftRadiusProperty.setNative]() {
+    [_j = roundBottomRightRadiusProperty.setNative]() {
         this.updateHierarchy();
     }
-    [_o = roundBottomRightRadiusProperty.setNative]() {
-        this.updateHierarchy();
+    [tintColorProperty.setNative](value) {
+        if (this.nativeImageViewProtected) {
+            this.nativeImageViewProtected.setColorFilter(value?.android ?? -1, android.graphics.PorterDuff.Mode.MULTIPLY);
+        }
     }
-    [_p = tintColorProperty.setNative](value) {
-        this.updateHierarchy();
+    [_k = blurRadiusProperty.setNative](value) {
+        this.initImage();
     }
-    [_q = blurRadiusProperty.setNative]() {
+    [_l = srcProperty.setNative]() {
         this.initImage();
     }
-    [_r = srcProperty.setNative]() {
+    [_m = decodeWidthProperty.setNative]() {
         this.initImage();
     }
-    [_s = lowerResSrcProperty.setNative]() {
+    [_o = decodeHeightProperty.setNative]() {
         this.initImage();
     }
-    [_t = blurDownSamplingProperty.setNative]() {
+    [_p = lowerResSrcProperty.setNative]() {
         this.initImage();
     }
-    [_u = aspectRatioProperty.setNative]() {
+    [_q = blurDownSamplingProperty.setNative]() {
         this.initImage();
     }
-    [_v = headersProperty.setNative](value) {
+    [_r = aspectRatioProperty.setNative](value) {
+        if (this.nativeViewProtected) {
+            this.nativeViewProtected.setAspectRatio(value || 0);
+        }
+    }
+    [_s = headersProperty.setNative](value) {
         this.initImage();
     }
     [backgroundInternalProperty.setNative](value) {
         super[backgroundInternalProperty.setNative](value);
-        this.nativeViewProtected.setClipToOutline(value?.hasBorderRadius());
+        if (this.nativeViewProtected) {
+            this.nativeViewProtected.setClipToOutline(value?.hasBorderRadius());
+        }
     }
     [noRatioEnforceProperty.setNative](value) {
-        this.nativeViewProtected.noRatioEnforce = value;
+        if (this.nativeViewProtected) {
+            this.nativeViewProtected.setNoRatioEnforce(value);
+        }
     }
-    async handleImageSrc(src) {
+    loadImageWithGlide(uri) {
         const view = this.nativeViewProtected;
-        if (view) {
-            if (src instanceof Promise) {
-                this.handleImageSrc(await src);
-                return;
-            }
-            else if (typeof src === 'function') {
-                const newSrc = src();
-                if (newSrc instanceof Promise) {
-                    await newSrc;
-                }
-                this.handleImageSrc(newSrc);
-                return;
-            }
-            if (src) {
-                let drawable;
-                if (typeof src === 'string') {
-                    // disabled for now: loading vector drawables
-                    // if (src.indexOf(Utils.RESOURCE_PREFIX) === 0) {
-                    //     const identifier = Utils.android.resources.getDrawableId(src.substring(Utils.RESOURCE_PREFIX.length));
-                    //     if (identifier >= 0 && isVectorDrawable(this._context, identifier)) {
-                    //         drawable = getBitmapFromVectorDrawable(this._context, identifier);
-                    //     }
-                    // } else
-                    if (Utils.isFontIconURI(src)) {
-                        const fontIconCode = src.split('//')[1];
-                        if (fontIconCode !== undefined) {
-                            // support sync mode only
-                            const font = this.style.fontInternal;
-                            const color = this.style.color;
-                            drawable = new android.graphics.drawable.BitmapDrawable(Utils.android.getApplicationContext().getResources(), ImageSource.fromFontIconCodeSync(fontIconCode, font, color).android);
-                        }
+        const context = this._context;
+        // Determine if this is a network request
+        this.isNetworkRequest = typeof uri === 'string' && (uri.startsWith('http://') || uri.startsWith('https://'));
+        let requestBuilder;
+        let loadModel = uri;
+        // Create callbacks separately based on what's needed
+        const needsProgress = this.isNetworkRequest && this.hasListeners(ImageBase.progressEvent);
+        const needsLoadSource = this.isNetworkRequest && this.hasListeners('loadSource');
+        // Create progress callback if needed (only for network requests with listener)
+        if (needsProgress) {
+            const owner = new WeakRef(this);
+            this.progressCallback = new com.nativescript.image.ImageProgressCallback({
+                onProgress(url, bytesRead, totalBytes) {
+                    const instance = owner.get();
+                    if (instance) {
+                        const progress = totalBytes > 0 ? bytesRead / totalBytes : 0;
+                        instance.notifyProgress({
+                            loaded: bytesRead,
+                            total: totalBytes,
+                            progress,
+                            finished: bytesRead >= totalBytes
+                        });
                     }
                 }
-                else if (src instanceof ImageSource) {
-                    drawable = new android.graphics.drawable.BitmapDrawable(Utils.android.getApplicationContext().getResources(), src.android);
-                    this.updateViewSize(src.android);
-                }
-                if (drawable) {
-                    const hierarchy = this.nativeImageViewProtected.getHierarchy();
-                    hierarchy.setImage(drawable, 1, hierarchy.getFadeDuration() === 0);
-                    return;
-                }
-                const uri = getUri(src);
-                if (!uri) {
-                    console.error(`Error: 'src' not valid: ${src}`);
-                    return;
+            });
+        }
+        // Create load source callback if needed (separate from progress)
+        if (needsLoadSource) {
+            const owner = new WeakRef(this);
+            this.loadSourceCallback = new com.nativescript.image.ImageLoadSourceCallback({
+                onLoadStarted(url, source) {
+                    const instance = owner.get();
+                    if (instance) {
+                        instance.notifyLoadSource(source);
+                    }
                 }
-                if (this.noCache) {
-                    // testing if is in cache is slow so lets remove without testing
-                    // const imagePipeLine = getImagePipeline();
-                    // const isInCache = imagePipeLine.isInBitmapMemoryCache(uri) || imagePipeLine.isInDiskCache(uri);
-                    // if (isInCache) {
-                    getImagePipeline().evictFromCache(uri);
-                    // }
+            });
+        }
+        // Use CustomGlideUrl if we need headers, progress, or load source
+        if (this.isNetworkRequest && (this.headers || this.progressCallback || this.loadSourceCallback)) {
+            const headersMap = new java.util.HashMap();
+            if (this.headers) {
+                for (const key in this.headers) {
+                    headersMap.put(key, this.headers[key]);
                 }
-                this.isLoading = true;
-                if (!this.controllerListener) {
-                    const that = new WeakRef(this);
-                    this.controllerListener = new com.facebook.drawee.controller.ControllerListener({
-                        onFinalImageSet(id, imageInfo, animatable) {
-                            if (Trace.isEnabled()) {
-                                CLog(CLogTypes.info, 'onFinalImageSet', id, imageInfo, animatable);
-                            }
-                            const owner = that?.get();
-                            if (owner) {
-                                owner.updateViewSize(imageInfo);
-                                owner.isLoading = false;
-                                const eventName = ImageBase.finalImageSetEvent;
-                                if (owner.hasListeners(eventName)) {
-                                    const info = new ImageInfo(imageInfo);
-                                    owner.notify({
-                                        eventName,
-                                        imageInfo: info,
-                                        animatable: animatable
-                                    });
-                                }
-                            }
-                        },
-                        onFailure(id, throwable) {
-                            if (Trace.isEnabled()) {
-                                CLog(CLogTypes.info, 'onFailure', id, throwable.getLocalizedMessage());
-                            }
-                            const owner = that?.get();
-                            if (owner) {
-                                // const nView = nativeView.nativeViewProtected;
-                                owner.isLoading = false;
-                                const eventName = ImageBase.failureEvent;
-                                if (owner.hasListeners(eventName)) {
-                                    const imageError = new ImageError(throwable);
-                                    owner.notify({
-                                        eventName,
-                                        error: wrapNativeException(throwable)
-                                    });
-                                }
-                            }
-                        },
-                        onIntermediateImageFailed(id, throwable) {
-                            if (Trace.isEnabled()) {
-                                CLog(CLogTypes.info, 'onIntermediateImageFailed', id, throwable);
-                            }
-                            const owner = that?.get();
-                            if (owner) {
-                                const eventName = ImageBase.intermediateImageFailedEvent;
-                                if (owner.hasListeners(eventName)) {
-                                    owner.notify({
-                                        eventName,
-                                        error: wrapNativeException(throwable)
-                                    });
-                                }
-                            }
-                        },
-                        onIntermediateImageSet(id, imageInfo) {
-                            if (Trace.isEnabled()) {
-                                CLog(CLogTypes.info, 'onIntermediateImageSet', id, imageInfo);
-                            }
-                            const owner = that?.get();
-                            if (owner) {
-                                owner.updateViewSize(imageInfo);
-                                const eventName = ImageBase.intermediateImageSetEvent;
-                                if (owner.hasListeners(eventName)) {
-                                    const info = new ImageInfo(imageInfo);
-                                    owner.notify({
-                                        eventName,
-                                        imageInfo: info
-                                    });
-                                }
-                            }
-                        },
-                        onRelease(id) {
-                            if (Trace.isEnabled()) {
-                                CLog(CLogTypes.info, 'onRelease', id);
-                            }
-                            const owner = that?.get();
-                            if (owner) {
-                                const eventName = ImageBase.releaseEvent;
-                                if (owner.hasListeners(eventName)) {
-                                    owner.notify({
-                                        eventName
-                                    });
-                                }
-                            }
-                        },
-                        onSubmit(id, callerContext) {
-                            if (Trace.isEnabled()) {
-                                CLog(CLogTypes.info, 'onSubmit', id, callerContext);
-                            }
-                            const owner = that?.get();
-                            const eventName = ImageBase.submitEvent;
-                            if (owner?.hasListeners(eventName)) {
-                                owner.notify({
-                                    eventName
-                                });
-                            }
-                        }
-                    });
+            }
+            loadModel = new com.nativescript.image.CustomGlideUrl(uri, headersMap, this.progressCallback, // Can be null
+            this.loadSourceCallback // Can be null
+            );
+        }
+        requestBuilder = com.bumptech.glide.Glide.with(context).load(loadModel).signature(new com.bumptech.glide.signature.ObjectKey(Date().valueOf()));
+        // Apply transformations (blur, rounded corners, etc.)
+        const transformations = [];
+        if (this.blurRadius) {
+            transformations.push(new jp.wasabeef.glide.transformations.BlurTransformation(Math.round(this.blurRadius), this.blurDownSampling || 1));
+        }
+        if (this.roundAsCircle) {
+            transformations.push(new jp.wasabeef.glide.transformations.CropCircleTransformation());
+        }
+        else {
+            const topLeft = Utils.layout.toDevicePixels(this.roundTopLeftRadius || 0);
+            const topRight = Utils.layout.toDevicePixels(this.roundTopRightRadius || 0);
+            const bottomRight = Utils.layout.toDevicePixels(this.roundBottomRightRadius || 0);
+            const bottomLeft = Utils.layout.toDevicePixels(this.roundBottomLeftRadius || 0);
+            if (topLeft || topRight || bottomRight || bottomLeft) {
+                const radius = Math.max(topLeft, topRight, bottomRight, bottomLeft);
+                transformations.push(new jp.wasabeef.glide.transformations.RoundedCornersTransformation(Math.round(radius), 0, jp.wasabeef.glide.transformations.RoundedCornersTransformation.CornerType.ALL));
+            }
+        }
+        // Tint color
+        if (this.tintColor) {
+            transformations.push(new jp.wasabeef.glide.transformations.ColorFilterTransformation(this.tintColor.android));
+        }
+        let multiTransform;
+        if (transformations.length > 0) {
+            multiTransform = new com.bumptech.glide.load.MultiTransformation(java.util.Arrays.asList(transformations));
+            requestBuilder = requestBuilder.transform(multiTransform);
+        }
+        // Placeholder
+        if (this.placeholderImageUri) {
+            const placeholder = this.getDrawable(this.placeholderImageUri);
+            if (placeholder) {
+                requestBuilder = requestBuilder.placeholder(placeholder);
+            }
+        }
+        // Error image
+        if (this.failureImageUri) {
+            const error = this.getDrawable(this.failureImageUri);
+            if (error) {
+                requestBuilder = requestBuilder.error(error);
+            }
+        }
+        // Thumbnail
+        if (this.lowerResSrc) {
+            const lowerResUri = getUri(this.lowerResSrc);
+            if (lowerResUri) {
+                const thumbnailRequest = com.bumptech.glide.Glide.with(context).load(lowerResUri);
+                requestBuilder = requestBuilder.thumbnail(thumbnailRequest);
+            }
+        }
+        // Fade duration + conditional crossfade
+        if (this.fadeDuration > 0) {
+            const factory = new com.nativescript.image.ConditionalCrossFadeFactory(this.fadeDuration, !this.alwaysFade);
+            requestBuilder = requestBuilder.transition(com.bumptech.glide.load.resource.drawable.DrawableTransitionOptions.withCrossFade(factory));
+        }
+        // Cache settings
+        if (this.noCache) {
+            requestBuilder = requestBuilder.skipMemoryCache(true).diskCacheStrategy(com.bumptech.glide.load.engine.DiskCacheStrategy.NONE);
+        }
+        // Decode size
+        if (this.decodeWidth || this.decodeHeight) {
+            const Target = com.bumptech.glide.request.target.Target;
+            const width = this.decodeWidth || Target.SIZE_ORIGINAL;
+            const height = this.decodeHeight || Target.SIZE_ORIGINAL;
+            if (width === Target.SIZE_ORIGINAL) {
+                requestBuilder = requestBuilder.override(height);
+            }
+            else if (height === Target.SIZE_ORIGINAL) {
+                requestBuilder = requestBuilder.override(width);
+            }
+            else {
+                requestBuilder = requestBuilder.override(width, height);
+            }
+        }
+        const owner = new WeakRef(this);
+        const sourceKey = new com.bumptech.glide.signature.ObjectKey(uri);
+        const objectArr = Array.create(com.bumptech.glide.request.RequestListener, 2);
+        const ro = new com.bumptech.glide.request.RequestOptions().signature(signature);
+        objectArr[0] = new com.nativescript.image.SaveKeysRequestListener(uri, uri, sourceKey, signature, this.decodeWidth || com.bumptech.glide.request.target.Target.SIZE_ORIGINAL, this.decodeHeight || com.bumptech.glide.request.target.Target.SIZE_ORIGINAL, multiTransform, ro, null);
+        objectArr[1] = new com.bumptech.glide.request.RequestListener({
+            onLoadFailed(e, model, target, isFirstResource) {
+                const instance = owner.get();
+                if (instance) {
+                    instance.progressCallback = null; // Clean up
+                    instance.loadSourceCallback = null;
+                    instance.notifyFailure(e);
                 }
-                if (!this.requestListener && this.hasListeners(ImageBase.fetchingFromEvent)) {
-                    const that = new WeakRef(this);
-                    this.requestListener = new com.facebook.imagepipeline.listener.RequestListener({
-                        onRequestStart(request, callerContext, requestId, isPrefetch) {
-                        },
-                        onRequestSuccess(param0, param1, param2) { },
-                        onRequestFailure(param0, param1, param2, param3) { },
-                        onRequestCancellation(param0) { },
-                        onProducerStart(param0, param1) { },
-                        onProducerEvent(param0, param1, param2) { },
-                        onProducerFinishWithSuccess(requestId, producerName, extraMap) {
-                            const owner = that?.get();
-                            const eventName = ImageBase.fetchingFromEvent;
-                            if (owner?.hasListeners(eventName)) {
-                                let source = 'local';
-                                if (producerName.indexOf('Network') !== -1) {
+                return false;
+            },
+            onResourceReady(resource, model, target, dataSource, isFirstResource) {
+                const instance = owner.get();
+                if (instance) {
+                    instance.progressCallback = null; // Clean up
+                    instance.loadSourceCallback = null;
+                    instance.notifyFinalImageSet(resource, dataSource);
+                    // Handle auto-play for animated drawables
+                    if (!instance.autoPlayAnimations && resource instanceof android.graphics.drawable.Animatable) {
+                        setTimeout(() => {
+                            resource.stop();
+                        }, 0);
+                    }
+                    // Notify load source for cache hits (network notified by interceptor)
+                    let source = 'local';
+                    if (dataSource) {
+                        try {
+                            const sourceName = dataSource.name ? dataSource.name() : String(dataSource);
+                            switch ((sourceName || '').toUpperCase()) {
+                                case 'MEMORY_CACHE':
+                                    source = 'memory';
+                                    break;
+                                case 'DATA_DISK_CACHE':
+                                case 'RESOURCE_DISK_CACHE':
+                                    source = 'disk';
+                                    break;
+                                case 'REMOTE':
                                     source = 'network';
-                                }
-                                else if (producerName.indexOf('Cache') !== -1) {
-                                    source = 'cache';
-                                }
-                                owner.notify({
-                                    eventName,
-                                    source
-                                });
+                                    break;
+                                case 'LOCAL':
+                                    source = 'local';
+                                    break;
                             }
-                        },
-                        onProducerFinishWithFailure(param0, param1, param2, param3) { },
-                        onProducerFinishWithCancellation(param0, param1, param2) { },
-                        onUltimateProducerReached(param0, param1, param2) { },
-                        requiresExtraMap(param0) { return false; },
-                    });
+                        }
+                        catch (err) {
+                            source = 'unknown';
+                        }
+                    }
+                    // Only notify if not network (network already notified by interceptor)
+                    if (source !== 'network' && instance.hasListeners('loadSource')) {
+                        instance.notifyLoadSource(source);
+                    }
                 }
-                const options = JSON.stringify({
-                    progressiveRenderingEnabled: this.blurRadius,
-                    localThumbnailPreviewsEnabled: this.blurRadius,
-                    decodeWidth: this.decodeWidth,
-                    decodeHeight: this.decodeHeight,
-                    blurRadius: this.blurRadius,
-                    lowerResSrc: this.lowerResSrc ? getUri(this.lowerResSrc, false) : undefined,
-                    blurDownSampling: this.blurDownSampling,
-                    autoPlayAnimations: this.autoPlayAnimations,
-                    tapToRetryEnabled: this.tapToRetryEnabled,
-                    headers: this.headers
-                });
-                view.setUri(uri, options, this.controllerListener, this.requestListener);
-                // const async = this.loadMode === 'async';
-                // if (async) {
-                // const builder = com.facebook.drawee.backends.pipeline.Fresco.newDraweeControllerBuilder();
-                // builder.setImageRequest(request);
-                // builder.setCallerContext(src);
-                // builder.setControllerListener(listener);
-                // builder.setOldController(this.nativeImageViewProtected.getController());
-                // if (Trace.isEnabled()) {
-                //     builder.setPerfDataListener(
-                //         new com.facebook.drawee.backends.pipeline.info.ImagePerfDataListener({
-                //             onImageLoadStatusUpdated(param0: com.facebook.drawee.backends.pipeline.info.ImagePerfData, param1: number) {
-                //                 CLog(CLogTypes.info, 'onImageLoadStatusUpdated', param0, param1);
-                //             },
-                //             onImageVisibilityUpdated(param0: com.facebook.drawee.backends.pipeline.info.ImagePerfData, param1: number) {
-                //                 CLog(CLogTypes.info, 'onImageVisibilityUpdated', param0, param1);
-                //             }
-                //         })
-                //     );
-                // }
-                // if (this.lowerResSrc) {
-                //     builder.setLowResImageRequest(com.facebook.imagepipeline.request.ImageRequest.fromUri(getUri(this.lowerResSrc)));
-                // }
-                // if (this.autoPlayAnimations) {
-                //     builder.setAutoPlayAnimations(this.autoPlayAnimations);
-                // }
-                // if (this.tapToRetryEnabled) {
-                //     builder.setTapToRetryEnabled(this.tapToRetryEnabled);
-                // }
-                // const controller = builder.build();
-                // this.nativeImageViewProtected.setController(controller);
-                // } else {
-                // const dataSource = com.facebook.drawee.backends.pipeline.Fresco.getImagePipeline().fetchDecodedImage(request, src);
-                // const result = com.facebook.datasource.DataSources.waitForFinalResult(dataSource);
-                // const bitmap = result.get().underlyingBitmap;
-                // CloseableReference.closeSafely(result);
-                // dataSource.close();
-                // }
+                return false;
             }
-            else {
-                this.nativeImageViewProtected.setController(null);
-                this.nativeImageViewProtected.setImageBitmap(null);
+        });
+        this.currentTarget = new com.nativescript.image.MatrixDrawableImageViewTarget(view);
+        requestBuilder.signature(signature).listener(new com.nativescript.image.CompositeRequestListener(objectArr)).into(this.currentTarget);
+    }
+    notifyLoadSource(source) {
+        const eventName = ImageBase.loadSourceEvent;
+        if (this.hasListeners(eventName)) {
+            this.notify({
+                eventName,
+                source // 'network', 'memory', 'disk', 'local'
+            });
+        }
+    }
+    notifyProgress(payload) {
+        const eventName = ImageBase.progressEvent;
+        if (this.hasListeners(eventName)) {
+            this.notify({
+                eventName,
+                current: payload.loaded,
+                total: payload.total,
+                progress: payload.progress,
+                finished: payload.finished
+            });
+        }
+    }
+    notifyFinalImageSet(drawable, dataSource) {
+        let sourceLabel = 'local';
+        if (dataSource) {
+            try {
+                sourceLabel = dataSource.name ? dataSource.name() : String(dataSource);
+            }
+            catch (err) {
+                sourceLabel = String(dataSource);
             }
+            switch ((sourceLabel || '').toUpperCase()) {
+                case 'MEMORY_CACHE':
+                    sourceLabel = 'memory';
+                    break;
+                case 'DATA_DISK_CACHE':
+                case 'RESOURCE_DISK_CACHE':
+                    sourceLabel = 'disk';
+                    break;
+                case 'REMOTE':
+                    sourceLabel = 'network';
+                    break;
+                case 'LOCAL':
+                    sourceLabel = 'local';
+                    break;
+                default:
+                    break;
+            }
+        }
+        const eventName = ImageBase.finalImageSetEvent;
+        if (this.hasListeners(eventName)) {
+            const width = drawable ? drawable.getIntrinsicWidth() : 0;
+            const height = drawable ? drawable.getIntrinsicHeight() : 0;
+            const info = new ImageInfo(width, height);
+            this.notify({
+                eventName,
+                imageInfo: info,
+                animatable: this.getAnimatable(drawable),
+                android: drawable,
+                source: sourceLabel
+            });
         }
     }
-    async initImage() {
-        // this.nativeImageViewProtected.setImageURI(null);
-        this.handleImageSrc(this.src);
+    notifyFailure(error) {
+        const eventName = ImageBase.failureEvent;
+        if (this.hasListeners(eventName)) {
+            this.notify({
+                eventName,
+                error: error instanceof java.lang.Throwable ? wrapNativeException(error) : error
+            });
+        }
     }
-    updateHierarchy() {
-        if (!this.mCanUpdateHierarchy) {
-            this.mNeedUpdateHierarchy = true;
+    getAnimatable(drawable) {
+        if (drawable && drawable instanceof android.graphics.drawable.Animatable) {
+            return drawable;
+        }
+        return null;
+    }
+    async handleImageSrc(src) {
+        const view = this.nativeViewProtected;
+        if (!view) {
             return;
         }
-        if (this.nativeImageViewProtected) {
-            let failureImageDrawable;
-            let placeholderImageDrawable;
-            let backgroundDrawable;
-            if (this.failureImageUri) {
-                failureImageDrawable = this.getDrawable(this.failureImageUri);
-            }
-            if (this.placeholderImageUri) {
-                placeholderImageDrawable = this.getDrawable(this.placeholderImageUri);
-            }
-            if (this.backgroundUri) {
-                backgroundDrawable = this.getDrawable(this.backgroundUri);
-            }
-            const builder = new GenericDraweeHierarchyBuilder();
-            if (this.failureImageUri && failureImageDrawable) {
-                builder.setFailureImage(failureImageDrawable, this.stretch);
-            }
-            if (this.tintColor) {
-                builder.setActualImageColorFilter(new android.graphics.PorterDuffColorFilter(this.tintColor.android, android.graphics.PorterDuff.Mode.MULTIPLY));
-            }
-            if (this.placeholderImageUri && placeholderImageDrawable) {
-                builder.setPlaceholderImage(placeholderImageDrawable, this.stretch);
+        if (src instanceof Promise) {
+            this.handleImageSrc(await src);
+            return;
+        }
+        else if (typeof src === 'function') {
+            const newSrc = src();
+            if (newSrc instanceof Promise) {
+                await newSrc;
             }
-            if (this.stretch) {
-                builder.setActualImageScaleType(this.stretch, this.imageRotation);
+            this.handleImageSrc(newSrc);
+            return;
+        }
+        if (src) {
+            let drawable;
+            if (typeof src === 'string') {
+                if (Utils.isFontIconURI(src)) {
+                    const fontIconCode = src.split('//')[1];
+                    if (fontIconCode !== undefined) {
+                        const font = this.style.fontInternal;
+                        const color = this.style.color;
+                        drawable = new android.graphics.drawable.BitmapDrawable(Utils.android.getApplicationContext().getResources(), ImageSource.fromFontIconCodeSync(fontIconCode, font, color).android);
+                    }
+                }
             }
-            builder.setFadeDuration(this.fadeDuration || 0);
-            if (this.backgroundUri && backgroundDrawable) {
-                builder.setBackground(backgroundDrawable);
+            else if (src instanceof ImageSource) {
+                drawable = new android.graphics.drawable.BitmapDrawable(Utils.android.getApplicationContext().getResources(), src.android);
             }
-            if (this.showProgressBar) {
-                builder.setProgressBarImage(this.progressBarColor?.hex, this.stretch);
+            if (drawable) {
+                view.setImageDrawable(drawable);
+                this.notifyFinalImageSet(drawable);
+                return;
             }
-            if (this.roundAsCircle) {
-                builder.setRoundingParamsAsCircle();
+            const uri = getUri(src);
+            if (!uri) {
+                console.error(`Error: 'src' not valid: ${src}`);
+                return;
             }
-            const topLeftRadius = this.roundTopLeftRadius || 0;
-            const topRightRadius = this.roundTopRightRadius || 0;
-            const bottomRightRadius = this.roundBottomRightRadius || 0;
-            const bottomLeftRadius = this.roundBottomLeftRadius || 0;
-            if (topLeftRadius || topRightRadius || bottomRightRadius || bottomLeftRadius) {
-                builder.setCornersRadii(Utils.layout.toDevicePixels(topLeftRadius), Utils.layout.toDevicePixels(topRightRadius), Utils.layout.toDevicePixels(bottomRightRadius), Utils.layout.toDevicePixels(bottomLeftRadius));
+            this.loadImageWithGlide(uri);
+        }
+        else {
+            // Clear existing request before removing the drawable
+            if (this.currentTarget) {
+                com.bumptech.glide.Glide.with(this._context).clear(this.currentTarget);
+                this.currentTarget = null;
             }
-            this.nativeImageViewProtected.setHierarchy(builder.build());
-            if (!this.mNeedRequestImage) {
-                this.nativeImageViewProtected.setController(this.nativeImageViewProtected.getController());
+            else {
+                com.bumptech.glide.Glide.with(this._context).clear(view);
             }
+            view.setImageDrawable(null);
+        }
+    }
+    async initImage() {
+        try {
+            await this.handleImageSrc(this.src);
+        }
+        catch (error) {
+            console.error(error, error.stack);
+        }
+    }
+    updateHierarchy() {
+        if (!this.mCanUpdateHierarchy) {
+            this.mNeedUpdateHierarchy = true;
+            return;
+        }
+        // Force reload with new settings
+        if (this.nativeImageViewProtected && this.src) {
+            this.initImage();
         }
     }
     getDrawable(path) {
-        let drawable;
         if (typeof path === 'string') {
             if (Utils.isFontIconURI(path)) {
                 const fontIconCode = path.split('//')[1];
                 if (fontIconCode !== undefined) {
-                    // support sync mode only
                     const font = this.style.fontInternal;
                     const color = this.style.color;
-                    drawable = new android.graphics.drawable.BitmapDrawable(Utils.android.getApplicationContext().getResources(), ImageSource.fromFontIconCodeSync(fontIconCode, font, color).android);
+                    return new android.graphics.drawable.BitmapDrawable(Utils.android.getApplicationContext().getResources(), ImageSource.fromFontIconCodeSync(fontIconCode, font, color).android);
                 }
             }
             else if (Utils.isFileOrResourcePath(path)) {
                 if (path.indexOf(Utils.RESOURCE_PREFIX) === 0) {
-                    return this.getDrawableFromResource(path); // number!
+                    return this.getDrawableFromResource(path);
                 }
                 else {
-                    drawable = this.getDrawableFromLocalFile(path);
+                    return this.getDrawableFromLocalFile(path);
                 }
             }
         }
-        else {
-            drawable = new android.graphics.drawable.BitmapDrawable(Utils.android.getApplicationContext().getResources(), path.android);
+        else if (path instanceof ImageSource) {
+            return new android.graphics.drawable.BitmapDrawable(Utils.android.getApplicationContext().getResources(), path.android);
         }
-        return drawable;
+        return null;
     }
     getDrawableFromLocalFile(localFilePath) {
         const img = ImageSource.fromFileSync(localFilePath);
-        let drawable = null;
         if (img) {
-            drawable = new android.graphics.drawable.BitmapDrawable(Utils.android.getApplicationContext().getResources(), img.android);
+            return new android.graphics.drawable.BitmapDrawable(Utils.android.getApplicationContext().getResources(), img.android);
         }
-        return drawable;
+        return null;
     }
     getDrawableFromResource(resourceName) {
         const application = Utils.android.getApplication();
         const resources = application.getResources();
         const identifier = resources.getIdentifier(resourceName.substring(Utils.RESOURCE_PREFIX.length), 'drawable', application.getPackageName());
-        // we return the identifier to allow Fresco to handle memory / caching
         return identifier;
-        // return Utils.android.getApplicationContext().getDrawable(identifier);
     }
     startAnimating() {
-        if (this.nativeImageViewProtected) {
-            const controller = this.nativeImageViewProtected.getController();
-            if (controller) {
-                const animatable = controller.getAnimatable();
-                if (animatable) {
-                    animatable.start();
-                }
-            }
+        const drawable = this.nativeViewProtected.getDrawable();
+        if (drawable && drawable instanceof android.graphics.drawable.Animatable) {
+            drawable.start();
         }
     }
     stopAnimating() {
-        if (this.nativeImageViewProtected) {
-            const controller = this.nativeImageViewProtected.getController();
-            if (controller) {
-                const animatable = controller.getAnimatable();
-                if (animatable) {
-                    animatable.stop();
-                }
-            }
+        const drawable = this.nativeViewProtected.getDrawable();
+        if (drawable && drawable instanceof android.graphics.drawable.Animatable) {
+            drawable.stop();
         }
     }
 }
@@ -857,19 +865,19 @@ __decorate([
     needUpdateHierarchy
 ], Img.prototype, _j, null);
 __decorate([
-    needUpdateHierarchy(true)
+    needRequestImage
 ], Img.prototype, _k, null);
 __decorate([
-    needUpdateHierarchy
+    needRequestImage
 ], Img.prototype, _l, null);
 __decorate([
-    needUpdateHierarchy
+    needRequestImage
 ], Img.prototype, _m, null);
 __decorate([
-    needUpdateHierarchy
+    needRequestImage
 ], Img.prototype, _o, null);
 __decorate([
-    needUpdateHierarchy
+    needRequestImage
 ], Img.prototype, _p, null);
 __decorate([
     needRequestImage
@@ -880,145 +888,32 @@ __decorate([
 __decorate([
     needRequestImage
 ], Img.prototype, _s, null);
-__decorate([
-    needRequestImage
-], Img.prototype, _t, null);
-__decorate([
-    needRequestImage
-], Img.prototype, _u, null);
-__decorate([
-    needRequestImage
-], Img.prototype, _v, null);
-class GenericDraweeHierarchyBuilder {
-    constructor() {
-        const res = Utils.android.getApplicationContext().getResources();
-        this.nativeBuilder = new com.facebook.drawee.generic.GenericDraweeHierarchyBuilder(res);
-    }
-    setPlaceholderImage(drawable, scaleType) {
-        if (!this.nativeBuilder) {
-            return this;
-        }
-        if (scaleType) {
-            this.nativeBuilder.setPlaceholderImage(drawable, getScaleType(scaleType));
-        }
-        else {
-            this.nativeBuilder.setPlaceholderImage(drawable);
-        }
-        return this;
-    }
-    setActualImageColorFilter(filter) {
-        if (!this.nativeBuilder) {
-            return this;
-        }
-        this.nativeBuilder.setActualImageColorFilter(filter);
-        return this;
-    }
-    setFailureImage(drawable, scaleType) {
-        if (!this.nativeBuilder) {
-            return null;
-        }
-        if (scaleType) {
-            this.nativeBuilder.setFailureImage(drawable, getScaleType(scaleType));
-        }
-        else {
-            this.nativeBuilder.setFailureImage(drawable);
-        }
-        return this;
-    }
-    setActualImageScaleType(scaleType, imageRotation = 0) {
-        if (!this.nativeBuilder) {
-            return this;
-        }
-        const nativeScaleType = getScaleType(scaleType);
-        if (imageRotation !== 0 && nativeScaleType['setImageRotation']) {
-            nativeScaleType['setImageRotation'](imageRotation);
-        }
-        this.nativeBuilder.setActualImageScaleType(nativeScaleType);
-        return this;
-    }
-    build() {
-        if (!this.nativeBuilder) {
-            return null;
-        }
-        return this.nativeBuilder.build();
-    }
-    setFadeDuration(duration) {
-        if (!this.nativeBuilder) {
-            return null;
-        }
-        this.nativeBuilder.setFadeDuration(duration);
-        return this;
-    }
-    setBackground(drawable) {
-        if (!this.nativeBuilder) {
-            return this;
-        }
-        this.nativeBuilder.setBackground(drawable);
-        return this;
-    }
-    setProgressBarImage(color, stretch) {
-        if (!this.nativeBuilder) {
-            return null;
-        }
-        const drawable = new com.facebook.drawee.drawable.ProgressBarDrawable();
-        if (color) {
-            drawable.setColor(android.graphics.Color.parseColor(color));
-        }
-        this.nativeBuilder.setProgressBarImage(drawable, getScaleType(stretch));
-        return this;
-    }
-    setRoundingParamsAsCircle() {
-        if (!this.nativeBuilder) {
-            return this;
-        }
-        const params = com.facebook.drawee.generic.RoundingParams.asCircle();
-        this.nativeBuilder.setRoundingParams(params);
-        return this;
-    }
-    setCornersRadii(topLeft, topRight, bottomRight, bottomLeft) {
-        if (!this.nativeBuilder) {
-            return this;
-        }
-        const params = new com.facebook.drawee.generic.RoundingParams();
-        params.setCornersRadii(topLeft, topRight, bottomRight, bottomLeft);
-        this.nativeBuilder.setRoundingParams(params);
-        return this;
-    }
-}
 function getScaleType(scaleType) {
     if (isString(scaleType)) {
         switch (scaleType) {
             case ScaleType.Center:
-                //@ts-ignore
-                return new com.nativescript.image.ScalingUtils.ScaleTypeCenter();
+                return android.widget.ImageView.ScaleType.CENTER;
             case ScaleType.AspectFill:
             case ScaleType.CenterCrop:
-                //@ts-ignore
-                return new com.nativescript.image.ScalingUtils.ScaleTypeCenterCrop();
+                return android.widget.ImageView.ScaleType.CENTER_CROP;
             case ScaleType.CenterInside:
-                //@ts-ignore
-                return new com.nativescript.image.ScalingUtils.ScaleTypeCenterInside();
+                return android.widget.ImageView.ScaleType.CENTER_INSIDE;
             case ScaleType.FitCenter:
             case ScaleType.AspectFit:
-                //@ts-ignore
-                return new com.nativescript.image.ScalingUtils.ScaleTypeFitCenter();
+                return android.widget.ImageView.ScaleType.FIT_CENTER;
             case ScaleType.FitEnd:
-                //@ts-ignore
-                return new com.nativescript.image.ScalingUtils.ScaleTypeFitEnd();
+                return android.widget.ImageView.ScaleType.FIT_END;
             case ScaleType.FitStart:
-                //@ts-ignore
-                return new com.nativescript.image.ScalingUtils.ScaleTypeFitStart();
+                return android.widget.ImageView.ScaleType.FIT_START;
             case ScaleType.Fill:
             case ScaleType.FitXY:
-                //@ts-ignore
-                return new com.nativescript.image.ScalingUtils.ScaleTypeFitXY();
+                return android.widget.ImageView.ScaleType.FIT_XY;
             case ScaleType.FocusCrop:
-                //@ts-ignore
-                return new com.nativescript.image.ScalingUtils.ScaleTypeFocusCrop();
+                return android.widget.ImageView.ScaleType.CENTER_CROP;
             default:
-                break;
+                return android.widget.ImageView.ScaleType.FIT_CENTER;
         }
     }
-    return null;
+    return android.widget.ImageView.ScaleType.FIT_CENTER;
 }
 //# sourceMappingURL=index.android.js.map