📱 Capacitor MediaStore Plugin

// Get all music files from device (including SD card)
const music = await CapacitorMediaStore.getMediasByType({
  mediaType: 'audio',
  includeExternal: true
});

console.log(`Found ${music.totalCount} songs!`);
music.media.forEach(song => {
  console.log(`${song.title} by ${song.artist}`);
});

import { CapacitorMediaStore } from '@odion-cloud/capacitor-mediastore';

// Listen for file changes
CapacitorMediaStore.addListener('mediaChanged', (event) => {
  console.log(`File ${event.type}:`, event.file);
  // event.type: 'added' | 'deleted' | 'modified'
  // event.file: { id, displayName, uri, mimeType, mediaType, ... }
});

// Start watching all media types
await CapacitorMediaStore.startWatching();

// Or watch specific types only
await CapacitorMediaStore.startWatching({
  mediaTypes: ['audio', 'image']
});

await CapacitorMediaStore.stopWatching();

async function setupAutoRefresh() {
  CapacitorMediaStore.addListener('mediaChanged', (event) => {
    if (event.file.mediaType === 'audio') {
      if (event.type === 'added') {
        console.log('New song downloaded:', event.file.displayName);
        refreshMusicLibrary();
      } else if (event.type === 'deleted') {
        console.log('Song removed:', event.file.displayName);
        removeFromLibrary(event.file.id);
      }
    }
  });
  
  await CapacitorMediaStore.startWatching({ mediaTypes: ['audio'] });
}

await CapacitorMediaStore.setMediaSession({
  title: 'Bohemian Rhapsody',
  artist: 'Queen',
  album: 'A Night at the Opera',
  artworkUrl: 'https://example.com/album-art.jpg',
  duration: 354,  // seconds
  smallIconName: 'ic_notification',  // 24dp monochrome white-on-transparent
  buttons: [
    // position: 'left' = displayed BEFORE the Previous button
    { action: 'shuffle', displayName: 'Shuffle', iconName: 'ic_shuffle',
      enabled: true, position: 'left' },
    // position: 'right' = displayed AFTER the Next button (default)
    { action: 'like', displayName: 'Like', iconName: 'ic_favorite_border',
      enabled: true, position: 'right' },
    { action: 'repeat', displayName: 'Repeat', iconName: 'ic_repeat',
      enabled: true, position: 'right' }
  ]
});

await CapacitorMediaStore.updatePlaybackState({ state: 'playing' });

CapacitorMediaStore.addListener('mediaSessionAction', (event) => {
  switch (event.action) {
    case 'play': player.play(); break;
    case 'pause': player.pause(); break;
    case 'nexttrack': player.next(); break;
    case 'previoustrack': player.previous(); break;
    case 'like': toggleLike(); break;
    case 'shuffle': toggleShuffle(); break;
    case 'repeat': toggleRepeat(); break;
    case 'seekto': player.seekTo(event.extras.seekTime); break;
  }
});

// Update position every second
setInterval(async () => {
  await CapacitorMediaStore.updatePositionState({
    position: player.getCurrentTime(),
    duration: player.getDuration(),
    playbackRate: 1.0
  });
}, 1000);

// Toggle like icon (outline → filled)
await CapacitorMediaStore.updateMediaSessionButtons({
  buttons: [
    { action: 'like', displayName: 'Unlike', iconName: 'ic_favorite',
      enabled: true, position: 'right' }
  ]
});

// Cycle repeat modes
// Mode 1: Repeat Off
await CapacitorMediaStore.updateMediaSessionButtons({
  buttons: [{ action: 'repeat', displayName: 'Repeat Off',
    iconName: 'ic_repeat', position: 'right' }]
});
// Mode 2: Repeat All
await CapacitorMediaStore.updateMediaSessionButtons({
  buttons: [{ action: 'repeat', displayName: 'Repeat All',
    iconName: 'ic_repeat_all', position: 'right' }]
});
// Mode 3: Repeat One
await CapacitorMediaStore.updateMediaSessionButtons({
  buttons: [{ action: 'repeat', displayName: 'Repeat One',
    iconName: 'ic_repeat_one', position: 'right' }]
});

await CapacitorMediaStore.destroyMediaSession();

import { CapacitorMediaStore } from '@odion-cloud/capacitor-mediastore';

// Request all permissions
const permissions = await CapacitorMediaStore.requestPermissions();

// Or request specific types only
const audioPermission = await CapacitorMediaStore.requestPermissions({
  types: ['audio']  // Only ask for music access
});

const allMedia = await CapacitorMediaStore.getMedias({
  limit: 100,              // Get first 100 files
  includeExternal: true    // Include SD card files
});

console.log(`Total files: ${allMedia.totalCount}`);

// Get all music files
const music = await CapacitorMediaStore.getMediasByType({
  mediaType: 'audio',
  sortBy: 'TITLE',
  sortOrder: 'ASC'
});

// Get all photos  
const photos = await CapacitorMediaStore.getMediasByType({
  mediaType: 'image',
  limit: 50
});

// Get all videos
const videos = await CapacitorMediaStore.getMediasByType({
  mediaType: 'video'
});

// Get documents (PDF, DOC, TXT, etc.)
const documents = await CapacitorMediaStore.getMediasByType({
  mediaType: 'document'
});

// Each file includes detailed information
music.media.forEach(song => {
  console.log('Title:', song.title);
  console.log('Artist:', song.artist);
  console.log('Album:', song.album);
  console.log('Duration:', song.duration + 'ms');
  console.log('File size:', song.size + ' bytes');
  console.log('SD Card?:', song.isExternal);
});

async function createMusicLibrary() {
  // Ask for music access
  await CapacitorMediaStore.requestPermissions({ types: ['audio'] });
  
  // Get all songs (including from SD card)
  const result = await CapacitorMediaStore.getMediasByType({
    mediaType: 'audio',
    sortBy: 'TITLE',
    includeExternal: true
  });
  
  // Create playlist
  const playlist = result.media.map(song => ({
    id: song.id,
    title: song.title || 'Unknown Song',
    artist: song.artist || 'Unknown Artist',
    album: song.album || 'Unknown Album',
    duration: song.duration || 0,
    filePath: song.uri,
    isOnSDCard: song.isExternal
  }));
  
  console.log(`Created playlist with ${playlist.length} songs`);
  return playlist;
}

async function createPhotoGallery() {
  // Ask for photo access
  await CapacitorMediaStore.requestPermissions({ types: ['images'] });
  
  // Get recent photos
  const photos = await CapacitorMediaStore.getMediasByType({
    mediaType: 'image',
    sortBy: 'DATE_ADDED',
    sortOrder: 'DESC',
    limit: 100
  });
  
  // Create gallery
  const gallery = photos.media.map(photo => ({
    id: photo.id,
    name: photo.displayName,
    size: `${photo.width}×${photo.height}`,
    fileSize: Math.round(photo.size / 1024) + ' KB',
    dateTaken: new Date(photo.dateAdded),
    thumbnailPath: photo.uri
  }));
  
  return gallery;
}

async function findSongsByArtist(artistName) {
  const songs = await CapacitorMediaStore.getMediasByType({
    mediaType: 'audio',
    artistName: artistName,  // Filter by specific artist
    sortBy: 'TITLE'
  });
  
  console.log(`Found ${songs.totalCount} songs by ${artistName}`);
  return songs.media;
}

// Usage
const beatlesSongs = await findSongsByArtist('The Beatles');
const taylorSwiftSongs = await findSongsByArtist('Taylor Swift');

async function getMusicAlbums() {
   await CapacitorMediaStore.requestPermissions({ types: ['audio'] });
   
   const albums = await CapacitorMediaStore.getAlbums();
   
   albums.albums.forEach(album => {
     console.log(`${album.name} by ${album.artist}`);
     console.log(`${album.trackCount} tracks`);
   });
   
   return albums.albums;
 }

async function saveAudioFile(audioData, fileName) {
   await CapacitorMediaStore.requestPermissions({ types: ['audio'] });
   
   const result = await CapacitorMediaStore.saveMedia({
     data: audioData,           // Base64 encoded audio data
     fileName: fileName,        // e.g., 'my-song.mp3'
     mediaType: 'audio',
     albumName: 'My Custom Album',
     relativePath: 'MyApp/Audio'  // Optional custom folder
   });
   
   if (result.success) {
     console.log('File saved successfully at:', result.uri);
     return result.uri;
   } else {
     console.error('Save failed:', result.error);
   }
 }

async function getDetailedSongInfo(fileUri) {
   const metadata = await CapacitorMediaStore.getMediaMetadata({
     filePath: fileUri
   });
   
   const song = metadata.media;
   
   console.log('🎵 Song Details:');
   console.log(`Title: ${song.title}`);
   console.log(`Artist: ${song.artist}`);
   console.log(`Album: ${song.album}`);
   console.log(`Duration: ${song.duration}ms`);
   console.log(`Bitrate: ${song.bitrate} kbps`);
   console.log(`Sample Rate: ${song.sampleRate} Hz`);
   console.log(`Channels: ${song.channels === 1 ? 'Mono' : 'Stereo'}`);
   console.log(`Genre: ${song.genre}`);
   console.log(`Year: ${song.year}`);
   
   return song;
 }