Rork のポッドキャストアプリを本番運用へ — expo-audio への移行・割り込みからの復帰・ダウンロード再開

// hooks/useAudioSession.ts（expo-audio 版）
import { setAudioModeAsync } from 'expo-audio';
import { useEffect } from 'react';
 
export function useAudioSession() {
  useEffect(() => {
    setAudioModeAsync({
      // バックグラウンドでも再生を継続する（iOS では UIBackgroundModes と対で必要）
      shouldPlayInBackground: true,
      // サイレントスイッチが入っていても鳴らす
      playsInSilentMode: true,
      // 他アプリの音声と混ぜない。ロック画面のコントロールを掴むためにも必要
      interruptionMode: 'doNotMix',
    }).catch((error) => {
      // 初期化に失敗しても再生自体は試みる価値がある。落とさずログに残す
      console.error('Failed to configure audio mode:', error);
    });
  }, []);
}

// components/EpisodePlayer.tsx（expo-audio 版）
import { useAudioPlayer, useAudioPlayerStatus } from 'expo-audio';
import { View, Text, Pressable } from 'react-native';
import { Episode } from '../types/podcast';
 
export function EpisodePlayer({ episode }: { episode: Episode }) {
  // ローカルにあればローカルを、なければリモートを再生する
  const source = episode.localPath ?? episode.audioUrl;
  const player = useAudioPlayer(source);
  const status = useAudioPlayerStatus(player);
 
  const toggle = () => {
    if (status.playing) {
      player.pause();
    } else {
      player.play();
    }
  };
 
  return (
    <View>
      <Text>{episode.title}</Text>
      <Pressable onPress={toggle}>
        <Text>{status.playing ? '一時停止' : '再生'}</Text>
      </Pressable>
      <Text>
        {Math.floor(status.currentTime)} / {Math.floor(status.duration ?? 0)} 秒
      </Text>
    </View>
  );
}

// lib/rssParser.ts
import xml2js from 'react-native-xml2js';
import { Episode, PodcastFeed } from '../types/podcast';
 
/**
 * RSS URL からポッドキャストフィードを取得してパースする
 * @throws ネットワークエラー・XMLパースエラー時にエラーをスロー
 */
export async function parsePodcastFeed(rssUrl: string): Promise<PodcastFeed> {
  // 1. RSS XML を取得
  const response = await fetch(rssUrl, {
    headers: {
      // ユーザーエージェントを設定しないと一部のサーバーが 403 を返す
      'User-Agent': 'PodcastApp/1.0',
    },
  });
 
  if (!response.ok) {
    throw new Error(`RSS フィードの取得に失敗しました: HTTP ${response.status}`);
  }
 
  const xmlText = await response.text();
 
  // 2. XML をパース
  const result = await new Promise<any>((resolve, reject) => {
    xml2js.parseString(
      xmlText,
      {
        normalizeTags: true,
        explicitArray: true,
        explicitCharkey: true,
      },
      (err: Error | null, parsed: any) => {
        if (err) reject(new Error(`XML のパースに失敗しました: ${err.message}`));
        else resolve(parsed);
      }
    );
  });
 
  // 3. 必要なデータを抽出
  const channel = result?.rss?.channel?.[0];
  if (!channel) {
    throw new Error('RSS フィードの形式が正しくありません');
  }
 
  const feedTitle = channel.title?.[0]?._ ?? channel.title?.[0] ?? '不明なポッドキャスト';
  const feedDescription = channel.description?.[0]?._ ?? channel.description?.[0] ?? '';
  const feedImage =
    channel['itunes:image']?.[0]?.$.href ??
    channel.image?.[0]?.url?.[0] ??
    '';
 
  // 4. エピソードを変換
  const items: any[] = channel.item ?? [];
  const episodes: Episode[] = items
    .map((item: any, index: number) => {
      const audioUrl = item.enclosure?.[0]?.$.url ?? '';
      if (!audioUrl) return null; // 音声 URL がないアイテムはスキップ
 
      const durationStr = item['itunes:duration']?.[0]?._ ?? item['itunes:duration']?.[0] ?? '0';
      const duration = parseDuration(durationStr);
 
      return {
        id: item.guid?.[0]?._ ?? item.guid?.[0] ?? `episode-${index}`,
        title: item.title?.[0]?._ ?? item.title?.[0] ?? `エピソード ${index + 1}`,
        description: stripHtml(
          item['itunes:summary']?.[0]?._ ?? item.description?.[0]?._ ?? item.description?.[0] ?? ''
        ),
        audioUrl,
        pubDate: new Date(item.pubdate?.[0] ?? Date.now()),
        duration,
        imageUrl: item['itunes:image']?.[0]?.$.href ?? feedImage,
      };
    })
    .filter((ep): ep is Episode => ep !== null);
 
  return {
    id: rssUrl,
    title: feedTitle,
    description: feedDescription,
    imageUrl: feedImage,
    rssUrl,
    episodes,
    lastUpdated: new Date(),
  };
}
 
/** HH:MM:SS または秒数の文字列を秒数（number）に変換 */
function parseDuration(raw: string): number {
  if (!raw) return 0;
  const parts = raw.split(':').map(Number);
  if (parts.length === 3) return parts[0] * 3600 + parts[1] * 60 + parts[2];
  if (parts.length === 2) return parts[0] * 60 + parts[1];
  return Number(raw) || 0;
}
 
/** HTML タグを除去してプレーンテキストにする */
function stripHtml(html: string): string {
  return html
    .replace(/<[^>]*>/g, '')
    .replace(/&amp;/g, '&')
    .replace(/&lt;/g, '<')
    .replace(/&gt;/g, '>')
    .replace(/&quot;/g, '"')
    .replace(/&#39;/g, "'")
    .trim();
}

// lib/downloadManager.ts
import * as FileSystem from 'expo-file-system';
import { Episode } from '../types/podcast';
 
// 永続的なドキュメントディレクトリに保存する（重要）
const DOWNLOAD_DIR = FileSystem.documentDirectory + 'podcasts/';
 
async function ensureDownloadDir(): Promise<void> {
  const dirInfo = await FileSystem.getInfoAsync(DOWNLOAD_DIR);
  if (!dirInfo.exists) {
    await FileSystem.makeDirectoryAsync(DOWNLOAD_DIR, { intermediates: true });
  }
}
 
/**
 * エピソードをダウンロードしてローカルパスを返す
 * @param episode ダウンロード対象のエピソード
 * @param onProgress 進捗コールバック (0.0〜1.0)
 */
export async function downloadEpisode(
  episode: Episode,
  onProgress: (progress: number) => void
): Promise<string> {
  await ensureDownloadDir();
 
  // エピソード ID からファイル名を生成（特殊文字を除去）
  const safeId = episode.id.replace(/[^a-zA-Z0-9-_]/g, '_');
  const ext = episode.audioUrl.split('.').pop()?.split('?')[0] ?? 'mp3';
  const localPath = DOWNLOAD_DIR + `${safeId}.${ext}`;
 
  // すでにダウンロード済みの場合はスキップ
  const existing = await FileSystem.getInfoAsync(localPath);
  if (existing.exists) {
    onProgress(1.0);
    return localPath;
  }
 
  const downloadResumable = FileSystem.createDownloadResumable(
    episode.audioUrl,
    localPath,
    { headers: { 'User-Agent': 'PodcastApp/1.0' } },
    (downloadProgress) => {
      const { totalBytesWritten, totalBytesExpectedToWrite } = downloadProgress;
      if (totalBytesExpectedToWrite > 0) {
        onProgress(Math.min(totalBytesWritten / totalBytesExpectedToWrite, 1.0));
      }
    }
  );
 
  const result = await downloadResumable.downloadAsync();
 
  if (!result || result.status !== 200) {
    // ダウンロード失敗時は不完全なファイルを削除
    await FileSystem.deleteAsync(localPath, { idempotent: true });
    throw new Error(`ダウンロードに失敗しました: HTTP ${result?.status ?? 'unknown'}`);
  }
 
  return result.uri;
}
 
export async function deleteEpisode(episode: Episode): Promise<void> {
  if (!episode.localPath) return;
  await FileSystem.deleteAsync(episode.localPath, { idempotent: true });
}
 
export async function getDownloadedSize(): Promise<number> {
  const dirInfo = await FileSystem.getInfoAsync(DOWNLOAD_DIR, { size: true });
  return dirInfo.exists && 'size' in dirInfo ? dirInfo.size : 0;
}

// components/DownloadButton.tsx
import React, { useState } from 'react';
import { TouchableOpacity, Text, View, StyleSheet } from 'react-native';
import { downloadEpisode, deleteEpisode } from '../lib/downloadManager';
import { Episode } from '../types/podcast';
 
interface Props {
  episode: Episode;
  onDownloadComplete: (localPath: string) => void;
  onDeleteComplete: () => void;
}
 
export function DownloadButton({ episode, onDownloadComplete, onDeleteComplete }: Props) {
  const [progress, setProgress] = useState(0);
  const [isDownloading, setIsDownloading] = useState(false);
 
  const isDownloaded = !!episode.localPath;
 
  const handleDownload = async () => {
    if (isDownloading) return;
    setIsDownloading(true);
    setProgress(0);
 
    try {
      const localPath = await downloadEpisode(episode, setProgress);
      onDownloadComplete(localPath);
    } catch (error) {
      console.error('ダウンロードエラー:', error);
    } finally {
      setIsDownloading(false);
      setProgress(0);
    }
  };
 
  const handleDelete = async () => {
    try {
      await deleteEpisode(episode);
      onDeleteComplete();
    } catch (error) {
      console.error('削除エラー:', error);
    }
  };
 
  if (isDownloading) {
    return (
      <View style={styles.progressContainer}>
        <View style={[styles.progressBar, { width: `${progress * 100}%` as any }]} />
        <Text style={styles.progressText}>{Math.round(progress * 100)}%</Text>
      </View>
    );
  }
 
  return (
    <TouchableOpacity
      onPress={isDownloaded ? handleDelete : handleDownload}
      style={[styles.button, isDownloaded && styles.downloadedButton]}
      accessibilityLabel={isDownloaded ? '保存済み・タップして削除' : 'ダウンロード'}
    >
      <Text style={styles.buttonText}>{isDownloaded ? '✓ 保存済み' : '↓ 保存'}</Text>
    </TouchableOpacity>
  );
}
 
const styles = StyleSheet.create({
  button: {
    paddingHorizontal: 12,
    paddingVertical: 6,
    borderRadius: 6,
    backgroundColor: '#f0f0f0',
  },
  downloadedButton: { backgroundColor: '#e8f5e9' },
  buttonText: { fontSize: 13, fontWeight: '600', color: '#333' },
  progressContainer: {
    width: 80, height: 24,
    backgroundColor: '#f0f0f0', borderRadius: 4,
    overflow: 'hidden', justifyContent: 'center',
  },
  progressBar: { position: 'absolute', height: '100%', backgroundColor: '#4CAF50' },
  progressText: { fontSize: 12, fontWeight: '600', color: '#333', textAlign: 'center', zIndex: 1 },
});

// SDK 53 まで
import * as FileSystem from 'expo-file-system';
 
// SDK 54 以降で、これまでの書き方をそのまま動かす場合
import * as FileSystem from 'expo-file-system/legacy';

// lib/downloadManager.ts
import * as FileSystem from 'expo-file-system/legacy';
import AsyncStorage from '@react-native-async-storage/async-storage';
import { Episode } from '../types/podcast';
 
const DOWNLOAD_DIR = FileSystem.documentDirectory + 'podcasts/';
const RESUME_KEY = (id: string) => `download:resume:${id}`;
 
type Snapshot = {
  url: string;
  fileUri: string;
  options: FileSystem.DownloadOptions;
  resumeData?: string;
};
 
/**
 * 再開可能なダウンロードを開始または再開する。
 * 中断済みのスナップショットがあればそこから継ぎ、なければ新規に始める。
 */
export async function startOrResumeDownload(
  episode: Episode,
  onProgress: (progress: number) => void
): Promise<string> {
  await ensureDownloadDir();
 
  const safeId = episode.id.replace(/[^a-zA-Z0-9-_]/g, '_');
  const ext = episode.audioUrl.split('.').pop()?.split('?')[0] ?? 'mp3';
  const localPath = DOWNLOAD_DIR + `${safeId}.${ext}`;
 
  const existing = await FileSystem.getInfoAsync(localPath);
  if (existing.exists && !(await AsyncStorage.getItem(RESUME_KEY(episode.id)))) {
    // 完了済み（中断スナップショットが残っていない = 最後まで届いた）
    onProgress(1.0);
    return localPath;
  }
 
  const onWrite = (p: FileSystem.DownloadProgressData) => {
    if (p.totalBytesExpectedToWrite > 0) {
      onProgress(Math.min(p.totalBytesWritten / p.totalBytesExpectedToWrite, 1.0));
    }
  };
 
  const saved = await AsyncStorage.getItem(RESUME_KEY(episode.id));
  const snapshot: Snapshot | null = saved ? JSON.parse(saved) : null;
 
  const downloadResumable = snapshot
    ? new FileSystem.DownloadResumable(
        snapshot.url,
        snapshot.fileUri,
        snapshot.options,
        onWrite,
        snapshot.resumeData
      )
    : FileSystem.createDownloadResumable(
        episode.audioUrl,
        localPath,
        { headers: { 'User-Agent': 'PodcastApp/1.0' } },
        onWrite
      );
 
  const result = snapshot
    ? await downloadResumable.resumeAsync()
    : await downloadResumable.downloadAsync();
 
  if (!result) {
    // 中断された。再開データを残して、次回に引き継ぐ
    await AsyncStorage.setItem(
      RESUME_KEY(episode.id),
      JSON.stringify(downloadResumable.savable())
    );
    throw new DownloadInterrupted(episode.id);
  }
 
  if (result.status !== 200 && result.status !== 206) {
    // 部分応答(206)は再開時の正常系。それ以外の異常はファイルごと捨てる
    await FileSystem.deleteAsync(localPath, { idempotent: true });
    await AsyncStorage.removeItem(RESUME_KEY(episode.id));
    throw new Error(`ダウンロードに失敗しました: HTTP ${result.status}`);
  }
 
  // 完走したのでスナップショットを消す。これが「完了」の唯一の印になる
  await AsyncStorage.removeItem(RESUME_KEY(episode.id));
  return result.uri;
}
 
export class DownloadInterrupted extends Error {
  constructor(public episodeId: string) {
    super(`Download interrupted: ${episodeId}`);
    this.name = 'DownloadInterrupted';
  }
}

// app/_layout.tsx の中で一度だけ
import { useEffect } from 'react';
import AsyncStorage from '@react-native-async-storage/async-storage';
 
export function useResumePendingDownloads() {
  useEffect(() => {
    const resumeAll = async () => {
      const keys = await AsyncStorage.getAllKeys();
      const pending = keys.filter((k) => k.startsWith('download:resume:'));
 
      // 一斉に再開すると帯域を食い合う。1本ずつ直列で戻す
      for (const key of pending) {
        const episodeId = key.replace('download:resume:', '');
        try {
          await resumeSingle(episodeId);
        } catch {
          // 1本の失敗で残りを止めない。次回起動でまた拾える
        }
      }
    };
 
    resumeAll();
  }, []);
}

/**
 * ダウンロード済みでもなく、再開待ちでもないファイルを掃除する。
 * 起動時ではなく、設定画面を開いたときなど、余裕のある場面で呼ぶ
 */
export async function sweepOrphans(knownEpisodeIds: string[]): Promise<number> {
  const files = await FileSystem.readDirectoryAsync(DOWNLOAD_DIR);
  const alive = new Set(knownEpisodeIds.map((id) => id.replace(/[^a-zA-Z0-9-_]/g, '_')));
 
  let removed = 0;
  for (const name of files) {
    const base = name.replace(/\.[^.]+$/, '');
    if (!alive.has(base)) {
      await FileSystem.deleteAsync(DOWNLOAD_DIR + name, { idempotent: true });
      removed += 1;
    }
  }
  return removed;
}

// store/playerStore.ts
import { create } from 'zustand';
import { Audio, AVPlaybackStatus } from 'expo-av';
import { Episode, PlayerState } from '../types/podcast';
 
interface PlayerStore extends PlayerState {
  sound: Audio.Sound | null;
  loadAndPlay: (episode: Episode) => Promise<void>;
  togglePlayPause: () => Promise<void>;
  seekTo: (seconds: number) => Promise<void>;
  setPlaybackRate: (rate: number) => Promise<void>;
  cleanup: () => Promise<void>;
}
 
export const usePlayerStore = create<PlayerStore>((set, get) => ({
  currentEpisode: null,
  isPlaying: false,
  position: 0,
  duration: 0,
  playbackRate: 1.0,
  sound: null,
 
  loadAndPlay: async (episode: Episode) => {
    const { sound: existingSound } = get();
 
    // 新しい音声を読み込む前に既存の Sound を必ずアンロードする
    if (existingSound) {
      await existingSound.unloadAsync();
    }
 
    // ダウンロード済みのローカルファイルがあれば優先して使う
    const audioSource = episode.localPath
      ? { uri: episode.localPath }
      : { uri: episode.audioUrl };
 
    try {
      const { sound } = await Audio.Sound.createAsync(
        audioSource,
        {
          shouldPlay: true,
          progressUpdateIntervalMillis: 500,
          rate: get().playbackRate,
        },
        (status: AVPlaybackStatus) => {
          if (!status.isLoaded) return;
 
          set({
            isPlaying: status.isPlaying,
            position: status.positionMillis / 1000,
            duration: (status.durationMillis ?? 0) / 1000,
          });
 
          if (status.didJustFinish) {
            set({ isPlaying: false, position: 0 });
          }
        }
      );
 
      set({ sound, currentEpisode: episode, isPlaying: true });
    } catch (error) {
      console.error('音声の読み込みに失敗しました:', error);
      throw new Error(`再生を開始できませんでした: ${episode.title}`);
    }
  },
 
  togglePlayPause: async () => {
    const { sound, isPlaying } = get();
    if (!sound) return;
    isPlaying ? await sound.pauseAsync() : await sound.playAsync();
  },
 
  seekTo: async (seconds: number) => {
    const { sound } = get();
    if (!sound) return;
    await sound.setPositionAsync(seconds * 1000);
  },
 
  setPlaybackRate: async (rate: number) => {
    const { sound } = get();
    set({ playbackRate: rate });
    if (sound) await sound.setRateAsync(rate, true);
  },
 
  cleanup: async () => {
    const { sound } = get();
    if (sound) {
      await sound.unloadAsync();
      set({ sound: null, currentEpisode: null, isPlaying: false });
    }
  },
}));

// hooks/useInterruptionRecovery.ts
import { useEffect, useRef } from 'react';
import { AppState, AppStateStatus } from 'react-native';
import { usePlayerStore } from '../store/playerStore';
 
export function useInterruptionRecovery() {
  // 「ユーザーが再生を意図していたか」を保持する。OS の再生状態とは別物
  const intendedToPlay = useRef(false);
 
  useEffect(() => {
    const unsubscribe = usePlayerStore.subscribe((state) => {
      // ユーザー操作による再生・一時停止のときだけ意図を更新する
      if (state.lastChangeSource === 'user') {
        intendedToPlay.current = state.isPlaying;
      }
    });
    return unsubscribe;
  }, []);
 
  useEffect(() => {
    const handleChange = async (next: AppStateStatus) => {
      if (next !== 'active') return;
 
      const { sound, isPlaying, resume } = usePlayerStore.getState();
      if (!sound) return;
 
      const status = await sound.getStatusAsync();
      if (!status.isLoaded) return;
 
      // 「鳴らすつもりだったのに、OS 側では止まっている」= 割り込みで落とされた
      if (intendedToPlay.current && !status.isPlaying && !isPlaying) {
        await resume();
      }
    };
 
    const sub = AppState.addEventListener('change', handleChange);
    return () => sub.remove();
  }, []);
}

// components/PlaybackRateSelector.tsx
import React from 'react';
import { View, TouchableOpacity, Text, StyleSheet } from 'react-native';
 
const RATES = [0.75, 1.0, 1.25, 1.5, 2.0];
 
interface Props {
  currentRate: number;
  onRateChange: (rate: number) => void;
}
 
export function PlaybackRateSelector({ currentRate, onRateChange }: Props) {
  return (
    <View style={styles.container}>
      {RATES.map((rate) => (
        <TouchableOpacity
          key={rate}
          onPress={() => onRateChange(rate)}
          style={[styles.button, currentRate === rate && styles.activeButton]}
          accessibilityLabel={`再生速度 ${rate}倍速`}
          accessibilityState={{ selected: currentRate === rate }}
        >
          <Text style={[styles.label, currentRate === rate && styles.activeLabel]}>
            {rate === 1.0 ? 'x1' : `x${rate}`}
          </Text>
        </TouchableOpacity>
      ))}
    </View>
  );
}
 
const styles = StyleSheet.create({
  container: { flexDirection: 'row', gap: 8, justifyContent: 'center', paddingVertical: 8 },
  button: { paddingHorizontal: 12, paddingVertical: 6, borderRadius: 16, backgroundColor: '#f0f0f0' },
  activeButton: { backgroundColor: '#1a73e8' },
  label: { fontSize: 13, fontWeight: '600', color: '#555' },
  activeLabel: { color: '#fff' },
});

// ❌ 状態更新のたびに永続化する
sound.setOnPlaybackStatusUpdate((status) => {
  if (!status.isLoaded) return;
  AsyncStorage.setItem(`pos:${episodeId}`, String(status.positionMillis));
});

// lib/positionStore.ts
import AsyncStorage from '@react-native-async-storage/async-storage';
 
const KEY = (id: string) => `pos:${id}`;
const SAVE_INTERVAL_MS = 5000;
// 終わり際まで聴いたエピソードは、次回は先頭から始める
const NEAR_END_THRESHOLD_MS = 30_000;
 
let lastSavedAt = 0;
 
export async function savePosition(
  episodeId: string,
  positionMillis: number,
  durationMillis: number,
  options: { force?: boolean } = {}
): Promise<void> {
  const now = Date.now();
  if (!options.force && now - lastSavedAt < SAVE_INTERVAL_MS) return;
  lastSavedAt = now;
 
  // 最後まで聴き切った扱いなら、位置を消して「完了」にする
  if (durationMillis > 0 && durationMillis - positionMillis < NEAR_END_THRESHOLD_MS) {
    await AsyncStorage.removeItem(KEY(episodeId));
    return;
  }
 
  await AsyncStorage.setItem(KEY(episodeId), String(Math.floor(positionMillis)));
}
 
export async function loadPosition(episodeId: string): Promise<number> {
  const raw = await AsyncStorage.getItem(KEY(episodeId));
  return raw ? Number(raw) : 0;
}

// app/_layout.tsx
import { AppState } from 'react-native';
import { usePlayerStore } from '../store/playerStore';
import { savePosition } from '../lib/positionStore';
 
AppState.addEventListener('change', (next) => {
  if (next === 'active') return;
 
  // 畳まれる・落とされる瞬間だけは、間引きを無視して必ず書く
  const { currentEpisode, positionMillis, durationMillis } = usePlayerStore.getState();
  if (currentEpisode) {
    savePosition(currentEpisode.id, positionMillis, durationMillis, { force: true });
  }
});

// lib/storageBudget.ts
import * as FileSystem from 'expo-file-system/legacy';
 
const DOWNLOAD_DIR = FileSystem.documentDirectory + 'podcasts/';
const BUDGET_BYTES = 1.5 * 1024 * 1024 * 1024; // 1.5GB を上限とする
 
type Entry = { path: string; size: number; lastPlayedAt: number };
 
/**
 * 上限を超えた分だけ、最後に聴いた時刻が古い順に消す。
 * 再生中のエピソードは保護する
 */
export async function evictIfOverBudget(
  entries: Entry[],
  protectedPath?: string
): Promise<string[]> {
  const total = entries.reduce((sum, e) => sum + e.size, 0);
  if (total <= BUDGET_BYTES) return [];
 
  // 古く聴いたものから捨てる。未再生(lastPlayedAt = 0)は最後まで残す
  const candidates = entries
    .filter((e) => e.path !== protectedPath && e.lastPlayedAt > 0)
    .sort((a, b) => a.lastPlayedAt - b.lastPlayedAt);
 
  const evicted: string[] = [];
  let freed = 0;
 
  for (const entry of candidates) {
    if (total - freed <= BUDGET_BYTES) break;
    await FileSystem.deleteAsync(entry.path, { idempotent: true });
    freed += entry.size;
    evicted.push(entry.path);
  }
 
  return evicted;
}

// ❌ 悪い例：再生のたびに Audio セッションを設定し直す
const playEpisode = async (episode: Episode) => {
  await Audio.setAudioModeAsync({ staysActiveInBackground: true }); // 毎回はNG
  const { sound } = await Audio.Sound.createAsync({ uri: episode.audioUrl });
};
 
// ✅ 正しい例：app/_layout.tsx の useEffect で一度だけ呼ぶ
// → useAudioSession() フックを参照

// ❌ 悪い例：前の Sound が解放されずメモリリークが起きる
const playNext = async (episode: Episode) => {
  const { sound } = await Audio.Sound.createAsync({ uri: episode.audioUrl });
  setCurrentSound(sound); // 古い sound は？
};
 
// ✅ 正しい例：新しい Sound を作る前に必ず unloadAsync する
const playNext = async (episode: Episode) => {
  if (currentSound) {
    await currentSound.unloadAsync(); // メモリ解放
  }
  const { sound } = await Audio.Sound.createAsync({ uri: episode.audioUrl });
  setCurrentSound(sound);
};

// ❌ 悪い例：OS がストレージ不足時に削除する可能性がある
const localPath = FileSystem.cacheDirectory + 'episode.mp3';
 
// ✅ 正しい例：documentDirectory を使う
// cacheDirectory は一時ファイル用。ユーザーが意図的に保存したファイルには使わない
const localPath = FileSystem.documentDirectory + 'podcasts/episode.mp3';

{
  "expo": {
    "android": {
      "permissions": [
        "FOREGROUND_SERVICE",
        "FOREGROUND_SERVICE_MEDIA_PLAYBACK"
      ]
    }
  }
}