lbry-desktop/js/lbry.js

351 lines
9.3 KiB
JavaScript
Raw Normal View History

2016-03-14 23:05:24 +01:00
var lbry = {
isConnected: false,
rootPath: '.',
daemonConnectionString: 'http://localhost:5279/lbryapi',
2016-03-14 23:05:24 +01:00
colors: {
primary: '#155B4A'
},
2016-08-22 21:19:04 +02:00
defaultClientSettings: {
showNsfw: false,
}
2016-03-14 23:05:24 +01:00
};
lbry.jsonrpc_call = function (connectionString, method, params, callback, errorCallback, connectFailedCallback) {
var xhr = new XMLHttpRequest;
xhr.addEventListener('load', function() {
var response = JSON.parse(xhr.responseText);
if (response.error) {
if (errorCallback) {
2016-08-08 02:57:12 +02:00
errorCallback(response.error);
}
} else if (callback) {
2016-08-08 02:57:12 +02:00
callback(response.result);
}
});
if (connectFailedCallback) {
xhr.addEventListener('error', function (e) {
connectFailedCallback(e);
});
}
xhr.open('POST', connectionString, true);
xhr.send(JSON.stringify({
'jsonrpc': '2.0',
'method': method,
'params': params,
'id': 0
2016-08-08 02:57:12 +02:00
}));
2016-03-16 22:56:51 +01:00
}
lbry.call = function (method, params, callback, errorCallback, connectFailedCallback) {
lbry.jsonrpc_call(lbry.daemonConnectionString, method, [params], callback, errorCallback, connectFailedCallback);
}
2016-03-14 23:05:24 +01:00
//core
lbry.connect = function(callback)
{
// Check every half second to see if the daemon's running.
// Returns true to callback once connected, or false if it takes too long and we give up.
function checkDaemonRunning(tryNum=0) {
lbry.daemonRunningStatus(function (runningStatus) {
if (runningStatus) {
lbry.isConnected = true;
callback(true);
} else {
2016-04-12 11:07:17 +02:00
if (tryNum <= 600) { // Move # of tries into constant or config option
setTimeout(function () {
checkDaemonRunning(tryNum + 1);
}, 500);
} else {
callback(false);
}
}
});
}
checkDaemonRunning();
2016-03-14 23:05:24 +01:00
}
lbry.daemonRunningStatus = function (callback) {
// Returns true/false whether the daemon is running (i.e. fully conncected to the network),
// or null if the AJAX connection to the daemon fails.
lbry.call('is_running', {}, callback, null, function () {
callback(null);
});
};
2016-04-14 06:40:31 +02:00
lbry.getDaemonStatus = function (callback) {
lbry.call('daemon_status', {}, callback);
};
lbry.getStartNotice = function(callback) {
lbry.call('get_start_notice', {}, callback);
}
2016-07-04 17:29:58 +02:00
lbry.checkFirstRun = function(callback) {
lbry.call('is_first_run', {}, callback);
}
lbry.getNewAddress = function(callback) {
lbry.call('get_new_address', {}, callback);
}
2016-09-02 07:34:30 +02:00
lbry.checkAddressIsMine = function(address, callback) {
lbry.call('address_is_mine', {address: address}, callback);
}
lbry.getDaemonSettings = function(callback) {
lbry.call('get_settings', {}, callback);
}
lbry.setDaemonSettings = function(settings, callback) {
lbry.call('set_settings', settings, callback);
}
lbry.setDaemonSetting = function(setting, value, callback) {
var setSettingsArgs = {};
setSettingsArgs[setting] = value;
lbry.call('set_settings', setSettingsArgs, callback)
}
2016-03-16 22:56:51 +01:00
lbry.getBalance = function(callback)
2016-03-14 23:05:24 +01:00
{
2016-03-16 22:56:51 +01:00
lbry.call("get_balance", {}, callback);
2016-03-14 23:05:24 +01:00
}
2016-07-22 17:33:05 +02:00
lbry.sendToAddress = function(amount, address, callback, errorCallback)
2016-07-19 00:40:15 +02:00
{
2016-07-22 17:33:05 +02:00
lbry.call("send_amount_to_address", { "amount" : amount, "address": address }, callback, errorCallback);
2016-07-19 00:40:15 +02:00
}
2016-03-14 23:05:24 +01:00
lbry.search = function(query, callback)
{
lbry.lighthouse.call('search', [query], callback);
2016-03-14 23:05:24 +01:00
}
lbry.resolveName = function(name, callback) {
lbry.call('resolve_name', { 'name': name }, callback, () => {
// For now, assume any error means the name was not resolved
callback(null);
});
2016-05-16 15:17:53 +02:00
}
2016-04-21 11:47:57 +02:00
lbry.getStream = function(name, callback) {
lbry.call('get', { 'name': name }, callback);
};
2016-07-29 00:02:24 +02:00
lbry.getClaimInfo = function(name, callback) {
lbry.call('get_claim_info', { name: name }, callback);
}
2016-09-16 19:45:33 +02:00
lbry.getMyClaim = function(name, callback) {
lbry.call('get_my_claim', { name: name }, callback);
}
2016-07-30 09:45:31 +02:00
lbry.getCostEstimate = function(name, callback) {
lbry.call('get_est_cost', { name: name }, callback);
}
2016-05-05 10:08:37 +02:00
lbry.getFileStatus = function(name, callback) {
lbry.call('get_lbry_file', { 'name': name }, callback);
}
2016-05-10 12:31:57 +02:00
lbry.getFilesInfo = function(callback) {
lbry.call('get_lbry_files', {}, callback);
}
lbry.startFile = function(name, callback) {
lbry.call('start_lbry_file', { name: name }, callback);
}
lbry.stopFile = function(name, callback) {
lbry.call('stop_lbry_file', { name: name }, callback);
}
lbry.deleteFile = function(name, deleteTargetFile=true, callback) {
lbry.call('delete_lbry_file', {
name: name,
delete_target_file: deleteTargetFile,
}, callback);
}
lbry.revealFile = function(path, callback) {
lbry.call('reveal', { path: path }, callback);
}
lbry.getFileInfoWhenListed = function(name, callback, timeoutCallback, tryNum=0) {
// Calls callback with file info when it appears in the list of files returned by lbry.getFilesInfo().
// If timeoutCallback is provided, it will be called if the file fails to appear.
lbry.getFilesInfo(function(filesInfo) {
for (var fileInfo of filesInfo) {
if (fileInfo.lbry_uri == name) {
callback(fileInfo);
return;
}
}
if (tryNum <= 200) {
setTimeout(function() { lbry.getFileInfoWhenListed(name, callback, timeoutCallback, tryNum + 1) }, 250);
} else if (timeoutCallback) {
timeoutCallback();
}
});
}
lbry.publish = function(params, fileListedCallback, publishedCallback, errorCallback) {
// Publishes a file.
// The optional fileListedCallback is called when the file becomes available in
// lbry.getFilesInfo() during the publish process.
// Use ES6 named arguments instead of directly passing param dict?
lbry.call('publish', params, publishedCallback, (errorInfo) => {
errorCallback({
name: fault.fault,
message: fault.faultString,
});
});
if (fileListedCallback) {
lbry.getFileInfoWhenListed(params.name, function(fileInfo) {
fileListedCallback(fileInfo);
});
}
}
lbry.getVersionInfo = function(callback) {
lbry.call('version', {}, callback);
};
lbry.checkNewVersionAvailable = function(callback) {
lbry.call('version', {}, function(versionInfo) {
var ver = versionInfo.lbrynet_version.split('.');
var maj = parseInt(ver[0]),
min = parseInt(ver[1]),
patch = parseInt(ver[2]);
var remoteVer = versionInfo.remote_lbrynet.split('.');
var remoteMaj = parseInt(remoteVer[0]),
remoteMin = parseInt(remoteVer[1]),
remotePatch = parseInt(remoteVer[2]);
2016-06-30 07:27:31 +02:00
if (maj < remoteMaj) {
var newVersionAvailable = true;
} else if (maj == remoteMaj) {
if (min < remoteMin) {
var newVersionAvailable = true;
} else if (min == remoteMin) {
var newVersionAvailable = (patch < remotePatch);
} else {
var newVersionAvailable = false;
}
} else {
var newVersionAvailable = false;
}
callback(newVersionAvailable);
}, function(err) {
if (err.fault == 'NoSuchFunction') {
// Really old daemon that can't report a version
callback(true);
}
});
}
lbry.getClientSettings = function() {
var outSettings = {};
for (let setting of Object.keys(lbry.defaultClientSettings)) {
var localStorageVal = localStorage.getItem('setting_' + setting);
outSettings[setting] = (localStorageVal === null ? lbry.defaultClientSettings[setting] : JSON.parse(localStorageVal));
}
return outSettings;
}
lbry.getClientSetting = function(setting) {
var localStorageVal = localStorage.getItem('setting_' + setting);
return (localStorageVal === null ? lbry.defaultClientSettings[setting] : JSON.parse(localStorageVal));
}
lbry.setClientSettings = function(settings) {
for (let setting of Object.keys(settings)) {
lbry.setClientSetting(setting, settings[setting]);
}
}
lbry.setClientSetting = function(setting, value) {
return localStorage.setItem('setting_' + setting, JSON.stringify(value));
}
2016-04-23 14:19:15 +02:00
lbry.reportBug = function(message, callback) {
lbry.call('upload_log', {
name_prefix: 'report',
exclude_previous: false,
force: true,
message: message
}, callback);
}
2016-03-14 23:05:24 +01:00
//utilities
lbry.formatCredits = function(amount, precision)
{
return amount.toFixed(precision || 1).replace(/\.?0+$/, '');
2016-03-14 23:05:24 +01:00
}
2016-09-01 09:28:07 +02:00
lbry.formatName = function(name) {
// Converts LBRY name to standard format (all lower case, no special characters)
return name.toLowerCase().replace(/[^a-z0-9\-]/, '');
}
2016-03-14 23:05:24 +01:00
lbry.loadJs = function(src, type, onload)
{
var lbryScriptTag = document.getElementById('lbry'),
newScriptTag = document.createElement('script'),
type = type || 'text/javascript';
2016-08-08 02:57:12 +02:00
2016-03-14 23:05:24 +01:00
newScriptTag.src = src;
newScriptTag.type = type;
if (onload)
{
newScript.onload = onload;
}
lbryScriptTag.parentNode.insertBefore(newScriptTag, lbryScriptTag);
}
lbry.imagePath = function(file)
2016-08-08 02:57:12 +02:00
{
return lbry.rootPath + '/img/' + file;
2016-03-14 23:05:24 +01:00
}
lbry.getMediaType = function(contentType, fileName) {
if (contentType) {
return /^[^/]+/.exec(contentType);
} else if (fileName) {
var dotIndex = fileName.lastIndexOf('.');
if (dotIndex == -1) {
return 'unknown';
}
var ext = fileName.substr(dotIndex + 1);
if (/^mp4|mov|m4v|flv|f4v$/i.test(ext)) {
return 'video';
} else if (/^mp3|m4a|aac|wav|flac|ogg$/i.test(ext)) {
return 'audio';
} else if (/^html|htm|pdf|odf|doc|docx|md|markdown|txt$/i.test(ext)) {
return 'document';
} else {
return 'unknown';
}
} else {
return 'unknown';
2016-05-16 10:16:40 +02:00
}
}
lbry.stop = function(callback) {
lbry.call('stop', {}, callback);
};
2016-05-16 10:16:40 +02:00