Kolejkowanie

Omówienie

Pakiet Web Receiver SDK obsługuje kolejkowanie z użyciem tagów domyślna kolejka udostępniana przez Pakiet SDK używa QueueData. oraz QueueManager. lub za pomocą niestandardowej kolejki wdrażanie cast.framework.QueueBase i za pomocą QueueManager .

Interfejs Queueing API umożliwia lepszą integrację aplikacji z Cast następujące funkcje:

• Pomoc we wdrażaniu kolejki w chmurze przez Google i partnerów, więc na zewnątrz zapisane i utworzone kolejki można załadować bezpośrednio do urządzeń przesyłających.
• Mechanizmy, które umożliwiają podział elementów w kolejce na strony zamiast wczytywania wszystko naraz.
• Obsługa nowych komunikatów, takich jak przejście do następnego lub poprzedniego elementu, pobierania okna z elementami oraz pobierania informacji o multimediach czyli zbiór elementów kolejki.
• QueueManager do zarządzania wstawianiem, usuwaniem i aktualizowaniem elementów w kolejce.

Domyślna kolejka

Pakiet Web Receiver SDK zapewnia ograniczoną obsługę kolejek domyślnej kolejki.

Aby użyć domyślnej kolejki, podaj queueData w LoadRequestData ładowania po stronie nadawcy lub wyślij lokalne żądanie wczytywania za pomocą PlayerManager#load Zobacz też Wczytywanie multimediów.

Uwaga: nie dodawaj ani nie modyfikuj queueData właściwości LoadRequestData w elemencie przechwytującym LOAD. Nie będzie to miało wpływu na odtwarzanie, ponieważ Projekt queueData został już przeczytany i został zastosowany do kolejki.

Po stronie odbiorcy kolejkę można modyfikować za pomocą QueueManager po załadowaniu początkowych multimediów.

Kolejka niestandardowa

Jeśli domyślna kolejka nie zapewnia funkcji kolejkowania wymaganej przez aplikacji, możesz utworzyć niestandardową kolejkę, możliwości i elastyczność.

Programiści aplikacji mogą utworzyć poboczną kolejkę odbiornika internetowego przez cast.framework.QueueBase

Oto podstawowy przykład prostej kolejki, w której initialize zostanie zastąpione, a następnie lista elementów kolejki wraz z ich opisami są dostarczane do urządzenia przesyłającego.

Zobacz też Wczytywanie multimediów.

// 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;
 }
};

W tym przykładzie lista elementów w tabeli initialize jest realizowany w QueueBase wywołanie konstruktora. Jednak w przypadku implementacji kolejki w chmurze niestandardowa Logika odbiornika może pobrać produkty na zewnątrz, a następnie zwrócić je w ramach wywołanie inicjujące.

Aby zaprezentować bardziej kompleksowe zastosowanie interfejsu API do obsługi kolejek, obejrzyj prezentację , która implementuje większość funkcji 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);
 }
};

W powyższym przykładzie YourServer jest serwerem kolejki w chmurze i zastosowanym mechanizmem logicznym. o pobieraniu określonych elementów multimedialnych.

Aby użyć narzędzia QueueBase -implementacji kolejki, trzeba ustawić opcję kolejki CastReceiverContext:

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

Zarządzanie kolejką

QueueManager daje programistom elastyczność w opracowywaniu rozwiązań do obsługi kolejek, dostępu do obecnie zapisanej listy elementów kolejki, a także obecnie odtwarzanego elementu. Zapewnia też takie operacje, jak wstawianie, usuwanie i aktualizacja elementów oczekujących. Ten fragment kodu pokazuje, jak uzyskać dostęp do wystąpienie QueueManager:

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

Domyślne zarządzanie kolejkami

Po załadowaniu początkowej kolejki QueueManager może służyć do wykonywania takich działań jak pobieranie bieżącego elementu, wszystkich elementów w kolejce, a także aktualizowanie elementów znajdujących się w kolejce za pomocą insertItems, removeItems, oraz updateItems.

Niestandardowe zarządzanie kolejkami

Oto przykład niestandardowej implementacji kolejki, która korzysta z funkcji wstawiania metod usuwania treści na podstawie jakiegoś zdarzenia. Ten przykład pokazuje też wykorzystanie updateItems gdzie deweloperzy mogą modyfikować elementy istniejącej kolejki, przez usunięcie przerw na reklamy.

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;
    }));
  }
};

Wiadomości przychodzące i wychodzące

Aby w pełni obsługiwać pobieranie kolejki po stronie odbiorcy jako źródła informacji, kolejne wiadomości umieszczane w kolejce są wprowadzane i obsługiwane przez CAF Pakiet SDK odbiorcy:

Wiadomość przychodząca	Parametry	Wiadomość z odpowiedzią wychodzącą	Zwróć
DALEJ	Parametr nie jest wymagany.	MEDIA_STATUS	Odbiorca (w razie potrzeby pobiera za pomocą funkcji nextItems()) i rozpoczyna odtwarzanie przejdź do następnego elementu.
WSTECZ	Parametr nie jest wymagany.	MEDIA_STATUS	Odbiornik internetowy (w razie potrzeby pobiera za pomocą prevItems()) i uruchamia odtwarzania poprzedniego elementu.
FETCH_ITEMS	FetchItemsRequestData	QUEUE_CHANGE	A cast.framework.messages.QueueChange. Na przykład w przypadku wstawiania pole items w pliku JSON będzie zawierać listę nowych pobranych elementów.
GET_ITEMS_INFO	GetItemsInfoRequestData zawiera identyfikatory itemIds: Tablica<numer>	ITEMS_INFO	cast.framework.messages.ItemsInfo z informacjami o elementach kolejki.
GET_QUEUE_IDS	Parametr nie jest wymagany.	QUEUE_IDS	cast.framework.messages.QueueIds.

Dla NEXT/PREVIOUS, jeśli obecna reprezentacja kolejki w odbiorniku internetowym nie ma więcej elementów, QueueBase.nextItems(). lub QueueBase.prevItems(). jest automatycznie wywoływany w celu otrzymania większej liczby elementów.

W przypadku funkcji FETCH_ITEM odpowiednia funkcja fetchItems. w implementacji QueueBase jest wywoływana dla kolejek w chmurze, które pobierają odpowiednie dane, które mają być zwracane do odbiornika internetowego w celu zapisania.

Przy każdym pobieraniu kolejnych elementów wywoływany jest nowy typ wiadomości QUEUE_CHANGE. i odesłać do nadawcy. Zobacz różne typy zmian w kolejce.

W przypadku usługi GET_ITEMS_INFO, użytkownika QueueBase implementacja nie zostanie aktywowana, a Web Receiver zwraca informacje o multimediach. już znany z listy identyfikatorów.

Uwaga: zwykle wiadomości w kolejce Przychodzące i Wychodzące są jest obsługiwany przez odpowiedni pakiet SDK nadawcy (internetowy, iOS, Android), aby zapewnić właściwy interfejs jest wyświetlany po stronie nadawcy. Programiści aplikacji mogą przechwytywać lub przechwytywać odsłuchiwanie tych komunikatów według własnego uznania.

Odtwarzanie losowe kolejki

Aby ustawić losową kolejność elementów w kolejce, ustaw shuffle flaga QueueData do true podczas wczytywania elementów do kolejki.

Jeśli używasz implementacji QueueBase, użyj shuffle , która zwróci losową listę elementów.

Aby losowo odtwarzać istniejącą kolejkę, użyj shuffle flaga kraju QUEUE_UPDATE MessageType, zamiast polecenia QUEUE_SHUFFLE. Zobacz QueueUpdateRequestData .

Tryb powtarzania

Aby elementy w kolejce powtarzały się, ustaw parametr repeatMode właściwość QueueData do żądanej wartości RepeatMode podczas wczytywania elementów do kolejki.

Aby zmienić RepeatMode istniejącej kolejki, użyj repeatMode. właściwości QueueUpdateRequestData, który korzysta z QUEUE_UPDATE MessageType