lbry-desktop/ui/js/lbry.js

564 lines
14 KiB
JavaScript
Raw Normal View History

import lbryio from './lbryio.js';
2016-12-09 07:54:18 +01:00
import lighthouse from './lighthouse.js';
import jsonrpc from './jsonrpc.js';
2017-04-18 21:14:42 +02:00
import lbryuri from './lbryuri.js';
2017-06-06 06:21:55 +02:00
import { getLocal, getSession, setSession, setLocal } from './utils.js';
2016-12-09 07:54:18 +01:00
2017-06-06 06:21:55 +02:00
const { remote, ipcRenderer } = require('electron');
const menu = remote.require('./menu/main-menu');
let lbry = {
2017-06-06 06:21:55 +02:00
isConnected: false,
daemonConnectionString: 'http://localhost:5279/lbryapi',
pendingPublishTimeout: 20 * 60 * 1000,
defaultClientSettings: {
showNsfw: false,
showUnavailable: true,
debug: false,
useCustomLighthouseServers: false,
customLighthouseServers: [],
showDeveloperMenu: false,
language: 'en'
}
};
/**
* Records a publish attempt in local storage. Returns a dictionary with all the data needed to
* needed to make a dummy claim or file info object.
*/
2017-06-06 06:21:55 +02:00
function savePendingPublish({ name, channel_name }) {
let uri;
if (channel_name) {
uri = lbryuri.build({ name: channel_name, path: name }, false);
} else {
uri = lbryuri.build({ name: name }, false);
}
const pendingPublishes = getLocal('pendingPublishes') || [];
const newPendingPublish = {
name,
channel_name,
claim_id: 'pending_claim_' + uri,
txid: 'pending_' + uri,
nout: 0,
outpoint: 'pending_' + uri + ':0',
time: Date.now()
};
setLocal('pendingPublishes', [...pendingPublishes, newPendingPublish]);
return newPendingPublish;
}
/**
* If there is a pending publish with the given name or outpoint, remove it.
* A channel name may also be provided along with name.
*/
2017-06-06 06:21:55 +02:00
function removePendingPublishIfNeeded({ name, channel_name, outpoint }) {
function pubMatches(pub) {
return (
pub.outpoint === outpoint ||
(pub.name === name &&
(!channel_name || pub.channel_name === channel_name))
);
}
setLocal(
'pendingPublishes',
lbry.getPendingPublishes().filter(pub => !pubMatches(pub))
);
}
/**
* Gets the current list of pending publish attempts. Filters out any that have timed out and
* removes them from the list.
*/
lbry.getPendingPublishes = function() {
2017-06-06 06:21:55 +02:00
const pendingPublishes = getLocal('pendingPublishes') || [];
const newPendingPublishes = pendingPublishes.filter(
pub => Date.now() - pub.time <= lbry.pendingPublishTimeout
);
setLocal('pendingPublishes', newPendingPublishes);
return newPendingPublishes;
};
/**
* Gets a pending publish attempt by its name or (fake) outpoint. A channel name can also be
* provided along withe the name. If no pending publish is found, returns null.
*/
2017-06-06 06:21:55 +02:00
function getPendingPublish({ name, channel_name, outpoint }) {
const pendingPublishes = lbry.getPendingPublishes();
return (
pendingPublishes.find(
pub =>
pub.outpoint === outpoint ||
(pub.name === name &&
(!channel_name || pub.channel_name === channel_name))
) || null
);
}
2017-06-06 06:21:55 +02:00
function pendingPublishToDummyClaim({
channel_name,
name,
outpoint,
claim_id,
txid,
nout
}) {
return { name, outpoint, claim_id, txid, nout, channel_name };
}
2017-06-06 06:21:55 +02:00
function pendingPublishToDummyFileInfo({ name, outpoint, claim_id }) {
return { name, outpoint, claim_id, metadata: null };
}
2017-06-06 06:21:55 +02:00
lbry.call = function(
method,
params,
callback,
errorCallback,
connectFailedCallback
) {
return jsonrpc.call(
lbry.daemonConnectionString,
method,
params,
callback,
errorCallback,
connectFailedCallback
);
};
2016-03-14 23:05:24 +01:00
//core
2017-04-09 17:06:23 +02:00
lbry._connectPromise = null;
lbry.connect = function() {
2017-06-06 06:21:55 +02:00
if (lbry._connectPromise === null) {
lbry._connectPromise = new Promise((resolve, reject) => {
let tryNum = 0;
function checkDaemonStartedFailed() {
if (tryNum <= 100) {
// Move # of tries into constant or config option
setTimeout(() => {
tryNum++;
checkDaemonStarted();
}, tryNum < 50 ? 400 : 1000);
} else {
reject(new Error('Unable to connect to LBRY'));
}
}
// Check every half second to see if the daemon is accepting connections
function checkDaemonStarted() {
lbry.call(
'status',
{},
resolve,
checkDaemonStartedFailed,
checkDaemonStartedFailed
);
}
checkDaemonStarted();
});
}
return lbry._connectPromise;
};
2016-03-14 23:05:24 +01:00
lbry.checkAddressIsMine = function(address, callback) {
2017-06-06 06:21:55 +02:00
lbry.call('wallet_is_address_mine', { address: address }, callback);
};
2016-09-02 07:34:30 +02:00
lbry.sendToAddress = function(amount, address, callback, errorCallback) {
2017-06-06 06:21:55 +02:00
lbry.call(
'send_amount_to_address',
{ amount: amount, address: address },
callback,
errorCallback
);
};
2016-07-19 00:40:15 +02:00
2017-04-13 20:57:12 +02:00
/**
* Takes a LBRY URI; 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.
*/
2017-06-06 06:21:55 +02:00
lbry.costPromiseCache = {};
2017-04-18 21:14:42 +02:00
lbry.getCostInfo = function(uri) {
2017-06-06 06:21:55 +02:00
if (lbry.costPromiseCache[uri] === undefined) {
lbry.costPromiseCache[uri] = new Promise((resolve, reject) => {
const COST_INFO_CACHE_KEY = 'cost_info_cache';
let costInfoCache = getSession(COST_INFO_CACHE_KEY, {});
function cacheAndResolve(cost, includesData) {
costInfoCache[uri] = { cost, includesData };
setSession(COST_INFO_CACHE_KEY, costInfoCache);
resolve({ cost, includesData });
}
if (!uri) {
return reject(new Error(`URI required.`));
}
if (costInfoCache[uri] && costInfoCache[uri].cost) {
return resolve(costInfoCache[uri]);
}
function getCost(uri, size) {
lbry
.stream_cost_estimate({ uri, ...(size !== null ? { size } : {}) })
.then(cost => {
cacheAndResolve(cost, size !== null);
}, reject);
}
const uriObj = lbryuri.parse(uri);
const name = uriObj.path || uriObj.name;
lighthouse.get_size_for_name(name).then(size => {
if (size) {
getCost(name, size);
} else {
getCost(name, null);
}
});
});
}
return lbry.costPromiseCache[uri];
};
2016-12-09 07:54:18 +01:00
/**
* Publishes a file. The optional fileListedCallback is called when the file becomes available in
* lbry.file_list() during the publish process.
*
* This currently includes a work-around to cache the file in local storage so that the pending
* publish can appear in the UI immediately.
*/
2017-06-06 06:21:55 +02:00
lbry.publish = function(
params,
fileListedCallback,
publishedCallback,
errorCallback
) {
lbry.call(
'publish',
params,
result => {
if (returnedPending) {
return;
}
clearTimeout(returnPendingTimeout);
publishedCallback(result);
},
err => {
if (returnedPending) {
return;
}
clearTimeout(returnPendingTimeout);
errorCallback(err);
}
);
let returnedPending = false;
// Give a short grace period in case publish() returns right away or (more likely) gives an error
const returnPendingTimeout = setTimeout(() => {
returnedPending = true;
if (publishedCallback) {
savePendingPublish({
name: params.name,
channel_name: params.channel_name
});
publishedCallback(true);
}
if (fileListedCallback) {
const { name, channel_name } = params;
savePendingPublish({
name: params.name,
channel_name: params.channel_name
});
fileListedCallback(true);
}
}, 2000);
};
lbry.getClientSettings = function() {
2017-06-06 06:21:55 +02:00
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) {
2017-06-06 06:21:55 +02:00
var localStorageVal = localStorage.getItem('setting_' + setting);
if (setting == 'showDeveloperMenu') {
return true;
}
return localStorageVal === null
? lbry.defaultClientSettings[setting]
: JSON.parse(localStorageVal);
};
lbry.setClientSettings = function(settings) {
2017-06-06 06:21:55 +02:00
for (let setting of Object.keys(settings)) {
lbry.setClientSetting(setting, settings[setting]);
}
};
lbry.setClientSetting = function(setting, value) {
2017-06-06 06:21:55 +02:00
return localStorage.setItem('setting_' + setting, JSON.stringify(value));
};
2016-11-30 06:23:45 +01:00
lbry.getSessionInfo = function(callback) {
2017-06-06 06:21:55 +02:00
lbry.call('status', { session_status: true }, callback);
};
2016-04-23 14:19:15 +02:00
lbry.reportBug = function(message, callback) {
2017-06-06 06:21:55 +02:00
lbry.call(
'report_bug',
{
message: message
},
callback
);
};
2016-04-23 14:19:15 +02:00
2016-03-14 23:05:24 +01:00
//utilities
2017-06-06 06:21:55 +02:00
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) {
2017-06-06 06:21:55 +02:00
// 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-03-14 23:05:24 +01:00
2017-06-06 06:21:55 +02:00
lbry.imagePath = function(file) {
return 'img/' + file;
};
lbry.getMediaType = function(contentType, fileName) {
2017-06-06 06:21:55 +02:00
if (contentType) {
return /^[^/]+/.exec(contentType)[0];
} 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) {
2017-06-06 06:21:55 +02:00
lbry.call('stop', {}, callback);
};
2016-05-16 10:16:40 +02:00
2017-03-26 20:30:18 +02:00
lbry._subscribeIdCount = 0;
lbry._balanceSubscribeCallbacks = {};
lbry._balanceSubscribeInterval = 5000;
2017-04-21 02:31:52 +02:00
lbry._balanceUpdateInterval = null;
2017-03-26 20:30:18 +02:00
lbry._updateBalanceSubscribers = function() {
2017-06-06 06:21:55 +02:00
lbry.wallet_balance().then(function(balance) {
for (let callback of Object.values(lbry._balanceSubscribeCallbacks)) {
callback(balance);
}
});
if (
!lbry._balanceUpdateInterval &&
Object.keys(lbry._balanceSubscribeCallbacks).length
) {
lbry._balanceUpdateInterval = setInterval(() => {
lbry._updateBalanceSubscribers();
}, lbry._balanceSubscribeInterval);
}
};
2017-03-26 20:30:18 +02:00
lbry.balanceSubscribe = function(callback) {
2017-06-06 06:21:55 +02:00
const subscribeId = ++lbry._subscribeIdCount;
lbry._balanceSubscribeCallbacks[subscribeId] = callback;
lbry._updateBalanceSubscribers();
return subscribeId;
};
2017-03-26 20:30:18 +02:00
lbry.balanceUnsubscribe = function(subscribeId) {
2017-06-06 06:21:55 +02:00
delete lbry._balanceSubscribeCallbacks[subscribeId];
if (
lbry._balanceUpdateInterval &&
!Object.keys(lbry._balanceSubscribeCallbacks).length
) {
clearInterval(lbry._balanceUpdateInterval);
}
};
2016-05-16 10:16:40 +02:00
lbry.showMenuIfNeeded = function() {
2017-06-06 06:21:55 +02:00
const showingMenu = sessionStorage.getItem('menuShown') || null;
const chosenMenu = lbry.getClientSetting('showDeveloperMenu')
? 'developer'
: 'normal';
if (chosenMenu != showingMenu) {
menu.showMenubar(chosenMenu == 'developer');
}
sessionStorage.setItem('menuShown', chosenMenu);
};
2017-05-25 20:29:28 +02:00
lbry.getAppVersionInfo = function() {
2017-06-06 06:21:55 +02:00
return new Promise((resolve, reject) => {
ipcRenderer.once('version-info-received', (event, versionInfo) => {
resolve(versionInfo);
});
ipcRenderer.send('version-info-requested');
});
};
2017-04-27 08:52:14 +02:00
/**
* Wrappers for API methods to simulate missing or future behavior. Unlike the old-style stubs,
* these are designed to be transparent wrappers around the corresponding API methods.
*/
/**
* Returns results from the file_list API method, plus dummy entries for pending publishes.
* (If a real publish with the same name is found, the pending publish will be ignored and removed.)
*/
2017-06-06 06:21:55 +02:00
lbry.file_list = function(params = {}) {
return new Promise((resolve, reject) => {
const { name, channel_name, outpoint } = params;
2017-06-06 06:21:55 +02:00
/**
* If we're searching by outpoint, check first to see if there's a matching pending publish.
* Pending publishes use their own faux outpoints that are always unique, so we don't need
* to check if there's a real file.
*/
2017-06-06 06:21:55 +02:00
if (outpoint) {
const pendingPublish = getPendingPublish({ outpoint });
if (pendingPublish) {
resolve([pendingPublishToDummyFileInfo(pendingPublish)]);
return;
}
}
lbry.call(
'file_list',
params,
fileInfos => {
removePendingPublishIfNeeded({ name, channel_name, outpoint });
const dummyFileInfos = lbry
.getPendingPublishes()
.map(pendingPublishToDummyFileInfo);
resolve([...fileInfos, ...dummyFileInfos]);
},
reject,
reject
);
});
};
2017-06-06 06:21:55 +02:00
lbry.claim_list_mine = function(params = {}) {
return new Promise((resolve, reject) => {
lbry.call(
'claim_list_mine',
params,
claims => {
for (let { name, channel_name, txid, nout } of claims) {
removePendingPublishIfNeeded({
name,
channel_name,
outpoint: txid + ':' + nout
});
}
const dummyClaims = lbry
.getPendingPublishes()
.map(pendingPublishToDummyClaim);
resolve([...claims, ...dummyClaims]);
},
reject,
reject
);
});
};
2017-05-04 05:44:08 +02:00
const claimCacheKey = 'resolve_claim_cache';
2017-05-13 00:50:51 +02:00
lbry._claimCache = getSession(claimCacheKey, {});
2017-06-06 06:21:55 +02:00
lbry._resolveXhrs = {};
lbry.resolve = function(params = {}) {
return new Promise((resolve, reject) => {
if (!params.uri) {
throw __('Resolve has hacked cache on top of it that requires a URI');
}
if (params.uri && lbry._claimCache[params.uri] !== undefined) {
resolve(lbry._claimCache[params.uri]);
} else {
lbry._resolveXhrs[params.uri] = lbry.call(
'resolve',
params,
function(data) {
if (data !== undefined) {
lbry._claimCache[params.uri] = data;
}
setSession(claimCacheKey, lbry._claimCache);
resolve(data);
},
reject
);
}
});
};
2017-04-13 20:52:26 +02:00
2017-06-06 06:21:55 +02:00
lbry.cancelResolve = function(params = {}) {
const xhr = lbry._resolveXhrs[params.uri];
if (xhr && xhr.readyState > 0 && xhr.readyState < 4) {
xhr.abort();
}
};
2017-05-15 18:34:33 +02:00
lbry = new Proxy(lbry, {
2017-06-06 06:21:55 +02:00
get: function(target, name) {
if (name in target) {
return target[name];
}
return function(params = {}) {
return new Promise((resolve, reject) => {
jsonrpc.call(
lbry.daemonConnectionString,
name,
params,
resolve,
reject,
reject
);
});
};
}
});
export default lbry;