Warteschlange

Übersicht

Das Web Receiver SDK unterstützt die Warteschlange mit dem Die Standardwarteschlange default des Objekts SDK mit QueueData und QueueManager oder eine benutzerdefinierte Warteschlange über wird implementiert cast.framework.QueueBase. und verwenden QueueManager .

Die Queueing API ermöglicht eine bessere Integration von Cast durch Anwendungen, indem sie die folgenden Funktionen:

• Unterstützung der Cloud-Warteschlangenimplementierung von Google und Partnern (extern) gespeicherte und erstellte Warteschlange kann direkt in Übertragungsgeräte geladen werden.
• Mechanismen, die eine Paginierung der Elemente in der Warteschlange ermöglichen, anstatt das Laden zu laden alles auf einmal.
• Unterstützung neuer Nachrichten, z. B. Wechsel zum nächsten, vorherigen Element, Abrufen eines Fensters mit Elementen sowie zum Abrufen von Medieninformationen im Zusammenhang mit eine Reihe von Warteschlangenelementen.
• Die QueueManager um das Einfügen, Entfernen und Aktualisieren von Warteschlangenelementen zu verwalten.

Standardwarteschlange

Das Web Receiver SDK bietet eingeschränkten Support für Warteschlangen direkt im Formular. einer Standardwarteschlange.

Um die Standardwarteschlange zu verwenden, geben Sie den Parameter queueData in den LoadRequestData Ihrer senderseitigen Ladevorgänge oder Senden einer lokalen Ladeanfrage mit PlayerManager#load Weitere Informationen finden Sie unter Medien laden.

Achtung :Sie dürfen den Parameter queueData der Eigenschaft des LoadRequestData im LOAD-Interceptor ein. Dies hat keine Auswirkungen auf die Wiedergabe, da queueData wurde bereits gelesen und auf die Warteschlange angewendet.

Auf Empfängerseite kann die Warteschlange mithilfe der QueueManager sobald das ursprüngliche Medium geladen wurde.

Benutzerdefinierte Warteschlange

Wenn die Standardwarteschlange nicht die für können Sie eine benutzerdefinierte Warteschlange erstellen, die mehr Funktionen und Flexibilität.

Anwendungsentwickler können eine Warteschlange auf der Webempfängerseite erstellen, indem sie cast.framework.QueueBase

Hier ist ein einfaches Beispiel für eine einfache Warteschlange, initialize -Aufruf überschrieben wird, dann wird eine Liste der Warteschlangenelemente mit Warteschlangenbeschreibungen auf dem Übertragungsgerät bereitgestellt werden.

Weitere Informationen finden Sie unter Medien laden.

// Creates a simple queue with a combination of contents.
const DemoQueue = class extends cast.framework.QueueBase {
 constructor() {
   super();

   /**
    * List of media urls.
    * @private @const {!Array<string>}
    */
   this.myMediaUrls_ = [...];
 }
 /**
  * Provide a list of items.
  * @param {!cast.framework.messages.LoadRequestData} loadRequestData
  * @return {!cast.framework.messages.QueueData}
  */
 initialize(loadRequestData) {
   const items = [];
   for (const mediaUrl of this.myMediaUrls_) {
     const item = new cast.framework.messages.QueueItem();
     item.media = new cast.framework.messages.MediaInformation();
     item.media.contentId = mediaUrl;
     items.push(item);
   }
   let queueData = loadRequestData.queueData;
   // Create a new queue with media from the load request if one doesn't exist.
   if (!queueData) {
     queueData = new cast.framework.messages.QueueData();
     queueData.name = 'Your Queue Name';
     queueData.description = 'Your Queue Description';
     queueData.items = items;
     // Start with the first item in the playlist.
     queueData.startIndex = 0;
     // Start from 10 seconds into the first item.
     queueData.currentTime = 10;
   }
   return queueData;
 }
};

In diesem Beispiel ist die Liste der Elemente initialize Aufruf wird im Feld QueueBase -Konstruktor aufzurufen. Bei einer Cloud-Warteschlangenimplementierung kann die benutzerdefinierte Web- Die Empfängerlogik kann die Elemente extern abrufen und dann im Rahmen der zum Initialisieren.

Um eine umfassendere Verwendung der Queueing API zu demonstrieren, finden Sie hier eine Demo. in der die meisten Funktionen Klasse QueueBase.

const DemoQueue = class extends cast.framework.QueueBase {
 constructor() {
   /** @private {} */
   super();
   YourServer.onSomeEvent = this.updateEntireQueue_;
 }

 /**
  * Initializes the queue.
  * @param {!cast.framework.messages.LoadRequestData} loadRequestData
  * @return {!cast.framework.messages.QueueData}
  */
 initialize(loadRequestData) {
   let queueData = loadRequestData.queueData;
   // Create a new queue with media from the load request if one doesn't exist.
   if (!queueData) {
     queueData = new cast.framework.messages.QueueData();
     queueData.name = 'Your Queue Name';
     queueData.description = 'Your Queue Description';
     // Put the first set of items into the queue
     const items = this.nextItems();
     queueData.items = items;
     // Start with the first item in the playlist.
     queueData.startIndex = 0;
     // Start from 10 seconds into the first item.
     queueData.currentTime = 10;
   }
   return queueData;
 }

 /**
  * Picks a set of items from remote server after the reference item id and
  * return as the next items to be inserted into the queue. When
  * referenceItemId is omitted, items are simply appended to the end of the
  * queue.
  * @param {number} referenceItemId
  * @return {!Array<cast.framework.QueueItem>}
  */
 nextItems(referenceItemId) {
   // Assume your media has a itemId and the media url
   return this.constructQueueList_(YourServer.getNextMedias(referenceItemId));
 }

 /**
  * Picks a set of items from remote server before the reference item id and
  * return as the items to be inserted into the queue. When
  * referenceItemId is omitted, items are simply appended to beginning of the
  * queue.
  * @param {number} referenceItemId
  * @return {!Array<cast.framework.QueueItem>}
  */
 prevItems(referenceItemId) {
   return this.constructQueueList_(YourServer.getPrevMedias(referenceItemId));
 }

 /**
  * Constructs a list of QueueItems based on the media information containing
  * the item id and the media url.
  * @param {number} referenceItemId
  * @return {!Array<cast.framework.QueueItem>}
  */
 constructQueueList_(medias) {
   const items = [];
   for (media of medias) {
     const item = new cast.framework.messages.QueueItem(media.itemId);
     item.media = new cast.framework.messages.MediaInformation();
     item.media.contentId = media.url;
     items.push(item);
   }
   return items;
 }

 /**
  * Logs the currently playing item.
  * @param {number} itemId The unique id for the item.
  * @export
  */
 onCurrentItemIdChanged(itemId) {
   console.log('We are now playing video ' + itemId);
   YourServer.trackUsage(itemId);
 }
};

Im obigen Beispiel ist YourServer Ihr Cloud-Warteschlangenserver und enthält Logik zum Abrufen bestimmter Medienelemente.

QueueBase verwenden implementierten Warteschlangen die Option für die Warteschlange CastReceiverContext:

const context = cast.framework.CastReceiverContext.getInstance();
context.start({queue: new DemoQueue()});

Warteschlange verwalten

Die QueueManager gibt Entwickelnden Flexibilität bei der Entwicklung ihrer Warteschlangenlösungen, indem , um auf die aktuell gespeicherte Liste der Warteschlangenelemente sowie auf die Element, das gerade wiedergegeben wird. Es bietet auch Operationen wie Einfügen, Entfernen, und Aktualisierung der Warteschlangenelemente. Das folgende Snippet zeigt, wie Sie auf ein Instanz von QueueManager:

const context = cast.framework.CastReceiverContext.getInstance();
const queueManager = context.getPlayerManager().getQueueManager();

Standard-Warteschlangenverwaltung

Nachdem die anfängliche Warteschlange geladen wurde, QueueManager können verwendet werden, um Aktionen wie das Abrufen des aktuellen Elements, alle Elemente in der Warteschlange und aktualisieren Sie die Elemente in der Warteschlange mithilfe insertItems, removeItems, und updateItems

Verwaltung benutzerdefinierter Warteschlangen

Hier ist ein Beispiel für eine benutzerdefinierte Warteschlangenimplementierung, bei der die Einfügungs- und die auf einem Ereignis basieren. Das Beispiel zeigt auch die Verwendung von updateItems Hier können Entwickler die Elemente der Warteschlange ändern, z. B. Werbeunterbrechungen entfernen.

const DemoQueue = class extends cast.framework.QueueBase {
  constructor() {
    super();

    /** @private @const {!cast.framework.QueueManager} */
    this.queueManager_ = context.getPlayerManager().getQueueManager();
  }

  /**
   * Provide a list of items.
   * @param {!cast.framework.messages.LoadRequestData} loadRequestData
   * @return {!cast.framework.messages.QueueData}
   */
  initialize(loadRequestData) {
    // Your normal initialization; see examples above.
    return queueData;
  }

  /** Inserts items to the queue. */
  onSomeEventTriggeringInsertionToQueue() {
    const twoMoreUrls = ['http://url1', 'http://url2'];
    const items = [];
    for (const mediaUrl of twoMoreUrls) {
      const item = new cast.framework.QueueItem();
      item.media = new cast.framework.messages.MediaInformation();
      item.media.contentId = mediaUrl;
      items.push(item);
    }
    // Insert two more items after the current playing item.
    const allItems = this.queueManager_.getItems();
    const currentItemIndex = this.queueManager_.getCurrentItemIndex();
    const nextItemIndex = currentItemIndex + 1;
    let insertBefore = undefined;
    if (currentItemIndex >= 0 &&
        currentItemIndex < allItems.length - 1) {
      insertBefore = allItems[nextItemIndex].itemId;
    }
    this.queueManager_.insertItems(items, insertBefore);
  }

  /** Removes a particular item from the queue. */
  onSomeEventTriggeringRemovalFromQueue() {
    this.queueManager_.removeItems([2]);
  }

  /** Removes all the ads from all the items across the entire queue. */
  onUserBoughtAdFreeVersion() {
    const items = this.queueManager_.getItems();
    this.queueManager_.updateItems(items.map(item => {
      item.media.breaks = undefined;
      return item;
    }));
  }
};

Eingehende und ausgehende Nachrichten

Um das Abrufen von Warteschlangen auf Empfängerseite als „Source of Truth“ vollständig zu unterstützen, nachdem zusätzliche Warteschlangennachrichten vom CAF eingeführt und verarbeitet werden Empfänger-SDK:

Eingehende Nachricht	Parameter	Ausgehende Antwort	Zurückgeben
WEITER	Kein Parameter erforderlich.	MEDIA_STATUS	Der Empfänger ruft (bei Bedarf über nextItems() ab) und beginnt mit dem Spielen. zum nächsten Element.
ZURÜCK	Kein Parameter erforderlich.	MEDIA_STATUS	Der Web Receiver ruft (gegebenenfalls über prevItems() ab) ab und startet das vorherige Element wiedergeben.
FETCH_ITEMS	FetchItemsRequestData	QUEUE_CHANGE	Ein Cast.framework.messages.QueueChange. Bei einem Einfüge-Case Das Elementfeld in der JSON-Datei enthält die Liste der neuen abgerufenen Elemente.
GET_ITEMS_INFO	GetItemsInfoRequestData, die itemIds enthalten: Array<Zahl>	ITEMS_INFO	Cast.framework.messages.ItemsInfo mit Informationen zu Warteschlangenelementen.
GET_QUEUE_IDS	Kein Parameter erforderlich.	QUEUE_IDS	cast.framework.messages.QueueIds.

Für NEXT/PREVIOUS, wenn die vorhandene Warteschlange im Web Receiver dargestellt wird nicht mehr Elemente hat, QueueBase.nextItems() oder QueueBase.prevItems() wird automatisch aufgerufen, um weitere Elemente zu erhalten.

Für FETCH_ITEM ist die entsprechende Funktion fetchItems in der QueueBase-Implementierung wird für Cloud-Warteschlangen aufgerufen, wodurch die relevanten Daten zum Speichern an den Web Receiver zurückgesendet werden.

Immer wenn mehr Elemente abgerufen werden, wird der neue Nachrichtentyp QUEUE_CHANGE ausgelöst. und an den Absender zurückgesendet werden. Sehen Sie sich die verschiedenen Änderungen an der Warteschlange.

Für GET_ITEMS_INFO, QueueBase wird nicht ausgelöst und der Web Receiver gibt Medieninformationen zurück. bereits der Liste der IDs bekannt ist.

Hinweis: Im Allgemeinen sind die Warteschlangen Eingehend und Ausgehend vom jeweiligen Absender-SDK (Web, iOS, Android) verarbeitet werden, wird auf der Absenderseite angezeigt. Anwendungsentwickler können die sich diese Nachrichten wie gewünscht anhören.

Zufallsmix einer Warteschlange

Um festzulegen, dass die Elemente in der Wiedergabeliste zufällig angeordnet werden, legen Sie das shuffle Flagge von QueueData beim Laden der Elemente in die Warteschlange auf true.

Wenn Sie eine Implementierung von QueueBase, verwenden Sie die shuffle um eine zufällig sortierte Liste von Elementen zurückzugeben.

Um den Zufallsmix einer vorhandenen Warteschlange zu ändern, verwenden Sie die Methode shuffle Flagge von QUEUE_UPDATE MessageType, anstelle des Befehls QUEUE_SHUFFLE. Weitere Informationen finden Sie unter QueueUpdateRequestData .

Wiederholungsmodus

Um festzulegen, dass die Elemente in der Warteschlange wiederholt werden sollen, legen Sie den Parameter repeatMode Eigenschaft von QueueData auf das gewünschte RepeatMode wenn Sie die Elemente in die Warteschlange laden.

Um den RepeatMode einer vorhandenen Warteschlange zu ändern, verwenden Sie die Methode repeatMode der Eigenschaft des QueueUpdateRequestData, die die QUEUE_UPDATE MessageType