lbry-desktop/ui/redux/actions/content.js

302 lines
9.3 KiB
JavaScript
Raw Normal View History

// @flow
import * as SETTINGS from 'constants/settings';
2018-10-19 22:38:07 +02:00
import * as NOTIFICATION_TYPES from 'constants/subscriptions';
2018-11-03 03:17:55 +01:00
import { PAGE_SIZE } from 'constants/claim';
import * as MODALS from 'constants/modal_types';
2019-03-05 05:46:57 +01:00
// @if TARGET='app'
import { ipcRenderer } from 'electron';
2019-03-05 05:46:57 +01:00
// @endif
import { doOpenModal } from 'redux/actions/app';
2019-04-04 23:05:23 +02:00
import { push } from 'connected-react-router';
2018-10-19 22:38:07 +02:00
import { setSubscriptionLatest, doUpdateUnreadSubscriptions } from 'redux/actions/subscriptions';
import { makeSelectUnreadByChannel } from 'redux/selectors/subscriptions';
2017-04-28 17:14:44 +02:00
import {
2018-04-18 06:03:01 +02:00
ACTIONS,
Lbry,
Lbryapi,
2017-09-08 05:15:05 +02:00
makeSelectFileInfoForUri,
selectFileInfosByOutpoint,
2018-10-19 22:38:07 +02:00
makeSelectChannelForClaimUri,
parseURI,
2019-08-02 08:28:14 +02:00
doPurchaseUri,
makeSelectUriIsStreamable,
2019-08-02 23:03:26 +02:00
selectDownloadingByOutpoint,
2019-08-13 07:35:13 +02:00
makeSelectClaimForUri,
2018-04-18 06:03:01 +02:00
} from 'lbry-redux';
2019-04-24 16:02:08 +02:00
import { makeSelectCostInfoForUri } from 'lbryinc';
2019-08-02 23:03:26 +02:00
import { makeSelectClientSetting, selectosNotificationsEnabled, selectDaemonSettings } from 'redux/selectors/settings';
2019-03-28 17:53:13 +01:00
import { formatLbryUriForWeb } from 'util/uri';
const DOWNLOAD_POLL_INTERVAL = 250;
export function doUpdateLoadStatus(uri: string, outpoint: string) {
2019-03-13 06:59:07 +01:00
// Updates the loading status for a uri as it's downloading
// Calls file_list and checks the written_bytes value to see if the number has increased
// Not needed on web as users aren't actually downloading the file
// @if TARGET='app'
2019-03-18 06:09:50 +01:00
return (dispatch: Dispatch, getState: GetState) => {
const setNextStatusUpdate = () =>
setTimeout(() => {
2018-10-18 14:38:12 +02:00
// We need to check if outpoint still exists first because user are able to delete file (outpoint) while downloading.
2018-10-18 17:23:08 +02:00
// If a file is already deleted, no point to still try update load status
const byOutpoint = selectFileInfosByOutpoint(getState());
if (byOutpoint[outpoint]) {
dispatch(doUpdateLoadStatus(uri, outpoint));
}
}, DOWNLOAD_POLL_INTERVAL);
2019-03-13 06:59:07 +01:00
Lbry.file_list({
outpoint,
full_status: true,
page: 1,
page_size: 1,
}).then(result => {
const { items: fileInfos } = result;
const fileInfo = fileInfos[0];
if (!fileInfo || fileInfo.written_bytes === 0) {
// download hasn't started yet
setNextStatusUpdate();
} else if (fileInfo.completed) {
const state = getState();
// TODO this isn't going to get called if they reload the client before
// the download finished
dispatch({
type: ACTIONS.DOWNLOADING_COMPLETED,
data: {
uri,
outpoint,
fileInfo,
},
});
2018-10-19 22:38:07 +02:00
const channelUri = makeSelectChannelForClaimUri(uri, true)(state);
const { channelName } = parseURI(channelUri);
const claimName = '@' + channelName;
2018-10-19 22:38:07 +02:00
const unreadForChannel = makeSelectUnreadByChannel(channelUri)(state);
if (unreadForChannel && unreadForChannel.type === NOTIFICATION_TYPES.DOWNLOADING) {
2018-10-19 22:38:07 +02:00
const count = unreadForChannel.uris.length;
2018-08-14 15:27:29 +02:00
if (selectosNotificationsEnabled(state)) {
const notif = new window.Notification(claimName, {
body: `Posted ${fileInfo.metadata.title}${
count > 1 && count < 10 ? ` and ${count - 1} other new items` : ''
}${count > 9 ? ' and 9+ other new items' : ''}`,
silent: false,
});
notif.onclick = () => {
2019-04-04 23:05:23 +02:00
dispatch(push(formatLbryUriForWeb(uri)));
};
}
2018-10-19 22:38:07 +02:00
dispatch(doUpdateUnreadSubscriptions(channelUri, null, NOTIFICATION_TYPES.DOWNLOADED));
} else {
// If notifications are disabled(false) just return
2019-08-02 08:28:14 +02:00
if (!selectosNotificationsEnabled(getState()) || !fileInfo.written_bytes) return;
2018-10-19 22:38:07 +02:00
2019-08-13 07:35:13 +02:00
const notif = new window.Notification(__('LBRY Download Complete'), {
body: fileInfo.metadata.title,
silent: false,
});
2019-03-05 05:46:57 +01:00
// @if TARGET='app'
notif.onclick = () => {
ipcRenderer.send('focusWindow', 'main');
};
2019-03-05 05:46:57 +01:00
// @ENDIF
}
} else {
// ready to play
const { total_bytes: totalBytes, written_bytes: writtenBytes } = fileInfo;
const progress = (writtenBytes / totalBytes) * 100;
2017-06-06 23:19:12 +02:00
dispatch({
type: ACTIONS.DOWNLOADING_PROGRESSED,
data: {
uri,
outpoint,
fileInfo,
progress,
},
});
setNextStatusUpdate();
}
});
2017-06-06 23:19:12 +02:00
};
2019-03-13 06:59:07 +01:00
// @endif
}
2019-03-18 06:09:50 +01:00
export function doSetPlayingUri(uri: ?string) {
return (dispatch: Dispatch) => {
dispatch({
type: ACTIONS.SET_PLAYING_URI,
data: { uri },
});
};
}
2019-05-07 23:38:29 +02:00
export function doFetchClaimsByChannel(uri: string, page: number = 1, pageSize: number = PAGE_SIZE) {
2019-03-18 06:09:50 +01:00
return (dispatch: Dispatch) => {
2017-05-13 00:50:51 +02:00
dispatch({
type: ACTIONS.FETCH_CHANNEL_CLAIMS_STARTED,
2017-07-17 08:06:04 +02:00
data: { uri, page },
2017-06-06 23:19:12 +02:00
});
2017-05-13 00:50:51 +02:00
2019-06-11 20:15:36 +02:00
Lbry.claim_search({
channel: uri,
page,
page_size: pageSize,
valid_channel_signature: true,
2019-06-11 20:15:36 +02:00
order_by: ['release_time'],
}).then(result => {
2019-04-24 16:02:08 +02:00
const { items: claimsInChannel, page: returnedPage } = result;
2018-11-03 03:17:55 +01:00
if (claimsInChannel && claimsInChannel.length) {
if (page === 1) {
2018-11-03 03:17:55 +01:00
const latest = claimsInChannel[0];
dispatch(
setSubscriptionLatest(
{
channelName: latest.signing_channel.name,
uri: latest.signing_channel.permanent_url,
2018-11-03 03:17:55 +01:00
},
latest.permanent_url
2018-11-03 03:17:55 +01:00
)
);
}
}
dispatch({
type: ACTIONS.FETCH_CHANNEL_CLAIMS_COMPLETED,
data: {
uri,
claims: claimsInChannel || [],
page: returnedPage || undefined,
},
});
});
2017-06-06 23:19:12 +02:00
};
}
export function doPurchaseUriWrapper(uri: string, cost: number, saveFile: boolean, cb: ?() => void) {
2019-08-02 08:28:14 +02:00
return (dispatch: Dispatch, getState: () => any) => {
function onSuccess(fileInfo) {
if (saveFile) {
dispatch(doUpdateLoadStatus(uri, fileInfo.outpoint));
}
if (cb) {
cb();
}
2019-08-02 08:28:14 +02:00
}
dispatch(doPurchaseUri(uri, { costInfo: cost }, saveFile, onSuccess));
2019-08-02 08:28:14 +02:00
};
}
export function doPlayUri(
uri: string,
skipCostCheck: boolean = false,
saveFileOverride: boolean = false,
cb?: () => void
) {
2019-08-02 08:28:14 +02:00
return (dispatch: Dispatch, getState: () => any) => {
const state = getState();
const fileInfo = makeSelectFileInfoForUri(uri)(state);
2019-08-02 23:03:26 +02:00
const uriIsStreamable = makeSelectUriIsStreamable(uri)(state);
const downloadingByOutpoint = selectDownloadingByOutpoint(state);
const alreadyDownloaded = fileInfo && (fileInfo.completed || (fileInfo.blobs_remaining === 0 && uriIsStreamable));
const alreadyDownloading = fileInfo && !!downloadingByOutpoint[fileInfo.outpoint];
if (alreadyDownloading || alreadyDownloaded) {
return;
}
const daemonSettings = selectDaemonSettings(state);
const costInfo = makeSelectCostInfoForUri(uri)(state);
const cost = (costInfo && Number(costInfo.cost)) || 0;
2019-08-02 23:03:26 +02:00
const saveFile = !uriIsStreamable ? true : daemonSettings.save_files || saveFileOverride || cost > 0;
const instantPurchaseEnabled = makeSelectClientSetting(SETTINGS.INSTANT_PURCHASE_ENABLED)(state);
const instantPurchaseMax = makeSelectClientSetting(SETTINGS.INSTANT_PURCHASE_MAX)(state);
2019-08-02 08:28:14 +02:00
2019-08-02 23:03:26 +02:00
function beginGetFile() {
dispatch(doPurchaseUriWrapper(uri, cost, saveFile, cb));
2019-08-02 23:03:26 +02:00
}
2019-08-29 06:11:10 +02:00
function attemptPlay(instantPurchaseMax = null) {
2019-08-02 23:03:26 +02:00
// If you have a file_list entry, you have already purchased the file
if (!fileInfo && (!instantPurchaseMax || !instantPurchaseEnabled || cost > instantPurchaseMax)) {
2019-08-02 23:03:26 +02:00
dispatch(doOpenModal(MODALS.AFFIRM_PURCHASE, { uri }));
} else {
beginGetFile();
2019-08-02 08:28:14 +02:00
}
2019-08-02 23:03:26 +02:00
}
2019-08-02 08:28:14 +02:00
if (fileInfo && saveFile && (!fileInfo.download_path || !fileInfo.written_bytes)) {
beginGetFile();
return;
}
2019-08-02 23:03:26 +02:00
if (cost === 0 || skipCostCheck) {
beginGetFile();
2019-08-02 08:28:14 +02:00
return;
}
2019-08-02 23:03:26 +02:00
if (instantPurchaseEnabled || instantPurchaseMax.currency === 'LBC') {
2019-08-29 06:11:10 +02:00
attemptPlay(instantPurchaseMax.amount);
2019-08-02 08:28:14 +02:00
} else {
2019-08-02 23:03:26 +02:00
// Need to convert currency of instant purchase maximum before trying to play
Lbryapi.getExchangeRates().then(({ LBC_USD }) => {
attemptPlay(instantPurchaseMax.amount / LBC_USD);
});
2019-08-02 08:28:14 +02:00
}
};
}
2019-08-13 07:35:13 +02:00
export function savePosition(uri: string, position: number) {
return (dispatch: Dispatch, getState: () => any) => {
const state = getState();
const claim = makeSelectClaimForUri(uri)(state);
const { claim_id: claimId, txid, nout } = claim;
const outpoint = `${txid}:${nout}`;
dispatch({
type: ACTIONS.SET_CONTENT_POSITION,
data: { claimId, outpoint, position },
});
};
}
export function doSetContentHistoryItem(uri: string) {
2019-03-18 06:09:50 +01:00
return (dispatch: Dispatch) => {
dispatch({
type: ACTIONS.SET_CONTENT_LAST_VIEWED,
data: { uri, lastViewed: Date.now() },
});
};
}
export function doClearContentHistoryUri(uri: string) {
2019-03-18 06:09:50 +01:00
return (dispatch: Dispatch) => {
dispatch({
type: ACTIONS.CLEAR_CONTENT_HISTORY_URI,
data: { uri },
});
};
}
2018-08-01 16:06:43 +02:00
export function doClearContentHistoryAll() {
2019-03-18 06:09:50 +01:00
return (dispatch: Dispatch) => {
dispatch({ type: ACTIONS.CLEAR_CONTENT_HISTORY_ALL });
};
}
2018-08-01 16:06:43 +02:00
2019-03-18 06:09:50 +01:00
export function doSetHistoryPage(page: string) {
return (dispatch: Dispatch) => {
2018-08-01 16:06:43 +02:00
dispatch({
type: ACTIONS.SET_CONTENT_HISTORY_PAGE,
data: { page },
});
};
}