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

299 lines
9.3 KiB
JavaScript
Raw Normal View History

// @flow
import * as ACTIONS from 'constants/action_types';
2018-10-19 22:38:07 +02:00
import * as NOTIFICATION_TYPES from 'constants/subscriptions';
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';
2020-04-22 00:09:02 +02:00
import { doUpdateUnreadSubscriptions } from 'redux/actions/subscriptions';
2018-10-19 22:38:07 +02:00
import { makeSelectUnreadByChannel } from 'redux/selectors/subscriptions';
2017-04-28 17:14:44 +02:00
import {
2018-04-18 06:03:01 +02:00
Lbry,
SETTINGS,
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,
2020-05-21 17:38:28 +02:00
makeSelectClaimIsMine,
makeSelectClaimWasPurchased,
2018-04-18 06:03:01 +02:00
} from 'lbry-redux';
2020-04-24 21:12:07 +02:00
import { makeSelectCostInfoForUri, Lbryio } from 'lbryinc';
2019-08-02 23:03:26 +02:00
import { makeSelectClientSetting, selectosNotificationsEnabled, selectDaemonSettings } from 'redux/selectors/settings';
import { formatLbryUrlForWeb } from 'util/url';
import { selectFloatingUri } from 'redux/selectors/content';
const DOWNLOAD_POLL_INTERVAL = 1000;
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 = () => {
dispatch(push(formatLbryUrlForWeb(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 },
});
};
}
export function doSetFloatingUri(uri: ?string) {
return (dispatch: Dispatch) => {
dispatch({
type: ACTIONS.SET_FLOATING_URI,
data: { uri },
});
};
}
export function doCloseFloatingPlayer() {
return (dispatch: Dispatch, getState: GetState) => {
const state = getState();
const floatingUri = selectFloatingUri(state);
if (floatingUri) {
dispatch(doSetFloatingUri(null));
} else {
dispatch(doSetPlayingUri(null));
}
};
}
2020-05-21 17:38:28 +02:00
export function doPurchaseUriWrapper(uri: string, cost: number, saveFile: boolean, cb: ?(GetResponse) => 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) {
2020-05-21 17:38:28 +02:00
cb(fileInfo);
}
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();
2020-05-21 17:38:28 +02:00
const isMine = makeSelectClaimIsMine(uri)(state);
2019-08-02 08:28:14 +02:00
const fileInfo = makeSelectFileInfoForUri(uri)(state);
2019-08-02 23:03:26 +02:00
const uriIsStreamable = makeSelectUriIsStreamable(uri)(state);
const downloadingByOutpoint = selectDownloadingByOutpoint(state);
2020-05-21 17:38:28 +02:00
const claimWasPurchased = makeSelectClaimWasPurchased(uri)(state);
2019-08-02 23:03:26 +02:00
const alreadyDownloaded = fileInfo && (fileInfo.completed || (fileInfo.blobs_remaining === 0 && uriIsStreamable));
const alreadyDownloading = fileInfo && !!downloadingByOutpoint[fileInfo.outpoint];
2020-05-21 17:38:28 +02:00
if (!IS_WEB && (alreadyDownloading || alreadyDownloaded)) {
2019-08-02 23:03:26 +02:00
return;
}
const daemonSettings = selectDaemonSettings(state);
const costInfo = makeSelectCostInfoForUri(uri)(state);
const cost = (costInfo && Number(costInfo.cost)) || 0;
2020-05-21 17:38:28 +02:00
const saveFile = !IS_WEB && (!uriIsStreamable ? true : daemonSettings.save_files || saveFileOverride || cost > 0);
2019-08-02 23:03:26 +02:00
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
2020-05-21 17:38:28 +02:00
if (
!isMine &&
!fileInfo &&
!claimWasPurchased &&
(!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;
}
if (instantPurchaseEnabled) {
if (instantPurchaseMax.currency === 'LBC') {
attemptPlay(instantPurchaseMax.amount);
} else {
// Need to convert currency of instant purchase maximum before trying to play
Lbryio.getExchangeRates().then(({ LBC_USD }) => {
attemptPlay(instantPurchaseMax.amount / LBC_USD);
});
}
2019-08-02 08:28:14 +02:00
} else {
attemptPlay();
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 clearPosition(uri: string) {
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.CLEAR_CONTENT_POSITION,
data: { claimId, outpoint },
});
};
}
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 });
};
}