Prototype implementation of MediaImportHandler.

ui/file_manager/file_manager/background/js/media_import_handler.js

+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Namespace
+var importer = importer || {};
+
+/**
+ * Handler for importing media from removable devices into the user's Drive.
+ * @param {!FileOperationManager} fileOperationManager
+ * @param {!MediaScanner=} opt_scanner
+ * @constructor
+ * @struct
+ */
+importer.MediaImportHandler = function(fileOperationManager, opt_scanner) {
+  /**
+   * Progress center to submit the progressing item.

[Steve McKay, 2014/12/05 01:09:39]

Comment doesn't seem to match the val.

[Ben Kwa, 2014/12/05 17:22:50]

Doh, I completely missed updating this jsdoc.  Fixed.

+   * @private {!FileOperationManager}
+   * @const

[Steve McKay, 2014/12/05 01:09:39]

Use @const or don't for your "final" fields. Just be consistent.

[Ben Kwa, 2014/12/05 17:22:50]

Done.

+   */
+  this.fileOperationManager_ = fileOperationManager;
+
+  /** @private {!MediaScanner} */
+  this.scanner_ = opt_scanner || new MediaScanner();
+};
+
+/**
+ * @typedef {function():(!DirectoryEntry|!Promise<!DirectoryEntry>)}
+ */
+importer.MediaImportHandler.DestinationFactory;
+
+/**
+ * Import all media found in a given subdirectory tree.
+ * @param {!DirectoryEntry} source The directory to import media from.
+ * @param {!importer.MediaImportHandler.DestinationFactory=} opt_destination A

[Steve McKay, 2014/12/05 01:09:39]

Why not just make opt_destination required, then let the foreground work out
(with the user) where to import. Then you can nuke all of the destination
related stuff.

[Ben Kwa, 2014/12/05 17:22:50]

I figured this was a good intermediate step that enabled us to get the overall
import process up and running.  Adding a bunch of UI to enable the user to
select a location sounds good, but I'd like to do it in a follow-up CL.

+ *     function that returns the directory into which media will be imported.
+ *     The function will be executed only when the import task actually runs.
+ * @return {!importer.MediaImportHandler.ImportTask} The resulting import task.
+ */
+importer.MediaImportHandler.prototype.importMedia =
+    function(source, opt_destination) {
+  var destination = opt_destination ||
+      importer.MediaImportHandler.defaultDestination.getImportDestination;
+  return new importer.MediaImportHandler.ImportTask(
+      this.fileOperationManager_,
+      this.scanner_,
+      source,
+      destination);
+};
+
+/**
+ * Note that this isn't an actual FileOperationManager.Task.  It currently uses
+ * the FileOperationManager (and thus *spawns* an associated
+ * FileOperationManager.CopyTask) but this is a temporary state of affairs.
+ *
+ * TODO(kenobi): Add a proper implementation that doesn't use
+ * FileOperationManager, but instead actually performs the copy using the
+ * fileManagerPrivate API directly.
+ *
+ * @param {!FileOperationManager} fileOperationManager
+ * @param {!MediaScanner} mediaScanner
+ * @param {!DirectoryEntry} source Source dir containing media for import.
+ * @param {!importer.MediaImportHandler.DestinationFactory} destination A
+ *     function that returns the directory into which media will be imported.
+ * @constructor
+ * @struct
+ */
+importer.MediaImportHandler.ImportTask =
+    function(fileOperationManager, mediaScanner, source, destination) {
+  this.source_ = source;

[Steve McKay, 2014/12/05 01:09:39]

Missing jsdoc on the fields.

[Ben Kwa, 2014/12/05 17:22:50]

Done.

+  this.scanner_ = mediaScanner;
+
+  // Call fileOperationManager.requestTaskCancel to cancel this task.
+  // TODO(kenobi): Add task cancellation.
+  this.taskId_ = fileOperationManager.generateTaskId();
+
+  Promise.all([
+    destination(),

[Steve McKay, 2014/12/05 01:09:39]

I think this is all okay for the early prototype.

That said: The "Import" task is really just a copy task, no? We should do the
file scanning outside of the Task, then construct the Task once all of the input
is available. Then you've got a much simpler Task that is pretty much data only.
Besides, I think we'll want to do the scanning prior to the user initiating
import. Why?

1) We can show the user what they're about to do (Copy 123 files taking up nGB
of space)?
2) We can pre-determine if there is sufficient space on the local device to copy
the media.
3) We can show the user what is going on while we're scanning (think about a
banner with info on "Finding files to import.....found 16, 17, ....).

Basically it seems like a separate task unto it self.

Here's how I think the whole thing would go down.

1) Foreground discovers a device that is eligible for import.
2) Foreground asks background's import manager, hey, scan this thing.
3) Import manager returns a new ScanResult that is a live view on the scanning
process....it fires change events so the UI can be updated when results change.
4) Foreground shows the user what is happening. User is not confused, User is
rather happy.
5) Scan finishes.
6) User approves import, foreground asks import manager to kick off import,
giving it back the scan result.
7) Import manager returns an ImportResult object so that the Foreground can show
progress on the import task, and deal with errors, if any, as they arise.

There are corner cases along the way we'll need to deal with, like insufficient
storage. That'll need to happen in the Foreground too. So I think we need to
keep a pipeline open between foreground and background during all major
operations.


Thoughts?

[Ben Kwa, 2014/12/05 17:22:50]

I agree with the (eventual) separation between the scanning and copying tasks. 
That said, the ImportTask is a copy task, but it is not necessarily a
fileOperationUtil.CopyTask (if that's what you meant).  That detail is still
being worked out.

All the other stuff makes sense.

+    this.scanner_.scan([source])
+  ]).then(
+      function(args) {
+        /** @type {!DirectoryEntry} */
+        var destinationDir = args[0];
+        /** @type {!Array<!FileEntry>} */
+        var media = args[1];
+
+        fileOperationManager.paste(
+            media,
+            destinationDir,
+            /* isMove */ false,
+            /* opt_taskId */ this.taskId_);
+      }.bind(this));
+};
+
+/** @struct */
+importer.MediaImportHandler.ImportTask.prototype = {
+  /**
+   * @return {string} The task ID.
+   */
+  get taskId() {
+    return this.taskId_;
+  }
+};
+
+/**
+ * Namespace for a default import destination factory. The
+ * defaultDestionation.getImportDestination function creates and returns the
+ * directory /photos/YYYY-MM-DD in the user's Google Drive.  YYYY-MM-DD is the
+ * current date.
+ */
+importer.MediaImportHandler.defaultDestination = {};
+
+/**
+ * Retrieves the user's drive root.
+ * @return {!Promise<!DirectoryEntry>}
+ * @private
+ */
+importer.MediaImportHandler.defaultDestination.getDriveRoot_ = function() {
+  // TODO(kenobi): change this to 'other' to get the unparented drive root.
+  /** @const {string} */
+  var rootName = 'root';

[Steve McKay, 2014/12/05 01:09:39]

Why not just inline it, or put it in a CONSTANT?

[Ben Kwa, 2014/12/05 17:22:50]

This was here to make it clear what had to change in order for us to switch to
unparented imports.  That's looking less and less likely, so I just switched to
the code that hirono@ suggested below.

+
+  return VolumeManager.getInstance()
+      .then(
+          function(volumeManager) {
+            var drive = volumeManager.getCurrentProfileVolumeInfo(
+                VolumeManagerCommon.VolumeType.DRIVE);
+            // Use the root for unparented objects.
+            return new Promise(function(resolve, reject) {

[hirono, 2014/12/05 05:57:37]

You can do "return drive.resolveDisplayRoot();"

[Ben Kwa, 2014/12/05 17:22:50]

Thanks!  Done.

+              drive.fileSystem.root.getDirectory(
+                  rootName,
+                  {create: false},
+                  resolve,
+                  reject);
+            });
+          });
+};
+
+/**
+ * Fetches (creating if necessary) the import destination subdirectory.
+ * @param {!DirectoryEntry} root The drive root.
+ * @return {!Promise<!DirectoryEntry>}
+ * @private
+ */
+importer.MediaImportHandler.defaultDestination.getOrCreateImportDestination_ =
+    function(root) {
+  /**
+   * @param {string} name The name of the new directory.
+   * @param {!DirectoryEntry} entry The parent directory.
+   * @return {!Promise<!DirectoryEntry>} The created directory.
+   */
+  var mkdir_ = function(name, entry) {
+    /** @const {Object} */
+    var CREATE_OPTIONS = {
+      create: true,
+      exclusive: false
+    };
+    return new Promise(function(resolve, reject) {
+      entry.getDirectory(name, CREATE_OPTIONS, resolve, reject);
+    });
+  };
+
+  /**
+   * @return {string} The current date, in YYYY-MM-DD format.
+   */
+  var getDateString = function() {
+    var padAndConvert = function(i) {
+      return (i < 10 ? '0' : '') + i.toString();
+    };
+    var date = new Date();
+    var year = date.getFullYear().toString();
+    var month = padAndConvert(date.getMonth());
+    var day = padAndConvert(date.getDate());
+
+    return year + '-' + month + '-' + day;
+  };
+
+  return Promise.resolve(root)
+      .then(mkdir_.bind(this, 'photos'))
+      .then(mkdir_.bind(this, getDateString()));
+};
+
+/**
+ * Returns the destination directory for media imports.  Creates the
+ * destination, if it doesn't exist.
+ * @return {!Promise<!DirectoryEntry>}
+ */
+importer.MediaImportHandler.defaultDestination.getImportDestination =
+    function() {
+  var defaultDestination = importer.MediaImportHandler.defaultDestination;
+  return defaultDestination.getDriveRoot_()
+      .then(defaultDestination.getOrCreateImportDestination_);
+};