Player Control

import { playMedia, getResumeInfo } from '@/services/api';

// Check for resume progress
const resumeInfo = await getResumeInfo(mediaId);

if (resumeInfo.has_progress) {
  // Ask user: Resume or Start Over?
  const shouldResume = confirm(
    `Resume from ${resumeInfo.time_str}? (${resumeInfo.progress_percent}%)`
  );
  await playMedia(mediaId, shouldResume);
} else {
  // No progress, start from beginning
  await playMedia(mediaId, false);
}

import { getResumeInfo } from '@/services/api';

const info = await getResumeInfo(movieId);

if (info.has_progress) {
  console.log(`Resume from: ${info.time_str}`);
  console.log(`${info.progress_percent}% complete`);
  
  // Show resume prompt
  const resumeUI = (
    <div>
      <p>Continue watching from {info.time_str}?</p>
      <button onClick={() => playMedia(movieId, true)}>Resume</button>
      <button onClick={() => playMedia(movieId, false)}>Start Over</button>
    </div>
  );
} else {
  console.log('No progress - fresh start');
}

import { updateWatchProgress } from '@/services/api';

// HTML5 video player
const videoElement = document.querySelector('video');

// Update progress every 5 seconds
setInterval(() => {
  if (!videoElement.paused) {
    updateWatchProgress(
      mediaId,
      videoElement.currentTime,
      videoElement.duration
    );
  }
}, 5000);

// Save on pause
videoElement.addEventListener('pause', () => {
  updateWatchProgress(
    mediaId,
    videoElement.currentTime,
    videoElement.duration
  );
});

import { clearProgress } from '@/services/api';

// Add "Start Over" button
async function handleStartOver(mediaId: number) {
  await clearProgress(mediaId);
  await playMedia(mediaId, false);
}

import { getStreamUrl } from '@/services/api';

function VideoPlayer({ mediaId }: { mediaId: number }) {
  const [streamInfo, setStreamInfo] = useState<StreamInfo | null>(null);

  useEffect(() => {
    async function loadStream() {
      const info = await getStreamUrl(mediaId);
      setStreamInfo(info);
    }
    loadStream();
  }, [mediaId]);

  if (!streamInfo) return <div>Loading...</div>;

  return (
    <video
      src={streamInfo.stream_url}
      poster={streamInfo.poster}
      controls
      autoPlay
    />
  );
}

import { getMpvStatus, getActiveMpvSessions } from '@/services/api';

// Check if specific media is playing
const status = await getMpvStatus(movieId);

if (status.is_playing) {
  console.log(`${status.title} is playing`);
  console.log(`Position: ${status.position}/${status.duration}`);
  console.log(`Paused: ${status.paused}`);
}

// List all active MPV sessions
const sessions = await getActiveMpvSessions();

sessions.forEach(session => {
  console.log(`PID ${session.pid}: ${session.title}`);
  console.log(`Started: ${new Date(session.start_time * 1000).toLocaleString()}`);
});

%APPDATA%/StreamVault/mpv_progress/{media_id}.json

local progress_file = "/path/to/progress.json"
local save_interval = 2 -- seconds

local function save_progress()
    local pos = mp.get_property_number("time-pos")
    local duration = mp.get_property_number("duration")
    local paused = mp.get_property_bool("pause") or false
    local eof = mp.get_property_bool("eof-reached") or false
    
    local data = string.format(
        '{"position":%.3f,"duration":%.3f,"paused":%s,"eof_reached":%s}',
        pos, duration,
        paused and "true" or "false",
        eof and "true" or "false"
    )
    
    local file = io.open(progress_file, "w")
    if file then
        file:write(data)
        file:close()
    end
end

mp.add_periodic_timer(save_interval, save_progress)
mp.register_event("shutdown", save_progress)

import { playWithVlc } from '@/services/api';

// User selected VLC as player
await playWithVlc(mediaId, shouldResume);

import {
  getPlayerPreference,
  setPlayerPreference,
  playMedia,
  playWithVlc
} from '@/services/api';

async function handlePlayClick(mediaId: number, resume: boolean) {
  const preference = getPlayerPreference();

  switch (preference) {
    case 'mpv':
      await playMedia(mediaId, resume);
      break;
    case 'vlc':
      await playWithVlc(mediaId, resume);
      break;
    case 'builtin':
      // Navigate to built-in player
      navigate(`/player/${mediaId}`);
      break;
    case 'ask':
      // Show player selection dialog
      showPlayerSelectionDialog(mediaId, resume);
      break;
  }
}

// Save user preference
function savePlayerChoice(choice: PlayerPreference) {
  setPlayerPreference(choice);
}

import {
  checkNeedsTranscode,
  startTranscodeStream,
  stopTranscodeStream
} from '@/services/api';

async function playVideo(filePath: string) {
  const needsTranscode = await checkNeedsTranscode(filePath);

  if (needsTranscode) {
    console.log('Video needs transcoding...');
    const { session_id, stream_url } = await startTranscodeStream(filePath);
    
    // Play transcoded stream
    videoPlayer.src = stream_url;
    
    // Cleanup on stop
    videoPlayer.addEventListener('ended', async () => {
      await stopTranscodeStream(session_id);
    });
  } else {
    // Direct playback
    videoPlayer.src = filePath;
  }
}

import { listen } from '@tauri-apps/api/event';

// MPV playback ended
const unlisten = await listen('mpv-playback-ended', (event) => {
  const { media_id } = event.payload;
  console.log(`Playback ended for media ${media_id}`);
  
  // Refresh library to show updated progress
  refreshLibrary();
});

// Cleanup
unlisten();