Enfileiramento

Visão geral

O SDK do receptor da Web suporta o enfileiramento com os fila padrão fornecida pelo SDK usando QueueData e QueueManager ou usar uma fila personalizada ao implementar cast.framework.QueueBase e usar QueueManager para atualizações.

A API Queueing permite que os aplicativos se integrem melhor ao Cast ao oferecer os seguintes recursos:

  • O suporte à implementação de filas na nuvem do Google e de parceiros para que as filas armazenadas e criadas podem ser carregadas diretamente nos dispositivos de transmissão.
  • Mecanismos que permitem a paginação de itens na fila em vez de carregar tudo de uma só vez.
  • Suporte para novas mensagens, como ir para o próximo item, o item anterior, buscar uma janela de itens, além de obter informações de mídia relacionadas a um conjunto de itens de fila.
  • A QueueManager para gerenciar a inserção, a remoção e a atualização dos itens da fila.

Fila padrão

O SDK do receptor da Web fornece suporte de fila limitado pronto para uso no formato de uma fila padrão.

Para usar a fila padrão, forneça o queueData no LoadRequestData dos carregamentos do lado do remetente ou envie uma solicitação de carga local usando PlayerManager#load Consulte também Como carregar mídia.

No lado do receptor, a fila pode ser modificada usando o método QueueManager depois que a mídia inicial for carregada.

Fila personalizada

Se a fila padrão não oferecer a funcionalidade de enfileiramento necessária para seu aplicativo, a capacidade de criar uma fila personalizada está disponível, permitindo mais capacidades e flexibilidade.

Os desenvolvedores de aplicativos podem criar uma fila no lado do receptor da Web implementando cast.framework.QueueBase

Este é um exemplo básico de uma fila simples em que o initialize chamada for substituída e, em seguida, uma lista de itens de fila juntamente com as descrições da fila são fornecidos ao dispositivo de transmissão.

Consulte também Como carregar mídia.

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

Neste exemplo, a lista de itens na initialize é fornecida no campo QueueBase chamada de construtor. No entanto, para uma implementação de fila na nuvem, a interface Web A lógica do receptor pode buscar os itens externamente e retorná-los como parte a chamada de inicialização.

Para demonstrar um uso mais abrangente da API de enfileiramento, aqui está uma demonstração que implementa a maioria dos classe 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);
 }
};

No exemplo acima, YourServer é o servidor de fila na nuvem e tem lógica sobre como buscar determinados itens de mídia.

Para usar QueueBase implementar as filas, seria possível definir a opção de fila no CastReceiverContext:

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

Como gerenciar uma fila

A QueueManager oferece aos desenvolvedores flexibilidade para desenvolver suas soluções de filas, métodos para acessar a lista atualmente armazenada de itens de fila, bem como os o item sendo reproduzido. Ela também oferece operações como inserção, remoção e atualização dos itens na fila. O snippet a seguir mostra como acessar uma instância de QueueManager:

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

Gerenciamento de filas padrão

Depois que a fila inicial é carregada, QueueManager podem ser usadas para realizar ações como a recuperação do item atual, todos os itens na fila e atualizar os itens na fila usando insertItems, removeItems, e updateItems

Gerenciamento de filas personalizadas

Aqui está um exemplo de implementação de fila personalizada que usa os operadores de inserção e métodos de remoção com base em algum evento. O exemplo também demonstra o uso de updateItems em que os desenvolvedores podem modificar os itens da fila existente, como e a remoção dos intervalos de anúncio.

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

Mensagens recebidas e enviadas

Para oferecer suporte total à busca pela fila do lado do destinatário como fonte da verdade, o as seguintes mensagens de enfileiramento são introduzidas e processadas pelo CAF SDK do receptor:

Mensagem recebida Parâmetros Mensagem de resposta enviada Enter
PRÓXIMA Nenhum parâmetro é necessário. MEDIA_STATUS O receptor vai (buscar por nextItems(), se necessário) e começar a reproduzir para o próximo item.
ANTERIOR Nenhum parâmetro é necessário. MEDIA_STATUS O receptor da Web (buscará por meio de prevItems(), se necessário) e iniciará reproduzindo o item anterior.
FETCH_ITEMS FetchItemsRequestData QUEUE_CHANGE Uma cast.framework.messages.QueueChange. Por exemplo, para um caso de inserção, o campo de itens no JSON conterá a lista de novos itens buscados.
GET_ITEMS_INFO GetItemsInfoRequestData que contém itemIds: Matriz<number> ITEMS_INFO cast.framework.messages.ItemsInfo com informações do item da fila.
GET_QUEUE_IDS Nenhum parâmetro é necessário. QUEUE_IDS cast.framework.messages.QueueIds.

Para NEXT/PREVIOUS, se a representação da fila existente no receptor da Web não tiver mais itens, o QueueBase.nextItems() ou QueueBase.prevItems() é invocado para receber mais itens.

Para FETCH_ITEM, a função correspondente fetchItems na implementação de QueueBase é chamado para filas do Cloud, que recuperam os dados relevantes a serem retornados ao receptor da Web para armazenamento.

Sempre que mais itens são buscados, um novo tipo de mensagem QUEUE_CHANGE é acionado. e devolvidos ao remetente. Veja os vários tipos de mudanças na fila.

Para o GET_ITEMS_INFO, QueueBase implementação não é acionada e o receptor da Web retorna informações de mídia já conhecidas na lista de IDs.

Ordem aleatória de uma fila

Para definir a ordem aleatória dos itens na fila, defina o shuffle bandeira de QueueData como true ao carregar seus itens na fila.

Se você estiver usando uma implementação do QueueBase, use as shuffle para retornar uma lista embaralhada de itens.

Para embaralhar uma fila existente, use o método shuffle bandeira do QUEUE_UPDATE MessageType, em vez do comando QUEUE_SHUFFLE. Consulte QueueUpdateRequestData se quiser mais informações.

Modo de repetição

Para definir os itens da fila a serem repetidos, defina o repeatMode propriedade de QueueData ao valor desejado RepeatMode ao carregar seus itens na fila.

Para alterar o RepeatMode de uma fila existente, use o repeatMode do elemento QueueUpdateRequestData, que usa o QUEUE_UPDATE MessageType.

Anterior
Faixas
Próxima
Intervalos de anúncio