X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=client%2Fsrc%2Fstandalone%2Fplayer%2Fplayer.ts;h=9776fda120297fbfd21966203cfd66f5eb65aeb1;hb=35f676e5d3e5e242e84ed63da2cc78117079c7cb;hp=9fc648d258ec6f19228acc0186ba2d5f95174f1d;hpb=999417328bde0e60cd59318fc1c18672356254ce;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/client/src/standalone/player/player.ts b/client/src/standalone/player/player.ts
index 9fc648d25..9776fda12 100644
--- a/client/src/standalone/player/player.ts
+++ b/client/src/standalone/player/player.ts
@@ -1,31 +1,38 @@
 import * as Channel from 'jschannel'
+import { EventHandler, PeerTubeResolution, PeerTubeTextTrack, PlayerEventType } from './definitions'
 import { EventRegistrar } from './events'
-import { EventHandler, PlayerEventType, PeerTubeResolution } from './definitions'
 
 const PASSTHROUGH_EVENTS = [
-  'pause', 'play', 
+  'pause',
+  'play',
   'playbackStatusUpdate',
   'playbackStatusChange',
-  'resolutionUpdate'
+  'resolutionUpdate',
+  'volumeChange'
 ]
 
 /**
- * Allows for programmatic control of a PeerTube embed running in an <iframe> 
+ * Allows for programmatic control of a PeerTube embed running in an <iframe>
  * within a web page.
  */
 export class PeerTubePlayer {
+
+  private eventRegistrar: EventRegistrar = new EventRegistrar()
+  private channel: Channel.MessagingChannel
+  private readyPromise: Promise<void>
+
   /**
    * Construct a new PeerTubePlayer for the given PeerTube embed iframe.
-   * Optionally provide a `scope` to ensure that messages are not crossed 
-   * between multiple PeerTube embeds. The string passed here must match the 
+   * Optionally provide a `scope` to ensure that messages are not crossed
+   * between multiple PeerTube embeds. The string passed here must match the
    * `scope=` query parameter on the embed URL.
-   * 
-   * @param embedElement 
-   * @param scope 
+   *
+   * @param embedElement
+   * @param scope
    */
-  constructor(
-    private embedElement : HTMLIFrameElement, 
-    private scope? : string
+  constructor (
+    private embedElement: HTMLIFrameElement,
+    private scope?: string
   ) {
     this.eventRegistrar.registerTypes(PASSTHROUGH_EVENTS)
 
@@ -33,55 +40,51 @@ export class PeerTubePlayer {
     this.prepareToBeReady()
   }
 
-  private eventRegistrar : EventRegistrar = new EventRegistrar()
-  private channel : Channel.MessagingChannel
-  private readyPromise : Promise<void>
-
   /**
    * Destroy the player object and remove the associated player from the DOM.
    */
-  destroy() {
+  destroy () {
     this.embedElement.remove()
   }
 
   /**
    * Listen to an event emitted by this player.
-   * 
+   *
    * @param event One of the supported event types
    * @param handler A handler which will be passed an event object (or undefined if no event object is included)
    */
-  addEventListener(event : PlayerEventType, handler : EventHandler<any>): boolean {
+  addEventListener (event: PlayerEventType, handler: EventHandler<any>): boolean {
     return this.eventRegistrar.addListener(event, handler)
   }
 
   /**
    * Remove an event listener previously added with addEventListener().
-   * 
+   *
    * @param event The name of the event previously listened to
-   * @param handler 
+   * @param handler
    */
-  removeEventListener(event : PlayerEventType, handler : EventHandler<any>): boolean {
+  removeEventListener (event: PlayerEventType, handler: EventHandler<any>): boolean {
     return this.eventRegistrar.removeListener(event, handler)
   }
-  
+
   /**
    * Promise resolves when the player is ready.
    */
-  get ready(): Promise<void> {
+  get ready (): Promise<void> {
     return this.readyPromise
   }
 
   /**
    * Tell the embed to start/resume playback
    */
-  async play() {
+  async play () {
     await this.sendMessage('play')
   }
 
   /**
    * Tell the embed to pause playback.
    */
-  async pause() {
+  async pause () {
     await this.sendMessage('pause')
   }
 
@@ -89,7 +92,7 @@ export class PeerTubePlayer {
    * Tell the embed to change the audio volume
    * @param value A number from 0 to 1
    */
-  async setVolume(value : number) {
+  async setVolume (value: number) {
     await this.sendMessage('setVolume', value)
   }
 
@@ -97,62 +100,98 @@ export class PeerTubePlayer {
    * Get the current volume level in the embed.
    * @param value A number from 0 to 1
    */
-  async getVolume(): Promise<number> {
-    return await this.sendMessage<void, number>('setVolume')
+  async getVolume (): Promise<number> {
+    return this.sendMessage<void, number>('getVolume')
+  }
+
+  /**
+   * Tell the embed to change the current caption
+   * @param value Caption id
+   */
+  async setCaption (value: string) {
+    await this.sendMessage('setCaption', value)
+  }
+
+  /**
+   * Get video captions
+   */
+  async getCaptions (): Promise<PeerTubeTextTrack[]> {
+    return this.sendMessage<void, PeerTubeTextTrack[]>('getCaptions')
   }
 
   /**
    * Tell the embed to seek to a specific position (in seconds)
-   * @param seconds 
+   * @param seconds
    */
-  async seek(seconds : number) {
+  async seek (seconds: number) {
     await this.sendMessage('seek', seconds)
   }
 
   /**
    * Tell the embed to switch resolutions to the resolution identified
    * by the given ID.
-   * 
+   *
    * @param resolutionId The ID of the resolution as found with getResolutions()
    */
-  async setResolution(resolutionId : any) {
+  async setResolution (resolutionId: any) {
     await this.sendMessage('setResolution', resolutionId)
   }
 
   /**
-   * Retrieve a list of the available resolutions. This may change later, listen to the 
+   * Retrieve a list of the available resolutions. This may change later, listen to the
    * `resolutionUpdate` event with `addEventListener` in order to be updated as the available
    * resolutions change.
    */
-  async getResolutions(): Promise<PeerTubeResolution[]> {
-    return await this.sendMessage<void, PeerTubeResolution[]>('getResolutions')
+  async getResolutions (): Promise<PeerTubeResolution[]> {
+    return this.sendMessage<void, PeerTubeResolution[]>('getResolutions')
   }
 
   /**
-   * Retrieve a list of available playback rates. 
+   * Retrieve a list of available playback rates.
    */
-  async getPlaybackRates() : Promise<number[]> {
-    return await this.sendMessage<void, number[]>('getPlaybackRates')
+  async getPlaybackRates (): Promise<number[]> {
+    return this.sendMessage<void, number[]>('getPlaybackRates')
   }
-  
+
   /**
    * Get the current playback rate. Defaults to 1 (1x playback rate).
    */
-  async getPlaybackRate() : Promise<number> {
-    return await this.sendMessage<void, number>('getPlaybackRate')
+  async getPlaybackRate (): Promise<number> {
+    return this.sendMessage<void, number>('getPlaybackRate')
   }
 
   /**
    * Set the playback rate. Should be one of the options returned by getPlaybackRates().
    * Passing 0.5 means half speed, 1 means normal, 2 means 2x speed, etc.
-   * 
-   * @param rate 
+   *
+   * @param rate
    */
-  async setPlaybackRate(rate : number) {
+  async setPlaybackRate (rate: number) {
     await this.sendMessage('setPlaybackRate', rate)
   }
 
-  private constructChannel() {
+  /**
+   * Play next video in playlist
+   */
+  async playNextVideo () {
+    await this.sendMessage('playNextVideo')
+  }
+
+  /**
+   * Play previous video in playlist
+   */
+  async playPreviousVideo () {
+    await this.sendMessage('playPreviousVideo')
+  }
+
+  /**
+   * Get video position currently played (starts from 1)
+   */
+  async getCurrentPosition () {
+    return this.sendMessage<void, number>('getCurrentPosition')
+  }
+
+  private constructChannel () {
     this.channel = Channel.build({
       window: this.embedElement.contentWindow,
       origin: '*',
@@ -160,14 +199,16 @@ export class PeerTubePlayer {
     })
     this.eventRegistrar.bindToChannel(this.channel)
   }
- 
-  private prepareToBeReady() {
-    let readyResolve, readyReject
+
+  private prepareToBeReady () {
+    let readyResolve: Function
+    let readyReject: Function
+
     this.readyPromise = new Promise<void>((res, rej) => {
       readyResolve = res
       readyReject = rej
     })
-    
+
     this.channel.bind('ready', success => success ? readyResolve() : readyReject())
     this.channel.call({
       method: 'isReady',
@@ -175,7 +216,7 @@ export class PeerTubePlayer {
     })
   }
 
-  private sendMessage<TIn, TOut>(method : string, params? : TIn): Promise<TOut> {
+  private sendMessage<TIn, TOut> (method: string, params?: TIn): Promise<TOut> {
     return new Promise<TOut>((resolve, reject) => {
       this.channel.call({
         method, params,
@@ -187,4 +228,4 @@ export class PeerTubePlayer {
 }
 
 // put it on the window as well as the export
-window['PeerTubePlayer'] = PeerTubePlayer
\ No newline at end of file
+(window[ 'PeerTubePlayer' ] as any) = PeerTubePlayer