Interactive interface for browsing global, full-resolution satellite imagery
import { useEffect, useState } from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import { get as lodashGet } from 'lodash';
import util from '../../util/util';
import ErrorBoundary from '../error-boundary';
import PlayQueue from '../../components/animation-widget/play-queue';
import { promiseImageryForTime as promiseImageryForTimeUtil } from '../../modules/map/util';
import {
selectDate as selectDateAction,
selectInterval,
toggleCustomModal,
} from '../../modules/date/actions';
import {
TIME_SCALE_FROM_NUMBER,
customModalType,
} from '../../modules/date/constants';
import {
snapToIntervalDelta,
getNumberOfSteps,
} from '../../modules/animation/util';
import {
subdailyLayersActive,
getAllActiveLayers,
dateRange as getDateRange,
} from '../../modules/layers/selectors';
import { getSelectedDate } from '../../modules/date/selectors';
import {
play,
onClose as onCloseAction,
stop,
toggleLooping,
changeFrameRate,
changeStartDate,
changeEndDate,
changeStartAndEndDate,
toggleAnimationCollapse,
} from '../../modules/animation/actions';
import usePrevious from '../../util/customHooks';
import DesktopAnimationWidget from './desktop-animation-widget';
import MobileAnimationWidget from './mobile-animation-widget';
import CollapsedAnimationWidget from './collapsed-animation-widget';
import AnimationTileCheck from '../../components/kiosk/animation-tile-check/animation-tile-check';
function AnimationWidget (props) {
const {
appNow,
animationCustomModalOpen,
autoplay,
breakpoints,
checkAnimationAvailability,
currentDate,
delta,
endDate,
hasFutureLayers,
hasSubdailyLayers,
hasTempoProduct,
interval,
isActive,
isCollapsed,
isDistractionFreeModeActive,
isEmbedModeActive,
isKioskModeActive,
isLandscape,
isMobile,
isMobilePhone,
isMobileTablet,
isPlaying,
isPortrait,
looping,
minDate,
maxDate,
numberOfFrames,
onClose,
onPushLoop,
onPushPause,
onPushPlay,
onSlide,
onToggleAnimationCollapse,
onUpdateEndDate,
onUpdateStartDate,
onUpdateStartAndEndDate,
playDisabled,
promiseImageryForTime,
screenHeight,
screenWidth,
selectDate,
sliderLabel,
speedRedux,
snappedCurrentDate,
startDate,
subDailyMode,
map,
autoSelected,
layers,
} = props;
const widgetWidth = 334;
const subdailyWidgetWidth = 460;
const halfWidgetWidth = (subDailyMode ? subdailyWidgetWidth : widgetWidth) / 2;
const [widgetPosition, setWidgetPosition] = useState(
{ x: screenWidth / 2 - halfWidgetWidth, y: -25 },
);
const [collapsedWidgetPosition, setCollapsedWidgetPosition] = useState({ x: 0, y: 0 });
const [userHasMovedWidget, setUserHasMovedWidget] = useState(false);
const [speed, setSpeed] = useState(speedRedux);
const prevSubDailyMode = usePrevious(subDailyMode);
const prevHasFutureLayers = usePrevious(hasFutureLayers);
const toggleCollapse = () => {
onToggleAnimationCollapse();
};
// component did mount
useEffect(() => {
if (isEmbedModeActive) {
setWidgetPosition({ x: 10, y: 0 });
toggleCollapse();
}
if (!isPlaying && autoplay) {
onPushPlay();
}
}, []);
// component did update
useEffect(() => {
const subdailyChange = subDailyMode !== prevSubDailyMode && prevSubDailyMode !== undefined;
if (prevHasFutureLayers && !hasFutureLayers) {
onUpdateEndDate(appNow);
}
// If toggle between subdaily/daily & widget hasn't been manually moved, try to keep centered
if (subdailyChange && !userHasMovedWidget) {
const useWidth = subDailyMode ? subdailyWidgetWidth : widgetWidth;
setWidgetPosition({
x: (screenWidth / 2) - (useWidth / 2),
y: 0,
});
}
});
// Prevent drag when interacting with child elements (e.g. buttons)
// Only allow drag when targeting "background" elements
const handleDragStart = (e, data) => {
const draggableTargets = [
'wv-animation-widget',
'wv-animation-widget-header',
'wv-anim-dates-case',
'thru-label',
];
const { classList } = e.target;
return draggableTargets.some((tClass) => classList.contains(tClass));
};
const onExpandedDrag = (e, position) => {
const { x, y } = position;
setUserHasMovedWidget(true);
setWidgetPosition({ x, y });
};
const onCollapsedDrag = (e, position) => {
const { x, y } = position;
setUserHasMovedWidget(true);
setCollapsedWidgetPosition({ x, y });
};
const onLoop = () => {
onPushLoop(looping);
};
const onDateChange = ([newStartDate, newEndDate]) => {
if (newStartDate !== startDate) {
onUpdateStartDate(newStartDate);
}
if (newEndDate !== endDate) {
onUpdateEndDate(newEndDate);
}
};
/**
* Zeroes start and end animation dates to UTC 00:00:00 for predictable animation range
* subdaily intervals retain hours and minutes
*
* @method zeroDates
*
* @return {Object}
* @param {Object} JS Date - startDate
* @param {Object} JS Date - endDate
*/
const zeroDates = () => {
let startDateZeroed = new Date(startDate);
let endDateZeroed = new Date(endDate);
if (subDailyMode) {
// for subdaily, zero start and end dates to UTC HH:MM:00:00
const startMinutes = startDateZeroed.getMinutes();
const endMinutes = endDateZeroed.getMinutes();
if (!autoSelected) {
startDateZeroed.setUTCMinutes(Math.floor(startMinutes / 10) * 10);
}
startDateZeroed.setUTCSeconds(0);
startDateZeroed.setUTCMilliseconds(0);
if (!autoSelected) {
endDateZeroed.setUTCMinutes(Math.floor(endMinutes / 10) * 10);
}
endDateZeroed.setUTCSeconds(0);
endDateZeroed.setUTCMilliseconds(0);
} else {
// for nonsubdaily, zero start and end dates to UTC 00:00:00:00
startDateZeroed = util.clearTimeUTC(startDate);
endDateZeroed = util.clearTimeUTC(endDate);
}
return {
startDate: startDateZeroed,
endDate: endDateZeroed,
};
};
const onPushPlayFunc = () => {
const {
startDate: startDateZeroed,
endDate: endDateZeroed,
} = zeroDates();
onUpdateStartAndEndDate(startDateZeroed, endDateZeroed);
onPushPlay();
};
const renderPlayQueue = isPlaying
? (
<PlayQueue
isMobile={isMobile}
isLoopActive={looping}
isPlaying={isPlaying}
numberOfFrames={numberOfFrames}
snappedCurrentDate={snappedCurrentDate}
currentDate={currentDate}
startDate={startDate}
endDate={endDate}
interval={interval}
isKioskModeActive={isKioskModeActive}
delta={delta}
speed={speed}
selectDate={selectDate}
togglePlaying={onPushPause}
promiseImageryForTime={promiseImageryForTime}
onClose={onPushPause}
map={map}
autoSelected={autoSelected}
layers={layers}
/>
)
: null;
const renderAnimationTileCheck = checkAnimationAvailability
? (
<AnimationTileCheck
startDate={startDate}
endDate={endDate}
interval={interval}
delta={delta}
isPlaying={isPlaying}
/>
)
: renderPlayQueue;
const renderDesktopAnimationWidget = (
<DesktopAnimationWidget
animationCustomModalOpen={animationCustomModalOpen}
customModalType={customModalType}
isDistractionFreeModeActive={isDistractionFreeModeActive}
endDate={endDate}
handleDragStart={handleDragStart}
hasSubdailyLayers={hasSubdailyLayers}
hasTempoProduct={hasTempoProduct}
interval={interval}
isKioskModeActive={isKioskModeActive}
isPlaying={isPlaying}
looping={looping}
maxDate={maxDate}
minDate={minDate}
numberOfFrames={numberOfFrames}
onClose={onClose}
onDateChange={onDateChange}
onExpandedDrag={onExpandedDrag}
onLoop={onLoop}
onPushPause={onPushPause}
onPushPlay={onPushPlayFunc}
onSlide={onSlide}
playDisabled={playDisabled}
toggleCollapse={toggleCollapse}
setSpeed={setSpeed}
sliderLabel={sliderLabel}
speed={speed}
startDate={startDate}
subDailyMode={subDailyMode}
widgetPosition={widgetPosition}
zeroDates={zeroDates}
/>
);
const renderMobileOrDesktopWidget = isMobile
? (
<MobileAnimationWidget
breakpoints={breakpoints}
endDate={endDate}
hasSubdailyLayers={hasSubdailyLayers}
isEmbedModeActive={isEmbedModeActive}
isLandscape={isLandscape}
isMobile={isMobile}
isMobilePhone={isMobilePhone}
isMobileTablet={isMobileTablet}
isPlaying={isPlaying}
isPortrait={isPortrait}
looping={looping}
maxDate={maxDate}
minDate={minDate}
onLoop={onLoop}
onSlide={onSlide}
onUpdateEndDate={onUpdateEndDate}
onUpdateStartDate={onUpdateStartDate}
playDisabled={playDisabled}
selectDate={selectDate}
screenHeight={screenHeight}
screenWidth={screenWidth}
setSpeed={setSpeed}
sliderLabel={sliderLabel}
speed={speed}
startDate={startDate}
subDailyMode={subDailyMode}
toggleCollapse={toggleCollapse}
/>
)
: renderDesktopAnimationWidget;
const renderCollapsedAnimationWidget = isCollapsed
? (
<CollapsedAnimationWidget
isDistractionFreeModeActive={isDistractionFreeModeActive}
hasSubdailyLayers={hasSubdailyLayers}
isMobile={isMobile}
isPlaying={isPlaying}
onClose={onClose}
onPushPause={onPushPause}
playDisabled={playDisabled}
isPortrait={isPortrait}
isLandscape={isLandscape}
isMobilePhone={isMobilePhone}
isMobileTablet={isMobileTablet}
screenWidth={screenWidth}
breakpoints={breakpoints}
collapsedWidgetPosition={collapsedWidgetPosition}
handleDragStart={handleDragStart}
onCollapsedDrag={onCollapsedDrag}
onPushPlay={onPushPlayFunc}
toggleCollapse={toggleCollapse}
/>
)
: renderMobileOrDesktopWidget;
const renderWidget = () => (
<ErrorBoundary>
{renderAnimationTileCheck}
{renderCollapsedAnimationWidget}
</ErrorBoundary>
);
return isActive ? renderWidget() : null;
}
const mapStateToProps = (state) => {
const {
compare,
animation,
date,
embed,
sidebar,
modal,
config,
map,
screenSize,
ui,
proj,
layers,
} = state;
const {
startDate, endDate, speed, loop, isPlaying, isActive, isCollapsed, autoplay,
} = animation;
const {
customSelected,
autoSelected,
delta,
customDelta,
appNow,
animationCustomModalOpen,
} = date;
let {
interval,
customInterval,
} = date;
const hasSubdailyLayers = subdailyLayersActive(state);
const hasTempoProduct = layers[compare.activeString].layers.filter((layer) => layer.visible && layer.id.includes('TEMPO')).length > 0;
const activeLayersForProj = getAllActiveLayers(state);
const hasFutureLayers = activeLayersForProj.filter((layer) => layer.futureTime).length > 0;
const layerDateRange = getDateRange({}, activeLayersForProj);
const minDate = new Date(config.startDate);
let maxDate;
if (layerDateRange && layerDateRange.end > appNow) {
maxDate = layerDateRange.end;
} else {
maxDate = appNow;
}
const {
isDistractionFreeModeActive, isKioskModeActive, animationAvailabilityChecked, eic,
} = ui;
const checkAnimationAvailability = (eic === 'sa' || eic === 'da') && !animationAvailabilityChecked && isKioskModeActive && isPlaying;
const { isEmbedModeActive } = embed;
const animationIsActive = isActive &&
lodashGet(map, 'ui.selected.frameState_') &&
sidebar.activeTab !== 'download' && // No Animation when data download is active
!compare.active &&
!(modal.isOpen && modal.id === 'TOOLBAR_SNAPSHOT'); // No Animation when Image download is open
if (!hasSubdailyLayers) {
interval = interval > 3 ? 3 : interval;
customInterval = customInterval > 3 ? 3 : customInterval;
}
const useInterval = customSelected ? customInterval || 3 : interval;
const useDelta = customSelected && customDelta ? customDelta : delta;
const subDailyInterval = useInterval > 3 || autoSelected;
const subDailyMode = subDailyInterval && hasSubdailyLayers;
const maxFrames = 300;
const mobileMaxFrames = 50;
const frameLimit = screenSize.isMobileDevice ? mobileMaxFrames : maxFrames;
const numberOfFrames = getNumberOfSteps(
startDate,
endDate,
TIME_SCALE_FROM_NUMBER[useInterval],
frameLimit,
autoSelected,
layers.active.layers,
useDelta,
);
const currentDate = getSelectedDate(state);
let snappedCurrentDate;
if (numberOfFrames < frameLimit) {
snappedCurrentDate = snapToIntervalDelta(
currentDate,
startDate,
endDate,
TIME_SCALE_FROM_NUMBER[useInterval],
useDelta,
);
} else {
snappedCurrentDate = currentDate;
}
const {
isMobilePhone, screenWidth, isMobileTablet, breakpoints, screenHeight,
} = screenSize;
return {
appNow,
animationCustomModalOpen,
autoplay,
checkAnimationAvailability,
customSelected,
startDate,
endDate,
isCollapsed,
isKioskModeActive,
snappedCurrentDate,
currentDate,
minDate,
maxDate,
isActive: animationIsActive,
isDistractionFreeModeActive,
isMobile: screenSize.isMobileDevice,
isMobilePhone,
isMobileTablet,
breakpoints,
isLandscape: screenSize.orientation === 'landscape',
isPortrait: screenSize.orientation === 'portrait',
screenWidth,
screenHeight,
hasFutureLayers,
hasSubdailyLayers,
hasTempoProduct,
subDailyMode,
delta: useDelta,
interval: TIME_SCALE_FROM_NUMBER[useInterval] || 'day',
customDelta: customDelta || 1,
customInterval: customInterval || 3,
numberOfFrames,
sliderLabel: 'Frames Per Second',
speedRedux: speed,
isPlaying,
looping: loop,
map,
proj,
promiseImageryForTime: (dateArg) =>
promiseImageryForTimeUtil(state, dateArg, undefined, autoSelected),
isEmbedModeActive,
playDisabled: !screenSize.isMobileDevice
? numberOfFrames >= maxFrames || numberOfFrames === 1
: numberOfFrames >= mobileMaxFrames || numberOfFrames === 1,
autoSelected,
layers: layers.active.layers,
};
};
const mapDispatchToProps = (dispatch) => ({
selectDate: (val) => {
dispatch(selectDateAction(val));
},
onClose: () => {
dispatch(onCloseAction());
},
onPushPlay: () => {
dispatch(play());
},
onPushPause: () => {
dispatch(stop());
},
onPushLoop: () => {
dispatch(toggleLooping());
},
toggleCustomModal: (open, toggleBy) => {
dispatch(toggleCustomModal(open, toggleBy));
},
onSlide: (num) => {
dispatch(changeFrameRate(num));
},
onIntervalSelect: (delta, timeScale, customSelected) => {
dispatch(selectInterval(delta, timeScale, customSelected));
},
onUpdateStartDate(date) {
dispatch(changeStartDate(date));
},
onUpdateEndDate(date) {
dispatch(changeEndDate(date));
},
onUpdateStartAndEndDate: (startDate, endDate) => {
dispatch(changeStartAndEndDate(startDate, endDate));
},
onToggleAnimationCollapse: () => {
dispatch(toggleAnimationCollapse());
},
});
AnimationWidget.propTypes = {
appNow: PropTypes.oneOfType([PropTypes.object, PropTypes.oneOf(['null'])]),
animationCustomModalOpen: PropTypes.bool,
autoplay: PropTypes.bool,
breakpoints: PropTypes.oneOfType([PropTypes.object, PropTypes.oneOf(['null'])]),
checkAnimationAvailability: PropTypes.bool,
snappedCurrentDate: PropTypes.oneOfType([PropTypes.object, PropTypes.oneOf(['null'])]),
currentDate: PropTypes.oneOfType([PropTypes.object, PropTypes.oneOf(['null'])]),
delta: PropTypes.number,
endDate: PropTypes.oneOfType([PropTypes.object, PropTypes.oneOf(['null'])]),
hasFutureLayers: PropTypes.bool,
hasSubdailyLayers: PropTypes.bool,
hasTempoProduct: PropTypes.bool,
interval: PropTypes.string,
isActive: PropTypes.bool,
isCollapsed: PropTypes.bool,
isDistractionFreeModeActive: PropTypes.bool,
isEmbedModeActive: PropTypes.bool,
isKioskModeActive: PropTypes.bool,
isMobile: PropTypes.bool,
isMobilePhone: PropTypes.bool,
isMobileTablet: PropTypes.bool,
isPlaying: PropTypes.bool,
isPortrait: PropTypes.bool,
isLandscape: PropTypes.bool,
looping: PropTypes.bool,
map: PropTypes.oneOfType([PropTypes.object, PropTypes.oneOf(['null'])]),
maxDate: PropTypes.oneOfType([PropTypes.object, PropTypes.oneOf(['null'])]),
minDate: PropTypes.oneOfType([PropTypes.object, PropTypes.oneOf(['null'])]),
numberOfFrames: PropTypes.number,
onToggleAnimationCollapse: PropTypes.func,
onClose: PropTypes.func,
onPushLoop: PropTypes.func,
onPushPause: PropTypes.func,
onPushPlay: PropTypes.func,
onSlide: PropTypes.func,
onUpdateEndDate: PropTypes.func,
onUpdateStartAndEndDate: PropTypes.func,
onUpdateStartDate: PropTypes.func,
playDisabled: PropTypes.bool,
promiseImageryForTime: PropTypes.func,
screenHeight: PropTypes.number,
screenWidth: PropTypes.number,
selectDate: PropTypes.func,
sliderLabel: PropTypes.string,
speedRedux: PropTypes.number,
startDate: PropTypes.oneOfType([PropTypes.object, PropTypes.oneOf(['null'])]),
subDailyMode: PropTypes.bool,
autoSelected: PropTypes.bool,
layers: PropTypes.oneOfType([PropTypes.array, PropTypes.oneOf(['null'])]),
};
export default connect(
mapStateToProps,
mapDispatchToProps,
)(AnimationWidget);