Pausas publicitarias
El SDK de remitente de iOS proporciona compatibilidad con pausas publicitarias y anuncios complementarios dentro de 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 el funcionamiento de las pausas publicitarias.
Si bien se pueden especificar pausas tanto en el emisor como en el receptor, se recomienda hacerlo en el receptor web y en el receptor de Android TV para mantener un comportamiento coherente en todas las plataformas.
En iOS, especifica pausas publicitarias en un comando de carga con GCKAdBreakClipInfo
y GCKAdBreakInfo
:
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())
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
En los siguientes dos archivos, se implementa GCKUIPlaybackRateController
, que controla la velocidad de reproducción mediante un control segmentado que tiene los botones "normal", "media velocidad" y "doble velocidad":
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 } }
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
Agregar un canal personalizado
El framework de Cast proporciona dos maneras de crear un canal para enviar mensajes personalizados a un receptor web:
GCKCastChannel
está destinado a ser una subclase para implementar canales no triviales que tienen un estado asociado.GCKGenericChannel
se proporciona como alternativa a la subclasificación; pasa sus mensajes recibidos a un delegado para que puedan procesarse en otro lugar.
Este es un ejemplo de una implementación de GCKCastChannel
:
class HGCTextChannel: GCKCastChannel { override func didReceiveTextMessage(_ message: String) { print("received message: \(message)") } }
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
Un canal se puede registrar en cualquier momento. Si la sesión no está conectada, el canal se conectará automáticamente cuando la sesión en sí se conecte, siempre que el espacio de nombres del canal esté presente en la lista de metadatos de la app del receptor web de espacios de nombres compatibles.
Cada canal personalizado está definido por 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 del receptor web también puede enviar y recibir mensajes con el mismo espacio de nombres.
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)") }
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 una lógica que necesite ejecutarse 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 API de reproducción automática y fila de elementos en cola.
Anula la selección y el almacenamiento en caché de imágenes
Varios componentes del framework (p. ej., el diálogo de Cast, el minicontrolador, el control expandido y GCKUIMediaController
, si está configurado) mostrarán el material gráfico del contenido multimedia que se esté transmitiendo. Por lo general, las URLs del material gráfico de la imagen se incluyen en el 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 un tamaño deseado. Tiene un solo método, -[getImageWithHints:fromMetadata:]
, que toma un objeto GCKUIImageHints
y un objeto GCKMediaMetadata
como parámetros, y muestra 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 en el objeto GCKMediaMetadata
, pero la app puede proporcionar una implementación alternativa estableciendo 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 esta puede proporcionar una implementación alternativa configurando la propiedad imageCache
del singleton GCKCastContext
.
Próximos pasos
Con esto concluye las funciones que puedes agregar a tu app de Sender para iOS. Ahora puedes compilar una app emisora para otra plataforma (Android o Web) o crear un Receptor web.