mirror of
https://github.com/apache/cordova-plugin-file-transfer.git
synced 2024-10-06 15:52:20 +08:00
236 lines
8.2 KiB
JavaScript
236 lines
8.2 KiB
JavaScript
/*
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one
|
|
* or more contributor license agreements. See the NOTICE file
|
|
* distributed with this work for additional information
|
|
* regarding copyright ownership. The ASF licenses this file
|
|
* to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing,
|
|
* software distributed under the License is distributed on an
|
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
* KIND, either express or implied. See the License for the
|
|
* specific language governing permissions and limitations
|
|
* under the License.
|
|
*
|
|
*/
|
|
|
|
var argscheck = require('cordova/argscheck'),
|
|
exec = require('cordova/exec'),
|
|
FileTransferError = require('./FileTransferError'),
|
|
ProgressEvent = require('cordova-plugin-file.ProgressEvent');
|
|
|
|
function newProgressEvent(result) {
|
|
var pe = new ProgressEvent();
|
|
pe.lengthComputable = result.lengthComputable;
|
|
pe.loaded = result.loaded;
|
|
pe.total = result.total;
|
|
return pe;
|
|
}
|
|
|
|
function getUrlCredentials(urlString) {
|
|
var credentialsPattern = /^https?\:\/\/(?:(?:(([^:@\/]*)(?::([^@\/]*))?)?@)?([^:\/?#]*)(?::(\d*))?).*$/,
|
|
credentials = credentialsPattern.exec(urlString);
|
|
|
|
return credentials && credentials[1];
|
|
}
|
|
|
|
function getBasicAuthHeader(urlString) {
|
|
var header = null;
|
|
|
|
|
|
// This is changed due to MS Windows doesn't support credentials in http uris
|
|
// so we detect them by regexp and strip off from result url
|
|
// Proof: http://social.msdn.microsoft.com/Forums/windowsapps/en-US/a327cf3c-f033-4a54-8b7f-03c56ba3203f/windows-foundation-uri-security-problem
|
|
|
|
if (window.btoa) {
|
|
var credentials = getUrlCredentials(urlString);
|
|
if (credentials) {
|
|
var authHeader = "Authorization";
|
|
var authHeaderValue = "Basic " + window.btoa(credentials);
|
|
|
|
header = {
|
|
name : authHeader,
|
|
value : authHeaderValue
|
|
};
|
|
}
|
|
}
|
|
|
|
return header;
|
|
}
|
|
|
|
function convertHeadersToArray(headers) {
|
|
var result = [];
|
|
for (var header in headers) {
|
|
if (headers.hasOwnProperty(header)) {
|
|
var headerValue = headers[header];
|
|
result.push({
|
|
name: header,
|
|
value: headerValue.toString()
|
|
});
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
var idCounter = 0;
|
|
|
|
/**
|
|
* FileTransfer uploads a file to a remote server.
|
|
* @constructor
|
|
*/
|
|
var FileTransfer = function() {
|
|
this._id = ++idCounter;
|
|
this.onprogress = null; // optional callback
|
|
};
|
|
|
|
/**
|
|
* Given an absolute file path, uploads a file on the device to a remote server
|
|
* using a multipart HTTP request.
|
|
* @param filePath {String} Full path of the file on the device
|
|
* @param server {String} URL of the server to receive the file
|
|
* @param successCallback (Function} Callback to be invoked when upload has completed
|
|
* @param errorCallback {Function} Callback to be invoked upon error
|
|
* @param options {FileUploadOptions} Optional parameters such as file name and mimetype
|
|
* @param trustAllHosts {Boolean} Optional trust all hosts (e.g. for self-signed certs), defaults to false
|
|
*/
|
|
FileTransfer.prototype.upload = function(filePath, server, successCallback, errorCallback, options, trustAllHosts) {
|
|
argscheck.checkArgs('ssFFO*', 'FileTransfer.upload', arguments);
|
|
// check for options
|
|
var fileKey = null;
|
|
var fileName = null;
|
|
var mimeType = null;
|
|
var params = null;
|
|
var chunkedMode = true;
|
|
var headers = null;
|
|
var httpMethod = null;
|
|
var basicAuthHeader = getBasicAuthHeader(server);
|
|
if (basicAuthHeader) {
|
|
server = server.replace(getUrlCredentials(server) + '@', '');
|
|
|
|
options = options || {};
|
|
options.headers = options.headers || {};
|
|
options.headers[basicAuthHeader.name] = basicAuthHeader.value;
|
|
}
|
|
|
|
if (options) {
|
|
fileKey = options.fileKey;
|
|
fileName = options.fileName;
|
|
mimeType = options.mimeType;
|
|
headers = options.headers;
|
|
httpMethod = options.httpMethod || "POST";
|
|
if (httpMethod.toUpperCase() == "PUT"){
|
|
httpMethod = "PUT";
|
|
} else {
|
|
httpMethod = "POST";
|
|
}
|
|
if (options.chunkedMode !== null || typeof options.chunkedMode != "undefined") {
|
|
chunkedMode = options.chunkedMode;
|
|
}
|
|
if (options.params) {
|
|
params = options.params;
|
|
}
|
|
else {
|
|
params = {};
|
|
}
|
|
}
|
|
|
|
if (cordova.platformId === "windowsphone") {
|
|
headers = headers && convertHeadersToArray(headers);
|
|
params = params && convertHeadersToArray(params);
|
|
}
|
|
|
|
var fail = errorCallback && function(e) {
|
|
var error = new FileTransferError(e.code, e.source, e.target, e.http_status, e.body, e.exception);
|
|
errorCallback(error);
|
|
};
|
|
|
|
var self = this;
|
|
var win = function(result) {
|
|
if (typeof result.lengthComputable != "undefined") {
|
|
if (self.onprogress) {
|
|
self.onprogress(newProgressEvent(result));
|
|
}
|
|
} else {
|
|
successCallback && successCallback(result);
|
|
}
|
|
};
|
|
exec(win, fail, 'FileTransfer', 'upload', [filePath, server, fileKey, fileName, mimeType, params, trustAllHosts, chunkedMode, headers, this._id, httpMethod]);
|
|
};
|
|
|
|
/**
|
|
* Downloads a file form a given URL and saves it to the specified directory.
|
|
* @param source {String} URL of the server to receive the file
|
|
* @param target {String} Full path of the file on the device
|
|
* @param successCallback (Function} Callback to be invoked when upload has completed
|
|
* @param errorCallback {Function} Callback to be invoked upon error
|
|
* @param trustAllHosts {Boolean} Optional trust all hosts (e.g. for self-signed certs), defaults to false
|
|
* @param options {FileDownloadOptions} Optional parameters such as headers
|
|
*/
|
|
FileTransfer.prototype.download = function(source, target, successCallback, errorCallback, trustAllHosts, options) {
|
|
argscheck.checkArgs('ssFF*', 'FileTransfer.download', arguments);
|
|
var self = this;
|
|
|
|
var basicAuthHeader = getBasicAuthHeader(source);
|
|
if (basicAuthHeader) {
|
|
source = source.replace(getUrlCredentials(source) + '@', '');
|
|
|
|
options = options || {};
|
|
options.headers = options.headers || {};
|
|
options.headers[basicAuthHeader.name] = basicAuthHeader.value;
|
|
}
|
|
|
|
var headers = null;
|
|
if (options) {
|
|
headers = options.headers || null;
|
|
}
|
|
|
|
if (cordova.platformId === "windowsphone" && headers) {
|
|
headers = convertHeadersToArray(headers);
|
|
}
|
|
|
|
var win = function(result) {
|
|
if (typeof result.lengthComputable != "undefined") {
|
|
if (self.onprogress) {
|
|
return self.onprogress(newProgressEvent(result));
|
|
}
|
|
} else if (successCallback) {
|
|
var entry = null;
|
|
if (result.isDirectory) {
|
|
entry = new (require('cordova-plugin-file.DirectoryEntry'))();
|
|
}
|
|
else if (result.isFile) {
|
|
entry = new (require('cordova-plugin-file.FileEntry'))();
|
|
}
|
|
entry.isDirectory = result.isDirectory;
|
|
entry.isFile = result.isFile;
|
|
entry.name = result.name;
|
|
entry.fullPath = result.fullPath;
|
|
entry.filesystem = new FileSystem(result.filesystemName || (result.filesystem == window.PERSISTENT ? 'persistent' : 'temporary'));
|
|
entry.nativeURL = result.nativeURL;
|
|
successCallback(entry);
|
|
}
|
|
};
|
|
|
|
var fail = errorCallback && function(e) {
|
|
var error = new FileTransferError(e.code, e.source, e.target, e.http_status, e.body, e.exception);
|
|
errorCallback(error);
|
|
};
|
|
|
|
exec(win, fail, 'FileTransfer', 'download', [source, target, trustAllHosts, this._id, headers]);
|
|
};
|
|
|
|
/**
|
|
* Aborts the ongoing file transfer on this object. The original error
|
|
* callback for the file transfer will be called if necessary.
|
|
*/
|
|
FileTransfer.prototype.abort = function() {
|
|
exec(null, null, 'FileTransfer', 'abort', [this._id]);
|
|
};
|
|
|
|
module.exports = FileTransfer;
|