Merge pull request #2 from nstudio/feature/image-saving

feat(ios): image save to disk option

Author: triniwiz

src/angular/index.ts

@@ -1,7 +1,7 @@
 import { NgModule, ModuleWithProviders, Optional, SkipSelf } from '@angular/core';
 import { TNSBrowserXhr } from './TNSBrowserXhr';
 import { XhrFactory } from '@angular/common/http';
-import { TNSHttpDebugging } from '../http/http-request-common';
+import { TNSHttpSettings, ISaveImageSettings } from '../http/http-request-common';
 
 const BASE_PROVIDERS = [
     TNSBrowserXhr,
@@ -12,9 +12,12 @@ const BASE_PROVIDERS = [
     providers: BASE_PROVIDERS
 })
 export class NativeScriptHttpAsyncModule {
-  static forRoot(options: { configuredProviders?: Array<any>; debug?: boolean; }): ModuleWithProviders {
+  static forRoot(options: { configuredProviders?: Array<any>; debug?: boolean; saveImageSettings?: ISaveImageSettings }): ModuleWithProviders {
     if (options.debug) {
-      TNSHttpDebugging.enabled = true;
+      TNSHttpSettings.debug = true;
+    }
+    if (options.saveImageSettings) {
+      TNSHttpSettings.saveImage = options.saveImageSettings;
     }
     return {
       ngModule: NativeScriptHttpAsyncModule,

src/file/file.android.ts

@@ -35,6 +35,11 @@ export class FileManager {
             }
         }));
     }
+
+    public static deleteFile(path: string, options: Options = {asStream: false}, callback: (...args) => void) {
+      // TODO
+      callback(null, true);
+    }
 }
 
 export interface Options {

src/file/file.ios.ts

@@ -27,6 +27,17 @@ export class FileManager {
             }
         });
     }
+
+    public static deleteFile(path: string, options: Options = {asStream: false}, callback: (...args) => void) {
+      dispatch_async(background_queue, () => {
+          try {
+              NSFileManager.defaultManager.removeItemAtPathError(path);
+              callback(null, true);
+          } catch (e) {
+              callback(e, false);
+          }
+      });
+    }
 }
 
 export interface Options {

src/http/http-request-common.ts

@@ -1,8 +1,33 @@
-export class TNSHttpDebugging {
-  static enabled: boolean;
-  // TODO: could add other debuggin options
+export interface ISaveImageSettings {
+  numberOfRequests?: number;
+  removeAfterDays?: number;
+  storageKey?: string;
 }
 
+export const SaveImageStorageKey = 'http.saved-images';
+export function isImageUrl(url: string) {
+  return url && /(http(s?):)([/|.|\w|\s|-])*\.(?:jpg|gif|png)/ig.test(url);
+}
+export function fileNameFromPath(fullPath: string) {
+  let filename = '';
+  if (fullPath) {
+    filename = fullPath.replace(/^.*[\\\/]/ig, '');
+  }
+  return filename;
+}
+
+export class TNSHttpSettings {
+  static debug: boolean;
+  static saveImage: ISaveImageSettings;
+  static currentlySavedImages: { [url: string]: {
+      date: number;
+      requests: number;
+      localPath?: string;
+    }
+  };
+}
+
+
 export class ProgressEvent {
     private _type: string;
     private _lengthComputable: boolean;

src/http/http.ios.ts

@@ -1,5 +1,8 @@
 import * as types from 'tns-core-modules/utils/types';
-import { Headers, HttpError, HttpRequestOptions, TNSHttpDebugging } from './http-request-common';
+import { File, knownFolders, path } from 'tns-core-modules/file-system';
+import { FileManager } from '../file/file';
+import { Headers, HttpError, HttpRequestOptions, TNSHttpSettings, SaveImageStorageKey, isImageUrl, fileNameFromPath } from './http-request-common';
+import { getString, setString } from 'tns-core-modules/application-settings';
 
 export type CancellablePromise = Promise<any> & { cancel: () => void };
 
@@ -302,6 +305,16 @@ class NSURLSessionTaskDelegateImpl extends NSObject
             } else {
                 content = this._data;
             }
+            if (TNSHttpSettings.saveImage && TNSHttpSettings.currentlySavedImages && TNSHttpSettings.currentlySavedImages[this._url]) {
+              // ensure saved to disk
+              if (TNSHttpSettings.currentlySavedImages[this._url].localPath) {
+                FileManager.writeFile(content, TNSHttpSettings.currentlySavedImages[this._url].localPath, function(error, result) {
+                  if (TNSHttpSettings.debug) {
+                    console.log('http image save:', error ? error : result);
+                  }
+                });
+              }
+            }
 
             if (this._debuggerRequest) {
                 this._debuggerRequest.mimeType = this._response.MIMEType;
@@ -377,14 +390,8 @@ export class Http {
 
             try {
 
-                let domainDebugger;
-                let debugRequest;
-                if (TNSHttpDebugging.enabled) {
-                    domainDebugger = require('tns-core-modules/debugger');
-                    const network = domainDebugger.getNetwork();
-                    debugRequest = network && network.create();
-                }
-
+              const makeRemoteRequest = () => {
+                // make remote request
                 const urlRequest = NSMutableURLRequest.requestWithURL(
                     NSURL.URLWithString(options.url)
                 );
@@ -455,6 +462,74 @@ export class Http {
                     debugRequest.requestWillBeSent(request);
                 }
                 task.resume();
+              };
+
+                let domainDebugger;
+                let debugRequest;
+                if (TNSHttpSettings.debug) {
+                    domainDebugger = require('tns-core-modules/debugger');
+                    const network = domainDebugger.getNetwork();
+                    debugRequest = network && network.create();
+                }
+
+                if (TNSHttpSettings.saveImage && isImageUrl(options.url)) {
+                  // handle saved images to disk
+                  if (!TNSHttpSettings.currentlySavedImages) {
+                    const stored = getString(SaveImageStorageKey);
+                    if (stored) {
+                      try {
+                        TNSHttpSettings.currentlySavedImages = JSON.parse(stored);
+                      } catch (err) {
+                        TNSHttpSettings.currentlySavedImages = {};
+                      }
+                    } else {
+                      TNSHttpSettings.currentlySavedImages = {};
+                    }
+                  }
+
+                  const imageSetting = TNSHttpSettings.currentlySavedImages[options.url];
+                  const requests = imageSetting ? imageSetting.requests : 0;
+                  let localPath: string;
+                  if (imageSetting && imageSetting.localPath && File.exists(imageSetting.localPath)) {
+                    // previously saved to disk
+                    resolve({
+                      url: options.url,
+                      responseText: '',
+                      statusCode: 200,
+                      content: File.fromPath(imageSetting.localPath).readSync(function(err) {
+                        if (TNSHttpSettings.debug) {
+                          console.log('http image load error:', err);
+                        }
+                      }),
+                      headers: {
+                        'Content-Type': 'arraybuffer'
+                      }
+                    });
+
+                  } else if (requests >= TNSHttpSettings.saveImage.numberOfRequests) {
+                    // setup to write to disk when response finishes
+                    let filename = fileNameFromPath(options.url);
+                    if (filename.indexOf('?')) {
+                      // strip any params if were any
+                      filename = filename.split('?')[0];
+                    }
+                    localPath = path.join(knownFolders.documents().path, filename);
+                    makeRemoteRequest();
+                  }
+
+                  // save settings
+                  TNSHttpSettings.currentlySavedImages[options.url] = {
+                    ...(imageSetting || {}),
+                    date: Date.now(),
+                    requests: requests + 1,
+                    localPath
+                  };
+                  setString(SaveImageStorageKey, JSON.stringify(TNSHttpSettings.currentlySavedImages));
+
+                } else {
+                  makeRemoteRequest();
+                }
+
             } catch (ex) {
                 reject({
                     type: HttpError.Error,