MOBILE-1554 resource: Open online URL for streaming resources

Author: dpalou

www/addons/mod_resource/services/resource.js

@@ -22,7 +22,7 @@ angular.module('mm.addons.mod_resource')
  * @name $mmaModResource
  */
 .factory('$mmaModResource', function($mmFilepool, $mmSite, $mmUtil, $mmFS, $http, $log, $q, $sce, $mmApp, $mmSitesManager,
-            mmaModResourceComponent) {
+            mmaModResourceComponent, mmCoreNotDownloaded, mmCoreDownloading, mmCoreDownloaded) {
     $log = $log.getInstance('$mmaModResource');
 
     var self = {};
@@ -356,20 +356,61 @@ angular.module('mm.addons.mod_resource')
             siteId = $mmSite.getId(),
             revision = $mmFilepool.getRevisionFromFileList(files),
             timeMod = $mmFilepool.getTimemodifiedFromFileList(files),
+            component = mmaModResourceComponent,
+            url = contents[0].fileurl,
+            fixedUrl = $mmSite.fixPluginfileURL(url),
             promise;
 
         if ($mmFS.isAvailable()) {
             // The file system is available.
-            promise = $mmFilepool.downloadPackage(siteId, files, mmaModResourceComponent, moduleId, revision, timeMod).then(function() {
-                return $mmFilepool.getUrlByUrl(siteId, contents[0].fileurl, mmaModResourceComponent, moduleId, timeMod);
+            promise = $mmFilepool.getPackageStatus(siteId, component, moduleId, revision, timeMod).then(function(status) {
+                var isWifi = !$mmApp.isNetworkAccessLimited(),
+                    isOnline = $mmApp.isOnline();
+
+                if (status === mmCoreDownloaded) {
+                    // Get the local file URL.
+                    return $mmFilepool.getUrlByUrl(siteId, url, component, moduleId, timeMod);
+                } else if (status === mmCoreDownloading) {
+                    // Return the online URL.
+                    return fixedUrl;
+                } else {
+                    if (!isOnline && status === mmCoreNotDownloaded) {
+                        // Not downloaded and we're offline, reject.
+                        return $q.reject();
+                    }
+
+                    return $mmFilepool.shouldDownloadBeforeOpen(fixedUrl, contents[0].filesize).then(function() {
+                        // Download and then return the local URL.
+                        return $mmFilepool.downloadPackage(siteId, files, component, moduleId, revision, timeMod).then(function() {
+                            return $mmFilepool.getUrlByUrl(siteId, url, component, moduleId, timeMod);
+                        });
+                    }, function() {
+                        // Start the download if in wifi, but return the URL right away so the file is opened.
+                        if (isWifi && isOnline) {
+                            $mmFilepool.downloadPackage(siteId, files, component, moduleId, revision, timeMod);
+                        }
+
+                        if (status === mmCoreNotDownloaded || isOnline) {
+                            // Not downloaded or outdated and online, return the online URL.
+                            return fixedUrl;
+                        } else {
+                            // Outdated but offline, so we return the local URL.
+                            return $mmFilepool.getUrlByUrl(siteId, url, component, moduleId, timeMod);
+                        }
+                    });
+                }
             });
         } else {
             // We use the live URL.
-            promise = $q.when($mmSite.fixPluginfileURL(url));
+            promise = $q.when(fixedUrl);
         }
 
-        return promise.then(function(localUrl) {
-            return $mmUtil.openFile(localUrl);
+        return promise.then(function(url) {
+            if (url.indexOf('http') === 0) {
+                return $mmUtil.openOnlineFile(url);
+            } else {
+                return $mmUtil.openFile(url);
+            }
         });
     };
 

www/core/lib/filepool.js

@@ -2321,6 +2321,37 @@ angular.module('mm.core')
         });
     };
 
+    /**
+     * Convenience function to check if a file should be downloaded before opening it.
+     *
+     * @module mm.core
+     * @ngdoc method
+     * @name $mmFilepool#shouldDownloadBeforeOpen
+     * @param  {String} url  File online URL.
+     * @param  {Number} size File size.
+     * @return {Promise}     Promise resolved if should download before open, rejected otherwise.
+     * @description
+     * Convenience function to check if a file should be downloaded before opening it.
+     *
+     * The default behaviour in the app is to download first and then open the local file in the following cases:
+     *     - The file is small (less than mmFilepoolDownloadThreshold).
+     *     - The file cannot be streamed.
+     * If the file is big and can be streamed, the promise returned by this function will be rejected.
+     */
+    self.shouldDownloadBeforeOpen = function(url, size) {
+        if (size >= 0 && size <= mmFilepoolDownloadThreshold) {
+            // The file is small, download it.
+            return $q.when();
+        }
+
+        return $mmUtil.getMimeType(url).then(function(mimetype) {
+            // If the file is streaming (audio or video) we reject.
+            if (mimetype.indexOf('video') != -1 || mimetype.indexOf('audio') != -1) {
+                return $q.reject();
+            }
+        });
+    };
+
     /**
      * Store package status.
      *

www/core/lib/text.js

@@ -337,10 +337,17 @@ angular.module('mm.core')
     self.guessExtensionFromUrl = function(fileUrl) {
         var split = fileUrl.split('.'),
             candidate,
-            extension;
+            extension,
+            position;
 
         if (split.length > 1) {
             candidate = split.pop().toLowerCase();
+            // Remove params if any.
+            position = candidate.indexOf('?');
+            if (position > -1) {
+                candidate = candidate.substr(0, position);
+            }
+
             if (extensionRegex.test(candidate)) {
                 extension = candidate;
             }

www/core/lib/util.js

@@ -277,20 +277,12 @@ angular.module('mm.core')
          * @name $mmUtil#openFile
          * @param  {String} path The local path of the file to be open.
          * @return {Void}
+         * @todo Restore node-webkit support.
          */
         self.openFile = function(path) {
             var deferred = $q.defer();
 
-            if (false) {
-                // TODO Restore node-webkit support.
-
-                // Link is the file path in the file system.
-                // We use the node-webkit shell for open the file (pdf, doc) using the default application configured in the os.
-                // var gui = require('nw.gui');
-                // gui.Shell.openItem(path);
-                deferred.resolve();
-
-            } else if (window.plugins) {
+            if (window.plugins) {
                 var extension = $mmFS.getFileExtension(path),
                     mimetype = $mmFS.getMimeType(extension);
 
@@ -425,30 +417,24 @@ angular.module('mm.core')
 
         /**
          * Open an online file using platform specific method.
+         * Specially useful for audio and video since they can be streamed.
          *
          * node-webkit: Using the default application configured.
          * Android: Using the WebIntent plugin.
-         * iOs: Using the window.open method.
+         * iOS: Using the window.open method (InAppBrowser)
+         *      We don't use iOS quickview framework because it doesn't support streaming.
          *
          * @module mm.core
          * @ngdoc method
          * @name $mmUtil#openOnlineFile
          * @param  {String} url The URL of the file.
          * @return {Promise}    Promise resolved when opened.
+         * @todo Restore node-webkit support.
          */
         self.openOnlineFile = function(url) {
             var deferred = $q.defer();
 
-            if (false) {
-                // @todo Restore node-webkit support.
-
-                // Link is the file path in the file system.
-                // We use the node-webkit shell for open the file (pdf, doc) using the default application configured in the os.
-                // var gui = require('nw.gui');
-                // gui.Shell.openItem(path);
-                deferred.resolve();
-
-            } else if (ionic.Platform.isAndroid() && window.plugins && window.plugins.webintent) {
+            if (ionic.Platform.isAndroid() && window.plugins && window.plugins.webintent) {
                 // In Android we need the mimetype to open it.
                 var extension,
                     iParams;
@@ -496,6 +482,27 @@ angular.module('mm.core')
             return deferred.promise;
         };
 
+        /**
+         * Get the mimetype of a file given its URL. It'll perform a HEAD request to get it, if that
+         * fails it'll try to guess it using the URL.
+         *
+         * @module mm.core
+         * @ngdoc method
+         * @name $mmUtil#getMimeType
+         * @param  {String} url The URL of the file.
+         * @return {Promise}    Promise resolved with the mimetype.
+         */
+        self.getMimeType = function(url) {
+            return $mmWS.getRemoteFileMimeType(url).then(function(mimetype) {
+                if (!mimetype) {
+                    // Couldn't retireve mimetype. Try to guess it.
+                    extension = $mmText.guessExtensionFromUrl(url);
+                    mimetype = $mmFS.getMimeType(extension);
+                }
+                return mimetype || '';
+            });
+        };
+
         /**
          * Displays a loading modal window.
          *

www/core/lib/ws.js

@@ -26,7 +26,8 @@ angular.module('mm.core')
 
     $log = $log.getInstance('$mmWS');
 
-    var self = {};
+    var self = {},
+        mimeTypeCache = {}; // A "cache" to store file mimetypes to prevent performing too many HEAD requests.
 
     /**
      * A wrapper function for a moodle WebService call.
@@ -237,12 +238,19 @@ angular.module('mm.core')
      * @module mm.core
      * @ngdoc method
      * @name $mmWS#getRemoteFileMimeType
-     * @param {Object} url File URL.
-     * @return {Promise}   Promise resolved with the mimetype or '' if failure.
+     * @param  {Object} url          File URL.
+     * @param  {Boolean} ignoreCache True to ignore cache, false otherwise.
+     * @return {Promise}             Promise resolved with the mimetype or '' if failure.
      */
-    self.getRemoteFileMimeType = function(url) {
+    self.getRemoteFileMimeType = function(url, ignoreCache) {
+        if (mimeTypeCache[url] && !ignoreCache) {
+            promise = $q.when(mimeTypeCache[url]);
+        }
+
         return $http.head(url).then(function(data) {
-            return data.headers('Content-Type') || '';
+            var mimeType = data.headers('Content-Type');
+            mimeTypeCache[url] = mimeType;
+            return mimeType || '';
         }).catch(function() {
             return '';
         });