Agrega funciones avanzadas a tu app para iOS

Pausas publicitarias

El SDK de iOS para emisores admite pausas publicitarias y anuncios complementarios en una transmisión de contenido multimedia determinada.

Consulta la descripción general de las pausas publicitarias del receptor web para obtener más información sobre cómo funcionan las pausas publicitarias.

Si bien las pausas se pueden especificar tanto en el remitente como en el receptor, se recomienda que se especifiquen en el receptor de Web y en el receptor de Android TV para mantener un comportamiento coherente en todas las plataformas.

En iOS, especifica las pausas publicitarias en un comando de carga con GCKAdBreakClipInfo y GCKAdBreakInfo:

Swift
let breakClip1Builder = GCKAdBreakClipInfoBuilder(adBreakClipID: "bc0")
breakClip1Builder.title = "Clip title"
if let posterUrl = URL(string: "https://www.some.url") {
  breakClip1Builder.posterURL = posterUrl
}
breakClip1Builder.duration = 60
breakClip1Builder.whenSkippable = 5  // Set this field so that the ad is skippable
let breakClip1 = breakClip1Builder.build()

let breakClip2 = ...
let breakClip3 = ...


let break1 = GCKAdBreakInfoBuilder(adBreakID: "b0", adBreakClipIds: ["bc0", "bc1", "bc2"]).build()
let mediaInfoBuilder = GCKMediaInformationBuilder(entity: "entity")
...
mediaInfoBuilder.adBreaks = [break1]
mediaInfoBuilder.adBreakClips = [breakClip1, breakClip2, breakClip3]
...
mediaInformation = mediaInfoBuilder.build()

let mediaLoadRequestDataBuilder = GCKMediaLoadRequestDataBuilder()
mediaLoadRequestDataBuilder.mediaInformation = mediaInformation

sessionManager.currentSession?.remoteMediaClient?.loadMedia(with: mediaLoadRequestDataBuilder.build())
Objective-C
GCKAdBreakClipInfoBuilder *breakClipInfoBuilder = [[GCKAdBreakClipInfoBuilder alloc] initWithAdBreakClipID:@"bc0"];
breakClipInfoBuilder.title = @"Clip title";
breakClipInfoBuilder.posterURL = [[NSURL alloc] initWithString:@"https://www.some.url"];
breakClipInfoBuilder.duration = 60;
breakClipInfoBuilder.whenSkippable = 5;
GCKAdBreakClipInfo *breakClip1 = breakClipInfoBuilder.build;

GCKAdBreakClipInfo *breakClip2 = ...
GCKAdBreakClipInfo *breakClip3 = ...

GCKAdBreakInfo *break1 = [[GCKAdBreakInfoBuilder alloc] initWithAdBreakID:@"b0"
                                                           adBreakClipIds:@[@"bc0", @"bc1", @"bc2"]].build;

GCKMediaInformationBuilder *mediaInfoBuilder = [[GCKMediaInformationBuilder alloc]
                                                initWithEntity:@"entity"];
...
mediaInfoBuilder.adBreaks = @[break1];
mediaInfoBuilder.adBreakClips = @[breakClip1, breakClip2, breakClip3];
...
self.mediaInformation = [mediaInfoBuilder build];

GCKMediaLoadRequestDataBuilder *mediaLoadRequestDataBuilder = [[GCKMediaLoadRequestDataBuilder alloc] init];
mediaLoadRequestDataBuilder.mediaInformation = self.mediaInformation;

// Send a load request to the remote media client.
GCKRequest *request = [self.sessionManager.currentSession.remoteMediaClient
                                loadMediaWithLoadRequestData:[mediaLoadRequestDataBuilder build]];

Velocidad de reproducción variable

Tu app puede mostrar y cambiar la velocidad de reproducción del elemento multimedia actual. Puedes establecer la velocidad con -[setPlaybackRate:] o -[setPlaybackRate:customData:] de GCKRemoteMediaClient, acceder a GCKUIPlaybackRateController con playbackRateController de GCKUIMediaController y mostrar la velocidad de reproducción actual con playbackRate de GCKUIPlaybackRateController.

Código de muestra

Los siguientes dos archivos implementan GCKUIPlaybackRateController, que controla la velocidad de reproducción con un control segmentado que tiene los botones "normal", "half speed" y "double speed":

Swift
import GoogleCast

/**
 * An implementation of GCKUIPlaybackRateController that controls playback rate
 * using a segmented control that has "normal", "half speed", and "double speed"
 * buttons.
 */
class SegmentedButtonPlaybackRateController: GCKUIPlaybackRateController {
  static let kSegmentNormal = 0;
  static let kSegmentHalfSpeed = 1;
  static let kSegmentDoubleSpeed = 2;

  var segmentedControl: UISegmentedControl!

  override var playbackRate: Float {
    didSet {
      var buttonIndex = 0

      // Map the playback rate to one of our three supported speeds.
      if playbackRate == 1.0 {
        buttonIndex = SegmentedButtonPlaybackRateController.kSegmentNormal
      } else if playbackRate < 1.0 {
        buttonIndex = SegmentedButtonPlaybackRateController.kSegmentHalfSpeed
      } else {
        buttonIndex = SegmentedButtonPlaybackRateController.kSegmentDoubleSpeed
      }

      segmentedControl?.selectedSegmentIndex = buttonIndex
    }
  }
  override var inputEnabled: Bool {
    didSet {
      segmentedControl?.isEnabled = inputEnabled
    }
  }

  /**
   * Designated initializer.
   *
   * @param segmentedControl The segmented control for changing/displaying the
   * playback rate.
   */
  convenience init(_ segmentedControl: UISegmentedControl) {
    self.init()
    self.segmentedControl = segmentedControl;

    segmentedControl.addTarget(self,
                               action: #selector(segmentedControlTapped(sender:)),
                               for: UIControl.Event.valueChanged)
  }

  @objc func segmentedControlTapped(sender: UISegmentedControl) {
    var playbackRate: Float = 1.0

    switch segmentedControl?.selectedSegmentIndex {
    case SegmentedButtonPlaybackRateController.kSegmentHalfSpeed:
      playbackRate = 0.5;
    case SegmentedButtonPlaybackRateController.kSegmentDoubleSpeed:
      playbackRate = 2.0;
    case SegmentedButtonPlaybackRateController.kSegmentNormal:
      fallthrough
    default:
      playbackRate = 1.0;
    }

    self.playbackRate = playbackRate
  }
}
Objective-C

SegmentedButtonPlaybackRateController.h

#import <GoogleCast/GoogleCast.h>
#import <UIKit/UIKit.h>

/**
 * An implementation of GCKUIPlaybackRateController that controls playback rate
 * using a segmented control that has "normal", "half speed", and "double speed"
 * buttons.
 */
@interface SegmentedButtonPlaybackRateController : GCKUIPlaybackRateController

/**
 * Designated initializer.
 *
 * @param segmentedControl The segmented control for changing/displaying the
 * playback rate.
 */
- (instancetype)initWithSegmentedControl:(UISegmentedControl *)segmentedControl;

@end

SegmentedButtonPlaybackRateController.m

#import "SegmentedButtonPlaybackRateController.h"

@interface SegmentedButtonPlaybackRateController () {
  UISegmentedControl *_segmentedControl;
}

@end

static const NSInteger kSegmentNormal = 0;
static const NSInteger kSegmentHalfSpeed = 1;
static const NSInteger kSegmentDoubleSpeed = 2;

@implementation SegmentedButtonPlaybackRateController

- (instancetype)initWithSegmentedControl:(UISegmentedControl *)segmentedControl {
  if (self = [super init]) {
    _segmentedControl = segmentedControl;
    [_segmentedControl addTarget:self
                          action:@selector(segmentedControlTapped:)
                forControlEvents:UIControlEventValueChanged];
  }
  return self;
}

- (void)setPlaybackRate:(float)playbackRate {
  [super setPlaybackRate:playbackRate];

  NSInteger buttonIndex = 0;

  // Map the playback rate to one of our three supported speeds.
  if (playbackRate == 1.0) {
    buttonIndex = kSegmentNormal;
  } else if (playbackRate < 1.0) {
    buttonIndex = kSegmentHalfSpeed;
  } else {
    buttonIndex = kSegmentDoubleSpeed;
  }

  _segmentedControl.selectedSegmentIndex = buttonIndex;
}

- (void)setInputEnabled:(BOOL)inputEnabled {
  _segmentedControl.enabled = inputEnabled;
  [super setInputEnabled:inputEnabled];
}

- (void)segmentedControlTapped:(id)sender {
  float playbackRate;

  switch (_segmentedControl.selectedSegmentIndex) {
    case kSegmentHalfSpeed:
      playbackRate = 0.5;
      break;

    case kSegmentDoubleSpeed:
      playbackRate = 2.0;
      break;

    case kSegmentNormal:
    default:
      playbackRate = 1.0;
      break;
  }

  self.playbackRate = playbackRate;
}

@end

Cómo agregar un canal personalizado

El framework de Cast proporciona dos formas de crear un canal para enviar mensajes personalizados a un receptor web:

  1. GCKCastChannel está diseñado para que se creen subclases de él con el objetivo de implementar canales no triviales que tengan un estado asociado.
  2. GCKGenericChannel se proporciona como una alternativa a la creación de subclases; pasa los mensajes recibidos a un delegado para que se puedan procesar en otro lugar.

Este es un ejemplo de una implementación de GCKCastChannel:

Swift
class HGCTextChannel: GCKCastChannel {
  override func didReceiveTextMessage(_ message: String) {
    print("received message: \(message)")
  }
}
Objective-C

HGCTextChannel.h

#import <GoogleCast/GCKCastChannel.h>

@interface HGCTextChannel : GCKCastChannel

@end

HGCTextChannel.m

#import "HGCTextChannel.h"

@implementation HGCTextChannel
- (void)didReceiveTextMessage:(NSString*)message {
  NSLog(@"received message: %@", message);
}

@end

Se puede registrar un canal en cualquier momento. Si la sesión no está conectada, el canal se conectará automáticamente cuando se conecte la sesión, siempre que el espacio de nombres del canal esté presente en la lista de espacios de nombres admitidos de los metadatos de la app de Web Receiver.

Cada canal personalizado se define con un espacio de nombres único y debe comenzar con el prefijo urn:x-cast:, por ejemplo, urn:x-cast:com.example.custom. Es posible tener varios canales personalizados, cada uno con un espacio de nombres único. La app de receptor web también puede enviar y recibir mensajes con el mismo espacio de nombres.

Swift
var error: GCKError?
let textChannel = HGCTextChannel.init(namespace: "urn:x-cast:com.google.cast.sample.helloworld")
sessionManager.currentCastSession?.add(textChannel)
textChannel.sendTextMessage("Hello World", error: &error)

if error != nil {
  print("Error sending text message \(error.debugDescription)")
}
Objective-C
NSError *error;
HGCTextChannel *textChannel = [[HGCTextChannel alloc] initWithNamespace:@"urn:x-cast:com.google.cast.sample.helloworld"];
[sessionManager.currentCastSession addChannel:textChannel];
[textChannel sendTextMessage:@"Hello World"
                       error:&error];

if (error != nil) {
  NSLog(@"Error sending text message: %@", error);
}

Para proporcionar la lógica que se debe ejecutar cuando un canal en particular se conecta o desconecta, anula los métodos -[didConnect] y -[didDisconnect] si usas GCKCastChannel, o proporciona implementaciones para los métodos -[castChannelDidConnect:] y -[castChannelDidDisconnect:] de GCKGenericChannelDelegate si usas GCKGenericChannel.

Compatibilidad con la reproducción automática

Consulta las APIs de reproducción automática y de cola.

Anula la selección y el almacenamiento en caché de imágenes

Varios componentes del framework (es decir, el diálogo de Cast, el minicontrolador, el controlador expandido y el GCKUIMediaController, si se configuró de esa manera) mostrarán el material gráfico del contenido multimedia que se está transmitiendo. Por lo general, las URLs de las imágenes se incluyen en el objeto GCKMediaMetadata del contenido multimedia, pero la app emisora puede tener una fuente alternativa para las URLs.

El protocolo GCKUIImagePicker define un medio para seleccionar una imagen adecuada para un uso determinado y el tamaño deseado. Tiene un solo método, -[getImageWithHints:fromMetadata:], que toma un objeto GCKUIImageHints y un objeto GCKMediaMetadata como parámetros, y devuelve un objeto GCKImage como resultado. El framework proporciona una implementación predeterminada de GCKUIImagePicker que siempre selecciona la primera imagen de la lista de imágenes del objeto GCKMediaMetadata, pero la app puede proporcionar una implementación alternativa si se configura la propiedad imagePicker del singleton GCKCastContext.

El protocolo GCKUIImageCache también define un medio para almacenar en caché las imágenes que descarga el framework con HTTPS. El framework proporciona una implementación predeterminada de GCKUIImageCache que almacena los archivos de imagen descargados en el directorio de caché de la app, pero la app puede proporcionar una implementación alternativa configurando la propiedad imageCache del singleton GCKCastContext.

Próximos pasos

Con esto, concluyen las funciones que puedes agregar a tu app de remitente para iOS. Ahora puedes compilar una app de remitente para otra plataforma (Android o Web) o compilar un receptor web.

Anterior
Agregar a una cola