feat(core): maximum cache size and age

closes #14

package.json

@@ -32,10 +32,14 @@
  "@angular/compiler-cli": "2.2.1",
  "@angular/core": "2.2.1",
  "@angular/platform-browser": "2.2.1",
+ "@types/lodash": "^4.14.50",
  "conventional-changelog-cli": "^1.2.0",
  "ionic-native": "^2.4.1",
  "rxjs": "5.0.0-beta.12",
  "typescript": "2.0.9",
  "zone.js": "0.6.26"
+ },
+ "dependencies": {
+ "lodash": "^4.17.4"
  }
 }

src/providers/image-loader-config.ts

@@ -23,6 +23,10 @@ export class ImageLoaderConfig {
 
  concurrency: number = 5;
 
+ maxCacheSize: number = -1;
+
+ maxCacheAge: number = -1;
+
  private _cacheDirectoryName: string = 'image-loader-cache';
 
  set cacheDirectoryName(name: string) {

src/providers/image-loader.ts

@@ -1,6 +1,7 @@
 import { Injectable } from '@angular/core';
 import { File, FileEntry, FileReader, Transfer } from 'ionic-native';
 import { ImageLoaderConfig } from "./image-loader-config";
+import * as _ from 'lodash';
 
 declare var cordova: any;
 
@@ -39,6 +40,20 @@ export class ImageLoader {
 
  private processing: number = 0;
 
+ private cacheIndex: Array<{
+ name: string;
+ modificationTime: Date;
+ size: number;
+ }> = [];
+
+ private currentCacheSize: number = 0;
+
+ private indexed: boolean = false;
+
+ private get shouldIndex() {
+ return (this.config.maxCacheAge > -1) || (this.config.maxCacheSize > -1);
+ }
+
  constructor(private config: ImageLoaderConfig) {
  if (window.location.protocol === 'http:' || window.location.protocol === 'https:') {
  // we are running on a browser, or using livereload
@@ -113,9 +128,7 @@ export class ImageLoader {
 
  let getImage = () => {
  this.getCachedImagePath(imageUrl)
- .then(imagePath => {
- resolve(imagePath);
- })
+ .then(resolve)
  .catch(() => {
  // image doesn't exist in cache, lets fetch it and save it
  this.addItemToQueue(imageUrl, resolve, reject);
@@ -198,9 +211,13 @@ export class ImageLoader {
 
  let localPath = cordova.file.cacheDirectory + this.config.cacheDirectoryName + '/' + this.createFileName(currentItem.imageUrl);
  this.downloadImage(currentItem.imageUrl, localPath)
- .then(() => {
- currentItem.resolve(localPath);
+ .then((file: FileEntry) => {
+
+ if (this.shouldIndex) {
+ this.addFileToIndex(file).then(this.maintainCacheSize.bind(this));
+ }
 
+ currentItem.resolve(localPath);
  done();
  })
  .catch((e) => {
@@ -226,33 +243,100 @@ export class ImageLoader {
  }
 
  this.cacheDirectoryExists
- .then(() => {
+ .catch(() => {
+ // doesn't exist
+ return this.createCacheDirectory(replace)
+ .catch(e => {
 
- // exists
+ this.throwError(e);
+ this.isInit = true;
 
+ });
+ })
+ .then(() => this.indexCache())
+ .then(() => {
  this.isCacheReady = true;
  this.isInit = true;
+ });
 
- })
- .catch(() => {
+ }
 
- // doesn't exist
+ /**
+ * Adds a file to index.
+ * Also deletes any files if they are older than the set maximum cache age.
+ * @param file {FileEntry} File to index
+ * @returns {Promise<any>}
+ */
+ private addFileToIndex(file: FileEntry): Promise<any> {
+ return new Promise<any>((resolve, reject) => file.getMetadata(resolve, reject))
+ .then(metadata => {
+
+ if (
+ this.config.maxCacheAge > -1
+ && (Date.now() - metadata.modificationTime.getTime()) > this.config.maxCacheAge
+ ) {
+ // file age exceeds maximum cache age
+ return File.removeFile(cordova.file.cacheDirectory + this.config.cacheDirectoryName, 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
+ });
 
- this.createCacheDirectory(replace)
- .then(() => {
+ return Promise.resolve();
 
- this.isCacheReady = true;
- this.isInit = true;
+ }
 
-  })
-  .catch(e => {
+ });
+ }
 
- this.throwError(e);
- this.isInit = true;
+ /**
+ * Indexes the cache if necessary
+ * @returns {any}
+ */
+ private indexCache(): Promise<void> {
 
- });
+ // only index if needed, to save resources
+ if (!this.shouldIndex) return Promise.resolve();
+
+ this.cacheIndex = [];
 
+ return File.listDir(cordova.file.cacheDirectory, this.config.cacheDirectoryName)
+ .then(files => Promise.all(files.map(this.addFileToIndex.bind(this))))
+ .then(() => {
+ this.cacheIndex = _.sortBy(this.cacheIndex, 'modificationTime');
+ this.indexed = true;
+ return Promise.resolve();
+ })
+ .catch(e => {
+ this.throwError(e);
+ return Promise.resolve();
  });
+ }
+
+ /**
+ * 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.
+ */
+ private maintainCacheSize(): void {
+
+ if (this.config.maxCacheSize > -1 && this.indexed) {
+
+ // we exceeded max cache size
+ while (this.currentCacheSize > this.config.maxCacheSize) {
+ let file = this.cacheIndex.splice(0,1)[0];
+ File.removeFile(cordova.file.cacheDirectory + this.config.cacheDirectoryName, file.name);
+ this.currentCacheSize -= file.size;
+ }
+
+ }
 
  }