tunzo-player 1.0.6 → 1.0.8

package/README.md

@@ -76,3 +76,4 @@ yarn add tunzo-player
 | 3     | High (160kbps)    |
 | 4     | Ultra (320kbps)   |
 
+# tunzo-player

package/dist/core/player.d.ts

@@ -9,27 +9,31 @@ export declare class Player {
     private static queue;
     private static playlist;
     private static selectedQuality;
-    /** Initialize with playlist and quality */
-    static initialize(playlist: any[], quality?: number): void;
-    static play(song: any, index?: number): void;
-    static pause(): void;
-    static resume(): void;
-    static togglePlayPause(): void;
-    static next(): void;
-    static prev(): void;
-    static seek(seconds: number): void;
-    static autoNext(): void;
-    static playRandom(): void;
+    private static isInitialized;
+    static initialize(playlist?: any[], quality?: number): void;
+    static play(song: any, index?: number): Promise<void>;
+    private static setupMusicControls;
+    static pause(): Promise<void>;
+    static resume(): Promise<void>;
+    static stop(): Promise<void>;
+    static togglePlayPause(): Promise<void>;
+    static next(): Promise<void>;
+    static prev(): Promise<void>;
+    static autoNext(): Promise<void>;
+    static playRandom(): Promise<void>;
     static toggleShuffle(): void;
     static addToQueue(song: any): void;
     static removeFromQueue(index: number): void;
     static reorderQueue(from: number, to: number): void;
+    static seekTo(seconds: number): Promise<void>;
     static getCurrentTime(): number;
     static getDuration(): number;
-    static formatTime(time: number): string;
+    static formatTime(t: number): string;
     static isPlayingSong(): boolean;
     static getCurrentSong(): any;
     static setQuality(index: number): void;
     static getQueue(): any[];
     static getPlaylist(): any[];
+    static getShuffleStatus(): boolean;
+    static destroy(): Promise<void>;
 }

package/dist/core/player.js

@@ -1,108 +1,189 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Player = void 0;
+const core_1 = require("@capacitor/core");
+const capacitor_music_controls_plugin_1 = require("capacitor-music-controls-plugin");
 class Player {
-    /** Initialize with playlist and quality */
-    static initialize(playlist, quality = 3) {
-        this.playlist = playlist;
+    static initialize(playlist = [], quality = 3) {
+        if (!core_1.Capacitor.isNativePlatform()) {
+            this.audio = new Audio();
+        }
+        this.playlist = [...playlist];
         this.selectedQuality = quality;
-    }
-    static play(song, index = 0) {
-        var _a;
-        if (!song || !song.downloadUrl)
-            return;
-        this.currentSong = song;
-        this.currentIndex = index;
-        this.audio.src = ((_a = song.downloadUrl[this.selectedQuality]) === null || _a === void 0 ? void 0 : _a.url) || '';
-        this.audio.play();
-        this.isPlaying = true;
-        // Set duration
-        this.audio.onloadedmetadata = () => {
-            this.duration = this.audio.duration;
-        };
-        // Set current time
-        this.audio.ontimeupdate = () => {
-            this.currentTime = this.audio.currentTime;
-        };
-        // Auto-play next song
-        this.audio.onended = () => {
-            this.autoNext();
-        };
+        this.isInitialized = true;
+    }
+    static play(song_1) {
+        return __awaiter(this, arguments, void 0, function* (song, index = 0) {
+            var _a, _b;
+            if (!this.isInitialized)
+                return;
+            if (!(song === null || song === void 0 ? void 0 : song.downloadUrl))
+                return;
+            yield this.stop();
+            this.currentSong = song;
+            this.currentIndex = index;
+            const url = ((_a = song.downloadUrl[this.selectedQuality]) === null || _a === void 0 ? void 0 : _a.url) || ((_b = song.downloadUrl[0]) === null || _b === void 0 ? void 0 : _b.url);
+            if (!url)
+                return;
+            if (!this.audio)
+                this.audio = new Audio();
+            this.audio.src = url;
+            this.audio.play().catch(console.error);
+            this.audio.onloadedmetadata = () => this.duration = this.audio.duration;
+            this.audio.ontimeupdate = () => this.currentTime = this.audio.currentTime;
+            this.audio.onended = () => this.autoNext();
+            yield this.setupMusicControls(song, true);
+            this.isPlaying = true;
+        });
+    }
+    static setupMusicControls(song, isPlaying) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!core_1.Capacitor.isNativePlatform())
+                return;
+            yield capacitor_music_controls_plugin_1.CapacitorMusicControls.destroy(); // clear existing
+            yield capacitor_music_controls_plugin_1.CapacitorMusicControls.create({
+                track: song.name || '',
+                artist: song.primaryArtists || '',
+                album: song.album || '',
+                cover: song.image || '',
+                isPlaying,
+                dismissable: true,
+                hasPrev: true,
+                hasNext: true,
+            });
+            capacitor_music_controls_plugin_1.CapacitorMusicControls.addListener('music-controls-next', () => this.next());
+            capacitor_music_controls_plugin_1.CapacitorMusicControls.addListener('music-controls-previous', () => this.prev());
+            capacitor_music_controls_plugin_1.CapacitorMusicControls.addListener('music-controls-pause', () => this.pause());
+            capacitor_music_controls_plugin_1.CapacitorMusicControls.addListener('music-controls-play', () => this.resume());
+            capacitor_music_controls_plugin_1.CapacitorMusicControls.addListener('music-controls-destroy', () => this.stop());
+        });
     }
     static pause() {
-        this.audio.pause();
-        this.isPlaying = false;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.audio)
+                this.audio.pause();
+            this.isPlaying = false;
+            core_1.Capacitor.isNativePlatform() && capacitor_music_controls_plugin_1.CapacitorMusicControls.updateIsPlaying({ isPlaying: false });
+        });
     }
     static resume() {
-        this.audio.play();
-        this.isPlaying = true;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.audio)
+                yield this.audio.play();
+            this.isPlaying = true;
+            core_1.Capacitor.isNativePlatform() && capacitor_music_controls_plugin_1.CapacitorMusicControls.updateIsPlaying({ isPlaying: true });
+        });
+    }
+    static stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.audio) {
+                this.audio.pause();
+                this.audio.src = '';
+            }
+            this.isPlaying = false;
+            yield capacitor_music_controls_plugin_1.CapacitorMusicControls.destroy();
+        });
     }
     static togglePlayPause() {
-        if (this.isPlaying) {
-            this.pause();
-        }
-        else {
-            this.resume();
-        }
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isPlaying) {
+                yield this.pause();
+            }
+            else if (this.currentSong) {
+                yield this.resume();
+            }
+            else if (this.playlist.length > 0) {
+                yield this.play(this.playlist[0], 0);
+            }
+        });
     }
     static next() {
-        if (this.queue.length > 0) {
-            const nextQueued = this.queue.shift();
-            const index = this.playlist.findIndex(s => s.id === nextQueued.id);
-            this.play(nextQueued, index);
-        }
-        else if (this.isShuffle) {
-            this.playRandom();
-        }
-        else if (this.currentIndex < this.playlist.length - 1) {
-            this.play(this.playlist[this.currentIndex + 1], this.currentIndex + 1);
-        }
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.queue.length > 0) {
+                const next = this.queue.shift();
+                const index = this.playlist.findIndex(s => s.id === next.id);
+                yield this.play(next, index);
+            }
+            else if (this.isShuffle) {
+                yield this.playRandom();
+            }
+            else if (this.currentIndex < this.playlist.length - 1) {
+                yield this.play(this.playlist[this.currentIndex + 1], this.currentIndex + 1);
+            }
+        });
     }
     static prev() {
-        if (this.currentIndex > 0) {
-            this.play(this.playlist[this.currentIndex - 1], this.currentIndex - 1);
-        }
-    }
-    static seek(seconds) {
-        this.audio.currentTime = seconds;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.currentTime > 3) {
+                yield this.seekTo(0);
+            }
+            else if (this.currentIndex > 0) {
+                yield this.play(this.playlist[this.currentIndex - 1], this.currentIndex - 1);
+            }
+        });
     }
     static autoNext() {
-        this.next();
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.next();
+        });
     }
     static playRandom() {
-        if (this.playlist.length <= 1)
-            return;
-        let randomIndex;
-        do {
-            randomIndex = Math.floor(Math.random() * this.playlist.length);
-        } while (randomIndex === this.currentIndex);
-        this.play(this.playlist[randomIndex], randomIndex);
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.playlist.length <= 1)
+                return;
+            let rand = this.currentIndex;
+            while (rand === this.currentIndex) {
+                rand = Math.floor(Math.random() * this.playlist.length);
+            }
+            yield this.play(this.playlist[rand], rand);
+        });
     }
     static toggleShuffle() {
         this.isShuffle = !this.isShuffle;
     }
     static addToQueue(song) {
-        if (!this.queue.some(q => q.id === song.id)) {
+        if (!this.queue.find(s => s.id === song.id)) {
             this.queue.push(song);
         }
     }
     static removeFromQueue(index) {
-        this.queue.splice(index, 1);
+        if (index >= 0 && index < this.queue.length) {
+            this.queue.splice(index, 1);
+        }
     }
     static reorderQueue(from, to) {
-        const item = this.queue.splice(from, 1)[0];
+        if (from === to)
+            return;
+        const [item] = this.queue.splice(from, 1);
         this.queue.splice(to, 0, item);
     }
+    static seekTo(seconds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.audio) {
+                this.audio.currentTime = seconds;
+                this.currentTime = seconds;
+            }
+        });
+    }
     static getCurrentTime() {
         return this.currentTime;
     }
     static getDuration() {
         return this.duration;
     }
-    static formatTime(time) {
-        const minutes = Math.floor(time / 60);
-        const seconds = Math.floor(time % 60);
-        return `${minutes}:${seconds < 10 ? '0' : ''}${seconds}`;
+    static formatTime(t) {
+        const m = Math.floor(t / 60);
+        const s = Math.floor(t % 60);
+        return `${m}:${s < 10 ? '0' : ''}${s}`;
     }
     static isPlayingSong() {
         return this.isPlaying;
@@ -114,20 +195,33 @@ class Player {
         this.selectedQuality = index;
     }
     static getQueue() {
-        return this.queue;
+        return [...this.queue];
     }
     static getPlaylist() {
-        return this.playlist;
+        return [...this.playlist];
+    }
+    static getShuffleStatus() {
+        return this.isShuffle;
+    }
+    static destroy() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.stop();
+            this.playlist = [];
+            this.queue = [];
+            this.audio = null;
+            this.isInitialized = false;
+        });
     }
 }
 exports.Player = Player;
-Player.audio = new Audio();
+Player.audio = null;
 Player.currentSong = null;
 Player.currentIndex = 0;
 Player.isPlaying = false;
 Player.currentTime = 0;
 Player.duration = 0;
-Player.isShuffle = true;
+Player.isShuffle = false;
 Player.queue = [];
 Player.playlist = [];
 Player.selectedQuality = 3;
+Player.isInitialized = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tunzo-player",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "A music playback service for Angular and Ionic apps with native audio control support.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,5 +18,12 @@
   "license": "MIT",
   "publishConfig": {
     "access": "public"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "@capacitor-community/native-audio": "^7.0.0",
+    "capacitor-music-controls-plugin": "^6.1.0"
   }
 }

package/src/core/player.ts

@@ -1,152 +1,214 @@
+import { Capacitor } from '@capacitor/core';
+import { CapacitorMusicControls } from 'capacitor-music-controls-plugin';
+
 export class Player {
-    private static audio = new Audio();
-    private static currentSong: any = null;
-    private static currentIndex = 0;
-    private static isPlaying = false;
-    private static currentTime = 0;
-    private static duration = 0;
-    private static isShuffle = true;
-    private static queue: any[] = [];
-    private static playlist: any[] = [];
-    private static selectedQuality = 3;
-  
-    /** Initialize with playlist and quality */
-    static initialize(playlist: any[], quality = 3) {
-      this.playlist = playlist;
-      this.selectedQuality = quality;
-    }
-  
-    static play(song: any, index: number = 0) {
-      if (!song || !song.downloadUrl) return;
-  
-      this.currentSong = song;
-      this.currentIndex = index;
-      this.audio.src = song.downloadUrl[this.selectedQuality]?.url || '';
-      this.audio.play();
-      this.isPlaying = true;
-  
-      // Set duration
-      this.audio.onloadedmetadata = () => {
-        this.duration = this.audio.duration;
-      };
-  
-      // Set current time
-      this.audio.ontimeupdate = () => {
-        this.currentTime = this.audio.currentTime;
-      };
-  
-      // Auto-play next song
-      this.audio.onended = () => {
-        this.autoNext();
-      };
-    }
-  
-    static pause() {
+  private static audio: HTMLAudioElement | null = null;
+  private static currentSong: any = null;
+  private static currentIndex = 0;
+  private static isPlaying = false;
+  private static currentTime = 0;
+  private static duration = 0;
+  private static isShuffle = false;
+  private static queue: any[] = [];
+  private static playlist: any[] = [];
+  private static selectedQuality = 3;
+  private static isInitialized = false;
+
+  static initialize(playlist: any[] = [], quality = 3) {
+    if (!Capacitor.isNativePlatform()) {
+      this.audio = new Audio();
+    }
+    this.playlist = [...playlist];
+    this.selectedQuality = quality;
+    this.isInitialized = true;
+  }
+
+  static async play(song: any, index = 0) {
+    if (!this.isInitialized) return;
+    if (!song?.downloadUrl) return;
+
+    await this.stop();
+
+    this.currentSong = song;
+    this.currentIndex = index;
+    const url = song.downloadUrl[this.selectedQuality]?.url || song.downloadUrl[0]?.url;
+
+    if (!url) return;
+
+    if (!this.audio) this.audio = new Audio();
+
+    this.audio.src = url;
+    this.audio.play().catch(console.error);
+
+    this.audio.onloadedmetadata = () => this.duration = this.audio!.duration;
+    this.audio.ontimeupdate = () => this.currentTime = this.audio!.currentTime;
+    this.audio.onended = () => this.autoNext();
+
+    await this.setupMusicControls(song, true);
+
+    this.isPlaying = true;
+  }
+
+  private static async setupMusicControls(song: any, isPlaying: boolean) {
+    if (!Capacitor.isNativePlatform()) return;
+
+    await CapacitorMusicControls.destroy(); // clear existing
+    await CapacitorMusicControls.create({
+      track: song.name || '',
+      artist: song.primaryArtists || '',
+      album: song.album || '',
+      cover: song.image || '',
+      isPlaying,
+      dismissable: true,
+      hasPrev: true,
+      hasNext: true,
+    });
+
+    CapacitorMusicControls.addListener('music-controls-next', () => this.next());
+    CapacitorMusicControls.addListener('music-controls-previous', () => this.prev());
+    CapacitorMusicControls.addListener('music-controls-pause', () => this.pause());
+    CapacitorMusicControls.addListener('music-controls-play', () => this.resume());
+    CapacitorMusicControls.addListener('music-controls-destroy', () => this.stop());
+  }
+
+  static async pause() {
+    if (this.audio) this.audio.pause();
+    this.isPlaying = false;
+    Capacitor.isNativePlatform() && CapacitorMusicControls.updateIsPlaying({ isPlaying: false });
+
+  }
+
+  static async resume() {
+    if (this.audio) await this.audio.play();
+    this.isPlaying = true;
+    Capacitor.isNativePlatform() && CapacitorMusicControls.updateIsPlaying({ isPlaying: true });
+
+  }
+
+  static async stop() {
+    if (this.audio) {
       this.audio.pause();
-      this.isPlaying = false;
-    }
-  
-    static resume() {
-      this.audio.play();
-      this.isPlaying = true;
-    }
-  
-    static togglePlayPause() {
-      if (this.isPlaying) {
-        this.pause();
-      } else {
-        this.resume();
-      }
-    }
-  
-    static next() {
-      if (this.queue.length > 0) {
-        const nextQueued = this.queue.shift();
-        const index = this.playlist.findIndex(s => s.id === nextQueued.id);
-        this.play(nextQueued, index);
-      } else if (this.isShuffle) {
-        this.playRandom();
-      } else if (this.currentIndex < this.playlist.length - 1) {
-        this.play(this.playlist[this.currentIndex + 1], this.currentIndex + 1);
-      }
-    }
-  
-    static prev() {
-      if (this.currentIndex > 0) {
-        this.play(this.playlist[this.currentIndex - 1], this.currentIndex - 1);
-      }
+      this.audio.src = '';
     }
-  
-    static seek(seconds: number) {
-      this.audio.currentTime = seconds;
-    }
-  
-    static autoNext() {
-      this.next();
+    this.isPlaying = false;
+    await CapacitorMusicControls.destroy();
+  }
+
+  static async togglePlayPause() {
+    if (this.isPlaying) {
+      await this.pause();
+    } else if (this.currentSong) {
+      await this.resume();
+    } else if (this.playlist.length > 0) {
+      await this.play(this.playlist[0], 0);
     }
-  
-    static playRandom() {
-      if (this.playlist.length <= 1) return;
-  
-      let randomIndex;
-      do {
-        randomIndex = Math.floor(Math.random() * this.playlist.length);
-      } while (randomIndex === this.currentIndex);
-  
-      this.play(this.playlist[randomIndex], randomIndex);
+  }
+
+  static async next() {
+    if (this.queue.length > 0) {
+      const next = this.queue.shift();
+      const index = this.playlist.findIndex(s => s.id === next.id);
+      await this.play(next, index);
+    } else if (this.isShuffle) {
+      await this.playRandom();
+    } else if (this.currentIndex < this.playlist.length - 1) {
+      await this.play(this.playlist[this.currentIndex + 1], this.currentIndex + 1);
     }
-  
-    static toggleShuffle() {
-      this.isShuffle = !this.isShuffle;
+  }
+
+  static async prev() {
+    if (this.currentTime > 3) {
+      await this.seekTo(0);
+    } else if (this.currentIndex > 0) {
+      await this.play(this.playlist[this.currentIndex - 1], this.currentIndex - 1);
     }
-  
-    static addToQueue(song: any) {
-      if (!this.queue.some(q => q.id === song.id)) {
-        this.queue.push(song);
-      }
+  }
+
+  static async autoNext() {
+    await this.next();
+  }
+
+  static async playRandom() {
+    if (this.playlist.length <= 1) return;
+    let rand = this.currentIndex;
+    while (rand === this.currentIndex) {
+      rand = Math.floor(Math.random() * this.playlist.length);
+    }
+    await this.play(this.playlist[rand], rand);
+  }
+
+  static toggleShuffle() {
+    this.isShuffle = !this.isShuffle;
+  }
+
+  static addToQueue(song: any) {
+    if (!this.queue.find(s => s.id === song.id)) {
+      this.queue.push(song);
     }
-  
-    static removeFromQueue(index: number) {
+  }
+
+  static removeFromQueue(index: number) {
+    if (index >= 0 && index < this.queue.length) {
       this.queue.splice(index, 1);
     }
-  
-    static reorderQueue(from: number, to: number) {
-      const item = this.queue.splice(from, 1)[0];
-      this.queue.splice(to, 0, item);
-    }
-  
-    static getCurrentTime(): number {
-      return this.currentTime;
-    }
-  
-    static getDuration(): number {
-      return this.duration;
-    }
-  
-    static formatTime(time: number): string {
-      const minutes = Math.floor(time / 60);
-      const seconds = Math.floor(time % 60);
-      return `${minutes}:${seconds < 10 ? '0' : ''}${seconds}`;
-    }
-  
-    static isPlayingSong(): boolean {
-      return this.isPlaying;
-    }
-  
-    static getCurrentSong(): any {
-      return this.currentSong;
-    }
-  
-    static setQuality(index: number) {
-      this.selectedQuality = index;
-    }
-  
-    static getQueue(): any[] {
-      return this.queue;
-    }
-  
-    static getPlaylist(): any[] {
-      return this.playlist;
+  }
+
+  static reorderQueue(from: number, to: number) {
+    if (from === to) return;
+    const [item] = this.queue.splice(from, 1);
+    this.queue.splice(to, 0, item);
+  }
+
+  static async seekTo(seconds: number) {
+    if (this.audio) {
+      this.audio.currentTime = seconds;
+      this.currentTime = seconds;
     }
   }
-  
+
+  static getCurrentTime(): number {
+    return this.currentTime;
+  }
+
+  static getDuration(): number {
+    return this.duration;
+  }
+
+  static formatTime(t: number): string {
+    const m = Math.floor(t / 60);
+    const s = Math.floor(t % 60);
+    return `${m}:${s < 10 ? '0' : ''}${s}`;
+  }
+
+  static isPlayingSong(): boolean {
+    return this.isPlaying;
+  }
+
+  static getCurrentSong(): any {
+    return this.currentSong;
+  }
+
+  static setQuality(index: number) {
+    this.selectedQuality = index;
+  }
+
+  static getQueue(): any[] {
+    return [...this.queue];
+  }
+
+  static getPlaylist(): any[] {
+    return [...this.playlist];
+  }
+
+  static getShuffleStatus(): boolean {
+    return this.isShuffle;
+  }
+
+  static async destroy() {
+    await this.stop();
+    this.playlist = [];
+    this.queue = [];
+    this.audio = null;
+    this.isInitialized = false;
+  }
+}

package/tsconfig.json

@@ -14,7 +14,8 @@
     "esModuleInterop": true,          // allow default imports from CommonJS
     "forceConsistentCasingInFileNames": true,
     "strict": true,
-    "skipLibCheck": true              // speed up builds, safe for libs
+    "skipLibCheck": true,
+    "types": ["@capacitor-community/native-audio"]              // speed up builds, safe for libs
   },
   "include": ["src"]                  // only compile the src folder
 }