forked from 0x2620/pandora
363 lines
15 KiB
JavaScript
363 lines
15 KiB
JavaScript
'use strict';
|
|
|
|
pandora.fs = (function() {
|
|
var that = {
|
|
local: {},
|
|
downloads: {},
|
|
enabled: false,
|
|
},
|
|
active,
|
|
queue = [],
|
|
requestedBytes = 100*1024*1024*1024; // 100GB
|
|
|
|
if(window.webkitRequestFileSystem) {
|
|
that.enabled = true;
|
|
window.webkitRequestFileSystem(window.PERSISTENT, requestedBytes, function(fs) {
|
|
that.fs = fs;
|
|
that.fs.root.createReader().readEntries(function(results) {
|
|
results.forEach(function(entry) {
|
|
if (entry.isFile && !Ox.startsWith(entry.name, 'partial::')) {
|
|
that.local[entry.name] = entry.toURL();
|
|
}
|
|
});
|
|
});
|
|
}, function(e) {
|
|
Ox.Log('FS', 'Error:', e);
|
|
});
|
|
}
|
|
|
|
function cacheVideo(id, callback) {
|
|
active = true;
|
|
pandora.api.get({id: id, keys: ['parts']}, function(result) {
|
|
var parts = result.data.parts, sizes = [];
|
|
downloadPart(0);
|
|
|
|
function downloadPart(part) {
|
|
if (that.getVideoURL(id, pandora.user.ui.videoResolution, part + 1)) {
|
|
done();
|
|
} else {
|
|
that.downloadVideoURL(id, pandora.user.ui.videoResolution, part + 1, false, function(result) {
|
|
result.progress = 1/parts * (part + result.progress);
|
|
that.downloads[id].progress = result.progress;
|
|
if (result.cancel) {
|
|
that.downloads[id].cancel = result.cancel;
|
|
}
|
|
if (result.total) {
|
|
sizes[part] = result.total;
|
|
that.downloads[id].size = Ox.sum(sizes);
|
|
}
|
|
if (result.url) {
|
|
done();
|
|
}
|
|
callback && callback(result);
|
|
});
|
|
}
|
|
function done() {
|
|
var n = 0;
|
|
if (part + 1 == parts) {
|
|
Ox.range(parts).forEach(function(part) {
|
|
var name = that.getVideoName(id, pandora.user.ui.videoResolution, part + 1),
|
|
partialName = 'partial::' + name;
|
|
renameFile(partialName, name, function(fileEntry) {
|
|
if (fileEntry) {
|
|
that.local[name] = fileEntry.toURL();
|
|
} else {
|
|
Ox.print('rename failed');
|
|
callback && callback({progress: -1, error: 'rename failed'});
|
|
}
|
|
if (++n == parts) {
|
|
callback && callback({
|
|
progress: 1
|
|
});
|
|
}
|
|
});
|
|
});
|
|
delete that.downloads[id];
|
|
active = false;
|
|
if (queue.length) {
|
|
var next = queue.shift();
|
|
setTimeout(function() {
|
|
cacheVideo(next[0], next[1]);
|
|
});
|
|
}
|
|
} else {
|
|
setTimeout(function() {
|
|
downloadPart(part + 1);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
function renameFile(old, name, callback) {
|
|
that.fs.root.getFile(old, {}, function(fileEntry) {
|
|
fileEntry.moveTo(that.fs.root, name);
|
|
setTimeout(function() {
|
|
that.fs.root.getFile(name, {}, callback, function() { callback() });
|
|
});
|
|
}, function() {
|
|
Ox.Log('FS', 'failed to move', old, name);
|
|
callback();
|
|
});
|
|
}
|
|
|
|
that.cacheVideo = function(id, callback) {
|
|
if (that.getVideoURL(id, pandora.user.ui.videoResolution, 1) || that.downloads[id]) {
|
|
callback({progress: 1});
|
|
return;
|
|
} else {
|
|
that.downloads = that.downloads || {};
|
|
that.downloads[id] = {
|
|
added: new Date(),
|
|
cancel: function() {
|
|
},
|
|
id: id + '::' + pandora.user.ui.videoResolution,
|
|
item: id,
|
|
progress: 0,
|
|
resolution: pandora.user.ui.videoResolution,
|
|
size: 0
|
|
};
|
|
|
|
(active || queue.length)
|
|
? queue.push([id, callback])
|
|
: cacheVideo(id, callback);
|
|
}
|
|
|
|
};
|
|
|
|
that.getVideoName = function(id, resolution, part, track) {
|
|
return pandora.getVideoURLName(id, resolution, part, track).replace('/', '::');
|
|
};
|
|
|
|
that.removeVideo = function(id, callback) {
|
|
if (that.downloads && that.downloads[id] && that.downloads[id].cancel) {
|
|
that.downloads[id].cancel();
|
|
delete that.downloads[id];
|
|
active = false;
|
|
if (queue.length) {
|
|
var next = queue.shift();
|
|
setTimeout(function() {
|
|
cacheVideo(next[0], next[1]);
|
|
});
|
|
}
|
|
} else {
|
|
pandora.api.get({id: id, keys: ['parts']}, function(result) {
|
|
var count = result.data.parts * pandora.site.video.resolutions.length, done = 0;
|
|
Ox.range(result.data.parts).forEach(function(part) {
|
|
pandora.site.video.resolutions.forEach(function(resolution) {
|
|
var name = that.getVideoName(id, resolution, part + 1);
|
|
that.fs.root.getFile(name, {create: false}, function(fileEntry) {
|
|
// remove existing file
|
|
fileEntry.remove(function(e) {
|
|
if (that.local[name]) {
|
|
delete that.local[name];
|
|
}
|
|
});
|
|
++done == count && callback();
|
|
}, function() { // file not found
|
|
++done == count && callback();
|
|
});
|
|
// remove partial file too
|
|
that.fs.root.getFile('partial::' + name, {create: false}, function(fileEntry) {
|
|
fileEntry.remove(function(e) {});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
}
|
|
};
|
|
|
|
that.storeBlob = function(blob, name, callback, append) {
|
|
requestQuota(blob.size, function() {
|
|
that.fs.root.getFile(name, {create: true}, function(fileEntry) {
|
|
fileEntry.createWriter(function(fileWriter) {
|
|
append && fileWriter.seek(fileWriter.length);
|
|
fileWriter.onwriteend = function(e) {
|
|
callback({
|
|
progress: 1,
|
|
url: fileEntry.toURL()
|
|
});
|
|
};
|
|
fileWriter.onerror = function(event) {
|
|
Ox.Log('FS', 'Write failed: ' + event.toString());
|
|
callback({progress: -1, event: event});
|
|
};
|
|
fileWriter.write(blob);
|
|
}, function(event) {
|
|
callback({progress: -1, event: event});
|
|
});
|
|
}, function(event) {
|
|
callback({progress: -1, event: event});
|
|
});
|
|
}, function(event) {
|
|
callback({progress: -1, event: event});
|
|
});
|
|
|
|
function requestQuota(size, callback, error) {
|
|
navigator.webkitPersistentStorage.queryUsageAndQuota(function(usage, quota) {
|
|
if (quota - usage < size) {
|
|
navigator.webkitPersistentStorage.requestQuota(quota + requestedBytes, function(grantedBytes) {
|
|
callback();
|
|
}, error);
|
|
} else {
|
|
callback();
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
that.downloadVideoURL = function(id, resolution, part, track, callback) {
|
|
//fixme: would be nice to download videos from subdomains,
|
|
// currently throws a cross domain error
|
|
var name = that.getVideoName(id, resolution, part, track),
|
|
partialName = 'partial::' + name,
|
|
url = '/' + pandora.getVideoURLName(id, resolution, part, track),
|
|
blobSize = 5*1024*1024, total;
|
|
Ox.Log('FS', 'start downloading', url);
|
|
getSize(url, function(size) {
|
|
Ox.Log('FS', 'HEAD', url, size);
|
|
total = size;
|
|
that.fs.root.getFile(partialName, {create: false}, function(fileEntry) {
|
|
fileEntry.getMetadata(function(meta) {
|
|
if (meta.size >= total) {
|
|
Ox.Log('FS', 'file exists, done', meta.size, total);
|
|
callback({
|
|
progress: 1,
|
|
total: total,
|
|
url: fileEntry.toURL()
|
|
})
|
|
} else {
|
|
Ox.Log('FS', 'resume from', meta.size);
|
|
partialDownload(meta.size);
|
|
}
|
|
});
|
|
}, function() {
|
|
Ox.Log('FS', 'new download');
|
|
partialDownload(0);
|
|
});
|
|
});
|
|
function getSize(url, callback) {
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open('HEAD', url, true);
|
|
xhr.addEventListener('load', function(event) {
|
|
callback(event.total);
|
|
});
|
|
xhr.addEventListener('error', function (event) {
|
|
setTimeout(function() {
|
|
getSize(url, callback);
|
|
}, 1000);
|
|
});
|
|
xhr.addEventListener('abort', function (event) {
|
|
callback({progress: -1, event: event});
|
|
});
|
|
xhr.addEventListener('timeout', function (event) {
|
|
setTimeout(function() {
|
|
getSize(url, callback);
|
|
}, 1000);
|
|
});
|
|
xhr.send();
|
|
}
|
|
function partialDownload(offset) {
|
|
var end = offset + blobSize - 1;
|
|
if (total) {
|
|
end = Math.min(end, total - 1);
|
|
}
|
|
var range = 'bytes=' + offset + '-' + end;
|
|
Ox.Log('FS', 'download part', url, offset, end, total, range);
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open('GET', url, true);
|
|
xhr.setRequestHeader('Range', range);
|
|
xhr.withCredentials = true;
|
|
xhr.responseType = 'blob';
|
|
xhr.timeout = 1000 * 60 * 5;
|
|
xhr.addEventListener('progress', function(event) {
|
|
if (event.lengthComputable) {
|
|
if (!total) {
|
|
var range = xhr.getResponseHeader('Content-Range');
|
|
total = Math.round(Ox.last(range.split('/')));
|
|
}
|
|
var progress = (event.loaded + offset) / total;
|
|
callback({
|
|
progress: progress,
|
|
request: xhr,
|
|
total: total,
|
|
cancel: function() {
|
|
xhr.abort();
|
|
}
|
|
});
|
|
}
|
|
});
|
|
xhr.addEventListener('load', function() {
|
|
var blob = xhr.response;
|
|
setTimeout(function() {
|
|
that.storeBlob(blob, partialName, function(response) {
|
|
if (offset + blob.size < total) {
|
|
partialDownload(offset + blob.size);
|
|
} else {
|
|
callback(response);
|
|
}
|
|
}, true);
|
|
});
|
|
});
|
|
xhr.addEventListener('error', function (event) {
|
|
Ox.print('partial download failed. retrying in 1 second');
|
|
//fixme. make blobSize smaller if this fails?
|
|
setTimeout(function() {
|
|
partialDownload(offset);
|
|
}, 1000);
|
|
});
|
|
xhr.addEventListener('abort', function (event) {
|
|
callback({progress: -1, event: event});
|
|
});
|
|
xhr.addEventListener('timeout', function (event) {
|
|
Ox.print('partial download, timeout');
|
|
setTimeout(function() {
|
|
partialDownload(offset);
|
|
}, 1000);
|
|
});
|
|
xhr.send();
|
|
}
|
|
};
|
|
|
|
that.getVideos = function(callback) {
|
|
var files = {};
|
|
that.fs.root.createReader().readEntries(function(results) {
|
|
var n = 0;
|
|
if (results.length) {
|
|
results.forEach(function(fileEntry) {
|
|
if (Ox.startsWith(fileEntry.name, 'partial::')) {
|
|
++n == results.length && callback(Ox.values(files).concat(Ox.values(that.downloads)));
|
|
} else {
|
|
fileEntry.getMetadata(function(meta) {
|
|
var item = fileEntry.name.split('::')[0],
|
|
resolution = parseInt(fileEntry.name.split('::')[1].split('p')[0]),
|
|
part = parseInt(fileEntry.name.split('::')[1].split('p')[1].split('.')[0]),
|
|
key = item + '::' + resolution;
|
|
if (!(that.downloads && that.downloads[item])) {
|
|
files[key] = Ox.extend(files[key] || {}, {
|
|
added: meta.modificationTime,
|
|
id: item + '::' + resolution,
|
|
item: item,
|
|
progress: 1,
|
|
resolution: resolution,
|
|
size: files[key] ? files[key].size + meta.size: meta.size
|
|
});
|
|
}
|
|
++n == results.length && callback(Ox.values(files).concat(Ox.values(that.downloads)));
|
|
});
|
|
}
|
|
});
|
|
} else {
|
|
callback(Ox.values(that.downloads));
|
|
}
|
|
});
|
|
};
|
|
|
|
that.getVideoURL = function(id, resolution, part, track) {
|
|
var name = that.getVideoName(id, resolution, part, track);
|
|
return that.local[name];
|
|
};
|
|
|
|
return that;
|
|
}());
|