lbry-desktop/js/lbry.js

531 lines
15 KiB
JavaScript
Raw Normal View History

2016-12-09 07:54:18 +01:00
import lighthouse from './lighthouse.js';
2016-03-14 23:05:24 +01:00
var lbry = {
isConnected: false,
rootPath: '.',
daemonConnectionString: 'http://localhost:5279/lbryapi',
webUiUri: 'http://localhost:5279',
peerListTimeout: 6000,
2016-03-14 23:05:24 +01:00
colors: {
primary: '#155B4A'
},
2016-08-22 21:19:04 +02:00
defaultClientSettings: {
showNsfw: false,
showUnavailable: true,
2016-12-29 10:17:10 +01:00
debug: false,
useCustomLighthouseServers: false,
customLighthouseServers: [],
2016-08-22 21:19:04 +02:00
}
2016-03-14 23:05:24 +01:00
};
lbry.jsonrpc_call = function (connectionString, method, params, callback, errorCallback, connectFailedCallback, timeout) {
var xhr = new XMLHttpRequest;
if (typeof connectFailedCallback !== 'undefined') {
if (timeout) {
xhr.timeout = timeout;
}
xhr.addEventListener('error', function (e) {
connectFailedCallback(e);
});
xhr.addEventListener('timeout', function() {
connectFailedCallback(new Error('XMLHttpRequest connection timed out'));
})
}
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 {
2016-10-22 11:22:44 +02:00
var errorEvent = new CustomEvent('unhandledError', {
detail: {
connectionString: connectionString,
method: method,
params: params,
2016-10-26 08:52:53 +02:00
code: response.error.code,
message: response.error.message,
data: response.error.data
}
});
document.dispatchEvent(errorEvent)
}
} else if (callback) {
2016-08-08 02:57:12 +02:00
callback(response.result);
}
});
2016-10-22 11:22:44 +02:00
if (connectFailedCallback) {
xhr.addEventListener('error', function (event) {
connectFailedCallback(event);
});
} else {
xhr.addEventListener('error', function (event) {
var errorEvent = new CustomEvent('unhandledError', {
detail: {
connectionString: connectionString,
method: method,
params: params,
code: xhr.status,
message: 'Connection to API server failed'
}
});
document.dispatchEvent(errorEvent);
});
}
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 is accepting connections
// Once this returns True, can call getDaemonStatus to see where
// we are in the startup process
function checkDaemonStarted(tryNum=0) {
lbry.isDaemonAcceptingConnections(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 () {
checkDaemonStarted(tryNum + 1);
}, 500);
} else {
callback(false);
}
}
});
}
checkDaemonStarted();
2016-03-14 23:05:24 +01:00
}
lbry.isDaemonAcceptingConnections = function (callback) {
// Returns true/false whether the daemon is at a point it will start returning status
lbry.call('status', {}, () => callback(true), null, () => callback(false))
};
2016-04-14 06:40:31 +02:00
lbry.getDaemonStatus = function (callback) {
lbry.call('daemon_status', {}, 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);
}
lbry.checkAddressIsMine = function(address, callback) {
2016-09-02 07:34:30 +02:00
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
}
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('claim_list_mine', {}, (claims) => {
callback(claims.find((claim) => claim.name == name) || null);
});
2016-09-16 19:45:33 +02:00
}
lbry.getKeyFee = function(name, callback, errorCallback) {
lbry.call('stream_cost_estimate', { name: name }, callback, errorCallback);
2016-07-30 09:45:31 +02:00
}
lbry.getTotalCost = function(name, size, callback, errorCallback) {
lbry.call('stream_cost_estimate', {
name: name,
size: size,
}, callback, errorCallback);
}
2016-12-07 22:29:04 +01:00
lbry.getPeersForBlobHash = function(blobHash, callback) {
let timedOut = false;
const timeout = setTimeout(() => {
timedOut = true;
callback([]);
}, lbry.peerListTimeout);
lbry.call('peer_list', { blob_hash: blobHash }, function(peers) {
if (!timedOut) {
clearTimeout(timeout);
callback(peers);
}
});
2016-12-07 22:29:04 +01:00
}
lbry.getCostInfoForName = function(name, callback, errorCallback) {
2016-12-09 07:54:18 +01:00
/**
* Takes a LBRY name; will first try and calculate a total cost using
* Lighthouse. If Lighthouse can't be reached, it just retrives the
* key fee.
*
* Returns an object with members:
* - cost: Number; the calculated cost of the name
* - includes_data: Boolean; indicates whether or not the data fee info
* from Lighthouse is included.
*/
function getCostWithData(name, size, callback, errorCallback) {
2016-12-09 07:54:18 +01:00
lbry.getTotalCost(name, size, (cost) => {
callback({
cost: cost,
includesData: true,
});
}, errorCallback);
2016-12-09 07:54:18 +01:00
}
function getCostNoData(name, callback, errorCallback) {
2016-12-09 07:54:18 +01:00
lbry.getKeyFee(name, (cost) => {
callback({
cost: cost,
includesData: false,
});
}, errorCallback);
2016-12-09 07:54:18 +01:00
}
lighthouse.getSizeForName(name, (size) => {
getCostWithData(name, size, callback, errorCallback);
2016-12-09 07:54:18 +01:00
}, () => {
getCostNoData(name, callback, errorCallback);
2016-12-09 07:54:18 +01:00
}, () => {
getCostNoData(name, callback, errorCallback);
2016-12-09 07:54:18 +01:00
});
}
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.getFileInfoByName = function(name, callback) {
lbry.call('get_lbry_file', {name: name}, callback);
}
lbry.getFileInfoBySdHash = function(sdHash, callback) {
lbry.call('get_lbry_file', {sd_hash: sdHash}, callback);
}
lbry.getFileInfoByFilename = function(filename, callback) {
lbry.call('get_lbry_file', {file_name: filename}, callback);
}
2016-11-09 12:27:07 +01:00
lbry.getMyClaims = function(callback) {
lbry.call('get_name_claims', {}, 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.removeFile = function(sdHash, name, deleteTargetFile=true, callback) { // Name param is temporary until the API can delete by unique ID (SD hash, claim ID etc.)
this._removedFiles.push(sdHash);
this._updateSubscribedFileInfo(sdHash);
lbry.call('delete_lbry_file', {
name: name,
delete_target_file: deleteTargetFile,
}, callback);
}
lbry.openFile = function(sdHash, callback) {
lbry.call('open', {sd_hash: sdHash}, callback);
}
lbry.revealFile = function(sdHash, callback) {
lbry.call('reveal', {sd_hash: sdHash}, 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(fileInfos) {
for (var fileInfo of fileInfos) {
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?
2017-01-18 04:37:24 +01:00
lbry.call('publish', params, publishedCallback, errorCallback);
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-11-30 06:23:45 +01:00
lbry.getSessionInfo = function(callback) {
lbry.call('get_lbry_session_info', {}, callback);
}
2016-04-23 14:19:15 +02:00
lbry.reportBug = function(message, callback) {
lbry.call('report_bug', {
2016-04-23 14:19:15 +02:00
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, spaces replaced by dashes)
name = name.replace('/\s+/g', '-');
name = name.toLowerCase().replace(/[^a-z0-9\-]/g, '');
return name;
2016-09-01 09:28:07 +02:00
}
2016-11-18 10:00:03 +01:00
lbry.nameIsValid = function(name, checkCase=true) {
const regexp = new RegExp('^[a-z0-9-]+$', checkCase ? '' : 'i');
return regexp.test(name);
}
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)
{
2016-11-22 21:28:16 +01:00
newScriptTag.onload = onload;
2016-03-14 23:05:24 +01:00
}
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
lbry.fileInfo = {};
lbry._fileInfoSubscribeIdCounter = 0;
lbry._fileInfoSubscribeCallbacks = {};
lbry._fileInfoSubscribeInterval = 5000;
lbry._removedFiles = [];
lbry._claimIdOwnershipCache = {}; // should be claimId!!! But not
lbry._updateClaimOwnershipCache = function(claimId) {
lbry.getMyClaims((claimInfos) => {
lbry._claimIdOwnershipCache[claimId] = !!claimInfos.reduce(function(match, claimInfo) {
return match || claimInfo.claim_id == claimId;
});
});
};
2017-01-13 23:18:37 +01:00
lbry._updateSubscribedFileInfo = function(sdHash) {
const callSubscribedCallbacks = (sdHash, fileInfo) => {
for (let [subscribeId, callback] of Object.entries(this._fileInfoSubscribeCallbacks[sdHash])) {
callback(fileInfo);
}
}
if (lbry._removedFiles.includes(sdHash)) {
callSubscribedCallbacks(sdHash, false);
} else {
lbry.getFileInfoBySdHash(sdHash, (fileInfo) => {
if (fileInfo) {
if (this._claimIdOwnershipCache[fileInfo.claim_id] === undefined) {
this._updateClaimOwnershipCache(fileInfo.claim_id);
}
fileInfo.isMine = !!this._claimIdOwnershipCache[fileInfo.claim_id];
}
callSubscribedCallbacks(sdHash, fileInfo);
});
}
2017-01-13 23:18:37 +01:00
if (Object.keys(this._fileInfoSubscribeCallbacks[sdHash]).length) {
2017-01-13 05:05:43 +01:00
setTimeout(() => {
this._updateSubscribedFileInfo(sdHash);
2017-01-13 05:05:43 +01:00
}, lbry._fileInfoSubscribeInterval);
}
}
2017-01-13 23:18:37 +01:00
lbry.fileInfoSubscribe = function(sdHash, callback) {
if (!lbry._fileInfoSubscribeCallbacks[sdHash])
{
2017-01-13 23:18:37 +01:00
lbry._fileInfoSubscribeCallbacks[sdHash] = {};
}
const subscribeId = ++lbry._fileInfoSubscribeIdCounter;
2017-01-13 23:18:37 +01:00
lbry._fileInfoSubscribeCallbacks[sdHash][subscribeId] = callback;
lbry._updateSubscribedFileInfo(sdHash);
return subscribeId;
}
lbry.fileInfoUnsubscribe = function(name, subscribeId) {
2017-01-13 05:05:43 +01:00
delete lbry._fileInfoSubscribeCallbacks[name][subscribeId];
}
2016-05-16 10:16:40 +02:00
export default lbry;