goog.Disposable | |
goog.net.FileDownloader | goog.Disposable |
dir
: !goog.fs.DirectoryEntry
The directory in which the downloaded
files are stored. This directory should be solely managed by
FileDownloader.
|
opt_pool
: goog.net.XhrIoPool=
The pool of XhrIo objects to use for
downloading files.
|
![]()
Abort the download of the given URL.
Arguments:
|
code » | ||||
![]()
No description.
|
code » | ||||
Download a remote file and save its contents to the filesystem. A given file
is uniquely identified by its URL string; this means that the relative and
absolute URLs for a single file are considered different for the purposes of
the FileDownloader.
Returns a Deferred that will contain the downloaded blob. If there's an error
while downloading the URL, this Deferred will be passed the
goog.net.FileDownloader.Error object as an errback.
If a download is already in progress for the given URL, this will return the
deferred blob for that download. If the URL has already been downloaded, this
will fail once it tries to save the downloaded blob.
When a download is in progress, all Deferreds returned for that download will
be branches of a single parent. If all such branches are cancelled, or if one
is cancelled with opt_deepCancel set, then the download will be cancelled as
well.
Arguments:
Returns: !goog.async.Deferred
The deferred result blob.
|
code » | ||||
![]()
The error callback for all asynchronous operations. Ensures that all stages
of a given download are cleaned up, and emits the error event.
Arguments:
|
code » | ||||
![]()
The callback called when a file that will be used for saving a file is
successfully opened.
Arguments:
|
code » | ||||
![]()
The callback called when a file writer is succesfully created for writing a
file to the filesystem.
Arguments:
|
code » | ||||
![]()
Remove all event listeners for an XHR and release it back into the pool.
Arguments:
|
code » | ||||
Get the directory for a given URL. If the directory already exists when this
is called, it will contain exactly one file: the downloaded file.
This not only calls the FileSystem API's getFile method, but attempts to
distribute the files so that they don't overload the filesystem. The spec
says directories can't contain more than 5000 files
(http://www.w3.org/TR/file-system-api/#directories), so this ensures that
each file is put into a subdirectory based on its SHA1 hash.
All parameters are the same as in the FileSystem API's Entry#getFile method.
Arguments:
Returns: !goog.async.Deferred
The deferred DirectoryEntry object.
|
code » | ||||
Load a downloaded blob from the filesystem. Will fire a deferred error if the
given URL has not yet been downloaded.
Arguments:
Returns: !goog.async.Deferred
The deferred Blob object. The callback will be
passed the blob. If a file API error occurs while loading the blob, that
error will be passed to the errback.
|
code » | ||||
Get the file for a given URL. This will only retrieve files that have already
been saved; it shouldn't be used for creating the file in the first place.
This is because the filename isn't necessarily determined by the URL, but by
the headers of the XHR response.
Arguments:
Returns: !goog.async.Deferred
The deferred FileEntry object.
|
code » | ||||
Get the local filesystem: URL for a downloaded file. This is different from
the blob: URL that's available from getDownloadedBlob(). If the end user
accesses the filesystem: URL, the resulting file's name will be determined by
the download filename as opposed to an arbitrary GUID. In addition, the
filesystem: URL is connected to a filesystem location, so if the download is
removed then that URL will become invalid.
Warning: in Chrome 12, some filesystem: URLs are opened inline. This means
that e.g. HTML pages given to the user via filesystem: URLs will be opened
and processed by the browser.
Arguments:
Returns: !goog.async.Deferred
The deferred filesystem: URL. The callback
will be passed the URL. If a file API error occurs while loading the
blob, that error will be passed to the errback.
|
code » | ||||
Gets the filename specified by the XHR. This first attempts to parse the
Content-Disposition header for a filename and, failing that, falls back on
deriving the filename from the URL.
Arguments:
Returns: string
The filename.
|
code » | ||||
![]()
The callback called when an XHR becomes available from the XHR pool.
Arguments:
|
code » | ||||
Return (deferred) whether or not a URL has been downloaded. Will fire a
deferred error if something goes wrong when determining this.
Arguments:
Returns: !goog.async.Deferred
The deferred boolean. The callback will be
passed the boolean. If a file API error occurs while checking the
existence of the downloaded URL, that error will be passed to the
errback.
|
code » | ||||
Returns whether or not there is an active download for a given URL.
|
code » | ||||
Remove a URL from the FileDownloader.
This returns a Deferred. If the removal is completed successfully, its
callback will be called without any value. If the removal fails, its errback
will be called with the
goog.fs.Error .
Arguments:
Returns: !goog.async.Deferred
The deferred used for registering callbacks on
success or on error.
|
code » | ||||
Sanitize a string so it can be safely used as a file or directory name for
the FileSystem API.
|
code » | ||||
Save a blob for a given URL. This works just as through the blob were
downloaded form that URL, except you specify the blob and no HTTP request is
made.
If the URL is currently being downloaded, it's indeterminate whether the blob
being set or the blob being downloaded will end up in the filesystem.
Whichever one doesn't get saved will have an error. To ensure that one or the
other takes precedence, use
#waitForDownload to allow the download to
complete before setting the blob.
Arguments:
Returns: !goog.async.Deferred
The deferred used for registering callbacks on
success or on error. This can be cancelled just like a
#download
Deferred. The objects passed to the errback will be
goog.net.FileDownloader.Error s.
|
code » | ||||
Extracts the basename from a URL.
|
code » | ||||
Return a Deferred that will fire once no download is active for a given URL.
If there's no download active for that URL when this is called, the deferred
will fire immediately; otherwise, it will fire once the download is complete,
whether or not it succeeds.
Arguments:
Returns: !goog.async.Deferred
The Deferred that will fire when the download
is complete.
|
code » | ||||
![]()
The callback called when file writing ends, whether or not it's successful.
Arguments:
|
code » | ||||
![]()
The callback called when an XHR succeeds in downloading a remote file.
Arguments:
|
code » |
![]()
Invokes a callback function when this object is disposed. Callbacks are
invoked in the order in which they were added.
Arguments:
|
code » | |||
![]()
Disposes of the object. If the object hasn't already been disposed of, calls
#disposeInternal . Classes that extend goog.Disposable should
override #disposeInternal in order to delete references to COM
objects, DOM nodes, and other disposable objects. Reentrant.
Returns: void
Nothing.
|
code » | |||
![]()
Deletes or nulls out any references to COM objects, DOM nodes, or other
disposable objects. Classes that extend
goog.Disposable should
override this method.
Not reentrant. To avoid calling it twice, it must only be called from the
subclass' disposeInternal method. Everywhere else the public
dispose method must be used.
For example:
mypackage.MyClass = function() { mypackage.MyClass.base(this, 'constructor'); // Constructor logic specific to MyClass. ... }; goog.inherits(mypackage.MyClass, goog.Disposable); mypackage.MyClass.prototype.disposeInternal = function() { // Dispose logic specific to MyClass. ... // Call superclass's disposeInternal at the end of the subclass's, like // in C++, to avoid hard-to-catch issues. mypackage.MyClass.base(this, 'disposeInternal'); }; |
code » | |||
Use
#isDisposed instead.
No description.
Returns: boolean
Whether the object has been disposed of.
|
code » | |||
No description.
Returns: boolean
Whether the object has been disposed of.
|
code » | |||
![]()
Associates a disposable object with this object so that they will be disposed
together.
Arguments:
|
code » |
![]()
No description.
|
Code » |