ionic-image-loader-v7/esm2020/lib/services/image-loader.service.mjs

ionic-image-loader to Ionic 6

import { Injectable } from '@angular/core';
import { File } from '@awesome-cordova-plugins/file/ngx';
import { fromEvent, Subject } from 'rxjs';
import { filter, first, take } from 'rxjs/operators';
import * as i0 from "@angular/core";
import * as i1 from "./image-loader-config.service";
import * as i2 from "@awesome-cordova-plugins/file/ngx";
import * as i3 from "@angular/common/http";
import * as i4 from "@ionic/angular";
import * as i5 from "@awesome-cordova-plugins/ionic-webview/ngx";
const EXTENSIONS = ['jpg', 'png', 'jpeg', 'gif', 'svg', 'tiff'];
export class ImageLoaderService {
    constructor(config, file, http, platform, webview) {
        this.config = config;
        this.file = file;
        this.http = http;
        this.platform = platform;
        this.webview = webview;
        /**
         * Indicates if the cache service is ready.
         * When the cache service isn't ready, images are loaded via browser instead.
         */
        this.isCacheReady = false;
        /**
         * Indicates if this service is initialized.
         * This service is initialized once all the setup is done.
         */
        this.isInit = false;
        this.initPromise = new Promise(resolve => this.initPromiseResolve = resolve);
        this.lockSubject = new Subject();
        this.lock$ = this.lockSubject.asObservable();
        /**
         * Number of concurrent requests allowed
         */
        this.concurrency = 5;
        /**
         * Queue items
         */
        this.queue = [];
        this.processing = 0;
        /**
         * Fast accessible Object for currently processing items
         */
        this.currentlyProcessing = {};
        this.cacheIndex = [];
        this.currentCacheSize = 0;
        this.indexed = false;
        this.lockedCallsQueue = [];
        if (!platform.is('cordova')) {
            // we are running on a browser, or using livereload
            // plugin will not function in this case
            this.isInit = true;
            this.throwWarning('You are running on a browser or using livereload, IonicImageLoader will not function, falling back to browser loading.');
            this.initPromiseResolve();
        }
        else {
            fromEvent(document, 'deviceready')
                .pipe(first())
                .subscribe(res => {
                if (this.nativeAvailable) {
                    this.initCache();
                }
                else {
                    // we are running on a browser, or using livereload
                    // plugin will not function in this case
                    this.isInit = true;
                    this.initPromiseResolve();
                    this.throwWarning('You are running on a browser or using livereload, IonicImageLoader will not function, falling back to browser loading.');
                }
            });
        }
    }
    get nativeAvailable() {
        return File.installed();
    }
    get isCacheSpaceExceeded() {
        return (this.config.maxCacheSize > -1 &&
            this.currentCacheSize > this.config.maxCacheSize);
    }
    get isWKWebView() {
        return (this.platform.is('ios') &&
            window.webkit &&
            window.webkit.messageHandlers);
    }
    get isIonicWKWebView() {
        return (
        //  Important: isWKWebview && isIonicWKWebview must be mutually excluse.
        //  Otherwise the logic for copying to tmp under IOS will fail.
        (this.platform.is('android') && this.webview) ||
            (this.platform.is('android')) && (location.host === 'localhost:8080') ||
            window.LiveReload);
    }
    get isDevServer() {
        return window['IonicDevServer'] !== undefined;
    }
    /**
     * Check if we can process more items in the queue
     */
    get canProcess() {
        return this.queue.length > 0 && this.processing < this.concurrency;
    }
    ready() {
        return this.initPromise;
    }
    /**
     * Preload an image
     * @param imageUrl Image URL
     * @returns returns a promise that resolves with the cached image URL
     */
    preload(imageUrl) {
        return this.getImagePath(imageUrl);
    }
    getFileCacheDirectory() {
        if (this.config.cacheDirectoryType === 'data') {
            return this.file.dataDirectory;
        }
        else if (this.config.cacheDirectoryType === 'external') {
            return this.platform.is('android') ? this.file.externalDataDirectory : this.file.documentsDirectory;
        }
        return this.file.cacheDirectory;
    }
    /**
     * Clears cache of a single image
     * @param imageUrl Image URL
     */
    async clearImageCache(imageUrl) {
        if (!this.platform.is('cordova')) {
            return;
        }
        await this.ready();
        this.runLocked(async () => {
            const fileName = this.createFileName(imageUrl);
            const route = this.getFileCacheDirectory() + this.config.cacheDirectoryName;
            // pause any operations
            this.isInit = false;
            try {
                await this.file.removeFile(route, fileName);
                if (this.isWKWebView && !this.isIonicWKWebView) {
                    await this.file.removeFile(this.file.tempDirectory + this.config.cacheDirectoryName, fileName);
                }
            }
            catch (err) {
                this.throwError(err);
            }
            return this.initCache(true);
        });
    }
    /**
     * Clears the cache
     */
    async clearCache() {
        if (!this.platform.is('cordova')) {
            return;
        }
        await this.ready();
        this.runLocked(async () => {
            try {
                await this.file.removeRecursively(this.getFileCacheDirectory(), this.config.cacheDirectoryName);
                if (this.isWKWebView && !this.isIonicWKWebView) {
                    // also clear the temp files
                    try {
                        this.file.removeRecursively(this.file.tempDirectory, this.config.cacheDirectoryName);
                    }
                    catch (err) {
                        // Noop catch. Removing the tempDirectory might fail,
                        // as it is not persistent.
                    }
                }
            }
            catch (err) {
                this.throwError(err);
            }
            return this.initCache(true);
        });
    }
    /**
     * Gets the filesystem path of an image.
     * This will return the remote path if anything goes wrong or if the cache service isn't ready yet.
     * @param imageUrl The remote URL of the image
     * @returns Returns a promise that will always resolve with an image URL
     */
    async getImagePath(imageUrl) {
        if (typeof imageUrl !== 'string' || imageUrl.length <= 0) {
            throw new Error('The image url provided was empty or invalid.');
        }
        await this.ready();
        if (!this.isCacheReady) {
            this.throwWarning('The cache system is not running. Images will be loaded by your browser instead.');
            return imageUrl;
        }
        if (this.isImageUrlRelative(imageUrl)) {
            return imageUrl;
        }
        try {
            return await this.getCachedImagePath(imageUrl);
        }
        catch (err) {
            // image doesn't exist in cache, lets fetch it and save it
            return this.addItemToQueue(imageUrl);
        }
    }
    async processLockedQueue() {
        if (await this.getLockedState()) {
            return;
        }
        if (this.lockedCallsQueue.length > 0) {
            await this.setLockedState(true);
            try {
                await this.lockedCallsQueue.slice(0, 1)[0]();
            }
            catch (err) {
                console.log('Error running locked function: ', err);
            }
            await this.setLockedState(false);
            return this.processLockedQueue();
        }
    }
    getLockedState() {
        return this.lock$
            .pipe(take(1))
            .toPromise();
    }
    awaitUnlocked() {
        return this.lock$
            .pipe(filter(locked => !!locked), take(1))
            .toPromise();
    }
    async setLockedState(locked) {
        this.lockSubject.next(locked);
    }
    runLocked(fn) {
        this.lockedCallsQueue.push(fn);
        this.processLockedQueue();
    }
    /**
     * Returns if an imageUrl is an relative path
     * @param imageUrl
     */
    isImageUrlRelative(imageUrl) {
        return !/^(https?|file):\/\/\/?/i.test(imageUrl);
    }
    /**
     * Add an item to the queue
     * @param imageUrl
     * @param resolve
     * @param reject
     */
    addItemToQueue(imageUrl, resolve, reject) {
        let p;
        if (!resolve && !reject) {
            p = new Promise((res, rej) => {
                resolve = res;
                reject = rej;
            });
        }
        else {
            resolve = resolve || (() => {
            });
            reject = reject || (() => {
            });
        }
        this.queue.push({
            imageUrl,
            resolve,
            reject,
        });
        this.processQueue();
        return p;
    }
    /**
     * Processes one item from the queue
     */
    async processQueue() {
        // make sure we can process items first
        if (!this.canProcess) {
            return;
        }
        // increase the processing number
        this.processing++;
        // take the first item from queue
        const currentItem = this.queue.splice(0, 1)[0];
        // function to call when done processing this item
        // this will reduce the processing number
        // then will execute this function again to process any remaining items
        const done = () => {
            this.processing--;
            this.processQueue();
            // only delete if it's the last/unique occurrence in the queue
            if (this.currentlyProcessing[currentItem.imageUrl] !== undefined && !this.currentlyInQueue(currentItem.imageUrl)) {
                delete this.currentlyProcessing[currentItem.imageUrl];
            }
        };
        const error = (e) => {
            currentItem.reject();
            this.throwError(e);
            done();
        };
        if (this.currentlyProcessing[currentItem.imageUrl] !== undefined) {
            try {
                // Prevented same Image from loading at the same time
                await this.currentlyProcessing[currentItem.imageUrl];
                const localUrl = await this.getCachedImagePath(currentItem.imageUrl);
                currentItem.resolve(localUrl);
                done();
            }
            catch (err) {
                error(err);
            }
            return;
        }
        this.currentlyProcessing[currentItem.imageUrl] = (async () => {
            // process more items concurrently if we can
            if (this.canProcess) {
                this.processQueue();
            }
            const localDir = this.getFileCacheDirectory() + this.config.cacheDirectoryName + '/';
            const fileName = this.createFileName(currentItem.imageUrl);
            try {
                const data = await this.http.get(currentItem.imageUrl, {
                    responseType: 'blob',
                    headers: this.config.httpHeaders,
                }).toPromise();
                const file = await this.file.writeFile(localDir, fileName, data, { replace: true });
                if (this.isCacheSpaceExceeded) {
                    this.maintainCacheSize();
                }
                await this.addFileToIndex(file);
                const localUrl = await this.getCachedImagePath(currentItem.imageUrl);
                currentItem.resolve(localUrl);
                done();
                this.maintainCacheSize();
            }
            catch (err) {
                error(err);
                throw err;
            }
        })();
    }
    /**
     * Search if the url is currently in the queue
     * @param imageUrl Image url to search
     */
    currentlyInQueue(imageUrl) {
        return this.queue.some(item => item.imageUrl === imageUrl);
    }
    /**
     * Initialize the cache service
     * @param [replace] Whether to replace the cache directory if it already exists
     */
    async initCache(replace) {
        this.concurrency = this.config.concurrency;
        // create cache directories if they do not exist
        try {
            await this.createCacheDirectory(replace);
            await this.indexCache();
            this.isCacheReady = true;
        }
        catch (err) {
            this.throwError(err);
        }
        this.isInit = true;
        this.initPromiseResolve();
    }
    /**
     * Adds a file to index.
     * Also deletes any files if they are older than the set maximum cache age.
     * @param file FileEntry to index
     */
    async addFileToIndex(file) {
        const metadata = await new Promise((resolve, reject) => file.getMetadata(resolve, reject));
        if (this.config.maxCacheAge > -1 &&
            Date.now() - metadata.modificationTime.getTime() >
                this.config.maxCacheAge) {
            // file age exceeds maximum cache age
            return this.removeFile(file.name);
        }
        else {
            // file age doesn't exceed maximum cache age, or maximum cache age isn't set
            this.currentCacheSize += metadata.size;
            // add item to index
            this.cacheIndex.push({
                name: file.name,
                modificationTime: metadata.modificationTime,
                size: metadata.size,
            });
        }
    }
    /**
     * Indexes the cache if necessary
     */
    async indexCache() {
        this.cacheIndex = [];
        try {
            const files = await this.file.listDir(this.getFileCacheDirectory(), this.config.cacheDirectoryName);
            await Promise.all(files.map(this.addFileToIndex.bind(this)));
            // Sort items by date. Most recent to oldest.
            this.cacheIndex = this.cacheIndex.sort((a, b) => (a > b ? -1 : a < b ? 1 : 0));
            this.indexed = true;
        }
        catch (err) {
            this.throwError(err);
        }
    }
    /**
     * This method runs every time a new file is added.
     * It checks the cache size and ensures that it doesn't exceed the maximum cache size set in the config.
     * If the limit is reached, it will delete old images to create free space.
     */
    async maintainCacheSize() {
        if (this.config.maxCacheSize > -1 && this.indexed) {
            const maintain = async () => {
                if (this.currentCacheSize > this.config.maxCacheSize) {
                    // grab the first item in index since it's the oldest one
                    const file = this.cacheIndex.splice(0, 1)[0];
                    if (typeof file === 'undefined') {
                        return maintain();
                    }
                    // delete the file then process next file if necessary
                    try {
                        await this.removeFile(file.name);
                    }
                    catch (err) {
                        // ignore errors, nothing we can do about it
                    }
                    this.currentCacheSize -= file.size;
                    return maintain();
                }
            };
            return maintain();
        }
    }
    /**
     * Remove a file
     * @param file The name of the file to remove
     */
    async removeFile(file) {
        await this.file.removeFile(this.getFileCacheDirectory() + this.config.cacheDirectoryName, file);
        if (this.isWKWebView && !this.isIonicWKWebView) {
            try {
                return this.file.removeFile(this.file.tempDirectory + this.config.cacheDirectoryName, file);
            }
            catch (err) {
                // Noop catch. Removing the files from tempDirectory might fail, as it is not persistent.
            }
        }
    }
    /**
     * Get the local path of a previously cached image if exists
     * @param url The remote URL of the image
     * @returns Returns a promise that resolves with the local path if exists, or rejects if doesn't exist
     */
    async getCachedImagePath(url) {
        await this.ready();
        if (!this.isCacheReady) {
            throw new Error('Cache is not ready');
        }
        // if we're running with livereload, ignore cache and call the resource from it's URL
        if (this.isDevServer) {
            return url;
        }
        // get file name
        const fileName = this.createFileName(url);
        // get full path
        const dirPath = this.getFileCacheDirectory() + this.config.cacheDirectoryName, tempDirPath = this.file.tempDirectory + this.config.cacheDirectoryName;
        try {
            // check if exists
            const fileEntry = await this.file.resolveLocalFilesystemUrl(dirPath + '/' + fileName);
            // file exists in cache
            if (this.config.imageReturnType === 'base64') {
                // read the file as data url and return the base64 string.
                // should always be successful as the existence of the file
                // is already ensured
                const base64 = await this.file.readAsDataURL(dirPath, fileName);
                return base64.replace('data:null', 'data:*/*');
            }
            else if (this.config.imageReturnType !== 'uri') {
                return;
            }
            // now check if iOS device & using WKWebView Engine.
            // in this case only the tempDirectory is accessible,
            // therefore the file needs to be copied into that directory first!
            if (this.isIonicWKWebView) {
                return this.normalizeUrl(fileEntry);
            }
            if (!this.isWKWebView) {
                // return native path
                return fileEntry.nativeURL;
            }
            // check if file already exists in temp directory
            try {
                const tempFileEntry = await this.file.resolveLocalFilesystemUrl(tempDirPath + '/' + fileName);
                // file exists in temp directory
                // return native path
                return this.normalizeUrl(tempFileEntry);
            }
            catch (err) {
                // file does not yet exist in the temp directory.
                // copy it!
                const tempFileEntry = await this.file
                    .copyFile(dirPath, fileName, tempDirPath, fileName);
                // now the file exists in the temp directory
                // return native path
                return this.normalizeUrl(tempFileEntry);
            }
        }
        catch (err) {
            throw new Error('File does not exist');
        }
    }
    /**
     * Normalizes the image uri to a version that can be loaded in the webview
     * @param fileEntry the FileEntry of the image file
     * @returns the normalized Url
     */
    normalizeUrl(fileEntry) {
        // Use Ionic normalizeUrl to generate the right URL for Ionic WKWebView
        if (Ionic && typeof Ionic.normalizeURL === 'function') {
            return Ionic.normalizeURL(fileEntry.nativeURL);
        }
        // use new webview function to do the trick
        if (this.webview) {
            return this.webview.convertFileSrc(fileEntry.nativeURL);
        }
        return fileEntry.nativeURL;
    }
    /**
     * Throws a console error if debug mode is enabled
     * @param args Error message
     */
    throwError(...args) {
        if (this.config.debugMode) {
            args.unshift('ImageLoader Error: ');
            console.error.apply(console, args);
        }
    }
    /**
     * Throws a console warning if debug mode is enabled
     * @param args Error message
     */
    throwWarning(...args) {
        if (this.config.debugMode) {
            args.unshift('ImageLoader Warning: ');
            console.warn.apply(console, args);
        }
    }
    /**
     * Check if the cache directory exists
     * @param directory The directory to check. Either this.file.tempDirectory or this.getFileCacheDirectory()
     * @returns Returns a promise that resolves if exists, and rejects if it doesn't
     */
    cacheDirectoryExists(directory) {
        return this.file.checkDir(directory, this.config.cacheDirectoryName);
    }
    /**
     * Create the cache directories
     * @param replace override directory if exists
     * @returns Returns a promise that resolves if the directories were created, and rejects on error
     */
    createCacheDirectory(replace = false) {
        let cacheDirectoryPromise, tempDirectoryPromise;
        if (replace) {
            // create or replace the cache directory
            cacheDirectoryPromise = this.file.createDir(this.getFileCacheDirectory(), this.config.cacheDirectoryName, replace);
        }
        else {
            // check if the cache directory exists.
            // if it does not exist create it!
            cacheDirectoryPromise = this.cacheDirectoryExists(this.getFileCacheDirectory())
                .catch(() => this.file.createDir(this.getFileCacheDirectory(), this.config.cacheDirectoryName, false));
        }
        if (this.isWKWebView && !this.isIonicWKWebView) {
            if (replace) {
                // create or replace the temp directory
                tempDirectoryPromise = this.file.createDir(this.file.tempDirectory, this.config.cacheDirectoryName, replace);
            }
            else {
                // check if the temp directory exists.
                // if it does not exist create it!
                tempDirectoryPromise = this.cacheDirectoryExists(this.file.tempDirectory).catch(() => this.file.createDir(this.file.tempDirectory, this.config.cacheDirectoryName, false));
            }
        }
        else {
            tempDirectoryPromise = Promise.resolve();
        }
        return Promise.all([cacheDirectoryPromise, tempDirectoryPromise]);
    }
    /**
     * Creates a unique file name out of the URL
     * @param url URL of the file
     * @returns Unique file name
     */
    createFileName(url) {
        // hash the url to get a unique file name
        return (this.hashString(url).toString() +
            (this.config.fileNameCachedWithExtension
                ? this.getExtensionFromUrl(url)
                : ''));
    }
    /**
     * Converts a string to a unique 32-bit int
     * @param string string to hash
     * @returns 32-bit int
     */
    hashString(string) {
        let hash = 0, char;
        if (string.length === 0) {
            return hash;
        }
        for (let i = 0; i < string.length; i++) {
            char = string.charCodeAt(i);
            // tslint:disable-next-line
            hash = (hash << 5) - hash + char;
            // tslint:disable-next-line
            hash = hash & hash;
        }
        return hash;
    }
    /**
     * Extract extension from filename or url
     *
     * @param url
     * @returns
     *
     * Not always will url's contain a valid image extention. We'll check if any valid extention is supplied.
     * If not, we will use the default.
     */
    getExtensionFromUrl(url) {
        const urlWitoutParams = url.split(/\#|\?/)[0];
        const ext = (urlWitoutParams.substr((~-urlWitoutParams.lastIndexOf('.') >>> 0) + 1) || '').toLowerCase();
        return (EXTENSIONS.indexOf(ext) >= 0 ? ext : this.config.fallbackFileNameCachedExtension);
    }
}
ImageLoaderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: ImageLoaderService, deps: [{ token: i1.ImageLoaderConfigService }, { token: i2.File }, { token: i3.HttpClient }, { token: i4.Platform }, { token: i5.WebView }], target: i0.ɵɵFactoryTarget.Injectable });
ImageLoaderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: ImageLoaderService, providedIn: 'root' });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: ImageLoaderService, decorators: [{
            type: Injectable,
            args: [{
                    providedIn: 'root',
                }]
        }], ctorParameters: function () { return [{ type: i1.ImageLoaderConfigService }, { type: i2.File }, { type: i3.HttpClient }, { type: i4.Platform }, { type: i5.WebView }]; } });
//# sourceMappingURL=data:application/json;base64,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