Integrar o Google Cast ao seu app iOS

Este guia para desenvolvedores descreve como adicionar suporte ao Google Cast ao seu app remetente para iOS usando o SDK do remetente para iOS.

Observação:recomendamos que você tente o seguinte:

• Tutorial do codelab do transmissor do Google Cast para iOS - Aprenda passo a passo como ativar um app de vídeo iOS para usar um dispositivo Google Cast e transmitir vídeos para uma TV.
• App de exemplo CastVideos-ios (GitHub) - execute, navegue e confira este app de exemplo de referência que obedece às Diretrizes de UX e à Lista de verificação de design.

O dispositivo móvel ou laptop é o remetente, que controla a reprodução, e o dispositivo Google Cast é o receptor, que exibe o conteúdo na TV.

O framework do remetente se refere ao binário da biblioteca de classes do Cast e aos recursos associados presentes no tempo de execução no remetente. O app remetente ou app Cast se refere a um app que também é executado no remetente. O app Web Receiver se refere ao aplicativo HTML em execução no Web Receiver.

O framework do remetente usa um design de callback assíncrono para informar o app remetente sobre eventos e fazer a transição entre vários estados do ciclo de vida do app do Google Cast.

Fluxo de aplicativos

As etapas a seguir descrevem o fluxo de execução típico de alto nível para um app de envio do iOS:

• O framework do Google Cast inicia GCKDiscoveryManager com base nas propriedades fornecidas em GCKCastOptions para iniciar a verificação de dispositivos.
• Quando o usuário clica no botão "Transmitir", o framework apresenta a caixa de diálogo com a lista de dispositivos de transmissão descobertos.
• Quando o usuário seleciona um dispositivo de transmissão, o framework tenta iniciar o app Web Receiver no dispositivo de transmissão.
• O framework invoca callbacks no app de envio para confirmar se o app Web Receiver foi iniciado.
• O framework cria um canal de comunicação entre o remetente e os apps do Web Receiver.
• O framework usa o canal de comunicação para carregar e controlar a reprodução de mídia no Web Receiver.
• O framework sincroniza o estado de reprodução de mídia entre o remetente e o receptor da Web: quando o usuário faz ações na IU do remetente, o framework transmite essas solicitações de controle de mídia para o receptor da Web. Quando o receptor da Web envia atualizações de status de mídia, o framework atualiza o estado da IU do remetente.
• Quando o usuário clica no botão "Transmitir" para se desconectar do dispositivo, o framework desconecta o app de envio do Web Receiver.

Para resolver problemas com o remetente, ative o registro.

Para conferir uma lista completa de todas as classes, métodos e eventos no framework do Google Cast para iOS, consulte a Referência da API Google Cast para iOS. As seções a seguir abrangem as etapas para integrar o Google Cast ao seu app iOS.

Chamar métodos da linha de execução principal

Importante: todos os métodos do SDK precisam ser chamados na linha de execução principal.

Inicializar o contexto do Google Cast

O framework do Google Cast tem um objeto Singleton global, o GCKCastContext, que coordena todas as atividades dele. Esse objeto precisa ser inicializado no início do ciclo de vida do aplicativo, normalmente no método -[application:didFinishLaunchingWithOptions:] do delegado do app, para que a retomada automática da sessão na reinicialização do app remetente possa ser acionada corretamente.

Um objeto GCKCastOptions precisa ser fornecido ao inicializar o GCKCastContext. Essa classe contém opções que afetam o comportamento do framework. A mais importante delas é o ID do aplicativo do receptor da Web, que é usado para filtrar os resultados da descoberta e iniciar o app do receptor da Web quando uma sessão de transmissão é iniciada.

O método -[application:didFinishLaunchingWithOptions:] também é um bom lugar para configurar um delegado de geração de registros para receber as mensagens de geração de registros do framework. Isso pode ser útil para depuração e solução de problemas.

Swift

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate, GCKLoggerDelegate {
  let kReceiverAppID = kGCKDefaultMediaReceiverApplicationID
  let kDebugLoggingEnabled = true

  var window: UIWindow?

  func applicationDidFinishLaunching(_ application: UIApplication) {
    let criteria = GCKDiscoveryCriteria(applicationID: kReceiverAppID)
    let options = GCKCastOptions(discoveryCriteria: criteria)
    GCKCastContext.setSharedInstanceWith(options)

    // Enable logger.
    GCKLogger.sharedInstance().delegate = self

    ...
  }

  // MARK: - GCKLoggerDelegate

  func logMessage(_ message: String,
                  at level: GCKLoggerLevel,
                  fromFunction function: String,
                  location: String) {
    if (kDebugLoggingEnabled) {
      print(function + " - " + message)
    }
  }
}

Objective-C

AppDelegate.h

@interface AppDelegate () <GCKLoggerDelegate>
@end

AppDelegate.m

@implementation AppDelegate

static NSString *const kReceiverAppID = @"AABBCCDD";
static const BOOL kDebugLoggingEnabled = YES;

- (BOOL)application:(UIApplication *)application
didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
  GCKDiscoveryCriteria *criteria = [[GCKDiscoveryCriteria alloc]
                                    initWithApplicationID:kReceiverAppID];
  GCKCastOptions *options = [[GCKCastOptions alloc] initWithDiscoveryCriteria:criteria];
  [GCKCastContext setSharedInstanceWithOptions:options];

  // Enable logger.
  [GCKLogger sharedInstance].delegate = self;

  ...

  return YES;
}

...

#pragma mark - GCKLoggerDelegate

- (void)logMessage:(NSString *)message
           atLevel:(GCKLoggerLevel)level
      fromFunction:(NSString *)function
          location:(NSString *)location {
  if (kDebugLoggingEnabled) {
    NSLog(@"%@ - %@, %@", function, message, location);
  }
}

@end

Os widgets de UX do Google Cast

O SDK do Cast para iOS oferece estes widgets que obedecem à lista de verificação de design do Cast:

• Sobreposição introdutória: a classe GCKCastContext tem um método, presentCastInstructionsViewControllerOnceWithCastButton, que pode ser usado para destacar o botão "Transmitir" na primeira vez que um receptor da Web fica disponível. O app de envio pode personalizar o texto, a posição do texto do título e o botão "Dismiss".

• Botão "Transmitir": a partir do SDK do remetente do Cast para iOS 4.6.0, o botão "Transmitir" fica sempre visível quando o dispositivo remetente está conectado ao Wi-Fi. Na primeira vez que o usuário toca no botão "Transmitir" após iniciar o app, uma caixa de diálogo de permissões aparece para que o usuário possa conceder ao app acesso à rede local para dispositivos na rede. Em seguida, quando o usuário toca no botão de transmissão, uma caixa de diálogo é mostrada, listando os dispositivos descobertos. Quando o usuário toca no botão de transmissão enquanto o dispositivo está conectado, ele exibe os metadados de mídia atuais (como título, nome do estúdio de gravação e uma miniatura de imagem) ou permite que o usuário se desconecte do dispositivo de transmissão. Quando o usuário toca no botão de transmissão quando não há dispositivos disponíveis, uma tela é mostrada informando ao usuário por que os dispositivos não foram encontrados e como resolver o problema.

• Minicontrole: quando o usuário está transmitindo conteúdo e saiu da página de conteúdo atual ou expandiu o controle para outra tela no app de envio, o minicontrole é mostrado na parte de baixo da tela para permitir que o usuário veja os metadados de mídia transmitidos e controle a reprodução.

• Controlador expandido: quando o usuário está transmitindo conteúdo, se ele clicar na notificação de mídia ou no minicontrolador, o controlador expandido será iniciado, mostrando os metadados da mídia que está sendo reproduzida e oferecendo vários botões para controlar a reprodução.

Adicionar um botão "Transmitir"

O framework oferece um componente do botão Transmitir como uma subclasse UIButton. Ele pode ser adicionado à barra de título do app colocando-o em um UIBarButtonItem. Uma subclasse UIViewController típica pode instalar um botão de transmissão da seguinte maneira:

Swift

let castButton = GCKUICastButton(frame: CGRect(x: 0, y: 0, width: 24, height: 24))
castButton.tintColor = UIColor.gray
navigationItem.rightBarButtonItem = UIBarButtonItem(customView: castButton)

Objective-C

GCKUICastButton *castButton = [[GCKUICastButton alloc] initWithFrame:CGRectMake(0, 0, 24, 24)];
castButton.tintColor = [UIColor grayColor];
self.navigationItem.rightBarButtonItem = [[UIBarButtonItem alloc] initWithCustomView:castButton];

Por padrão, tocar no botão abre a caixa de diálogo de transmissão fornecida pelo framework.

O GCKUICastButton também pode ser adicionado diretamente ao storyboard.

Configurar a descoberta de dispositivos

No framework, a descoberta de dispositivos acontece automaticamente. Não é necessário iniciar ou interromper explicitamente o processo de descoberta, a menos que você implemente uma IU personalizada.

A descoberta no framework é gerenciada pela classe GCKDiscoveryManager, que é uma propriedade do GCKCastContext. O framework fornece um componente de caixa de diálogo padrão do Google Cast para seleção e controle de dispositivos. A lista de dispositivos é ordenada lexicograficamente pelo nome amigável.

Como o gerenciamento de sessões funciona

O SDK do Google Cast apresenta o conceito de uma sessão do Google Cast, cuja criação combina as etapas de conexão a um dispositivo, inicialização (ou participação) de um app receptor da Web, conexão a esse app e inicialização de um canal de controle de mídia. Consulte o guia do ciclo de vida do aplicativo do receptor da Web para mais informações sobre as sessões do Google Cast e o ciclo de vida do receptor da Web.

As sessões são gerenciadas pela classe GCKSessionManager, que é uma propriedade do GCKCastContext. As sessões individuais são representadas por subclasses da classe GCKSession. Por exemplo, GCKCastSession representa sessões com dispositivos de transmissão. É possível acessar a sessão do Google Cast ativa no momento (se houver) como a propriedade currentCastSession de GCKSessionManager.

A interface GCKSessionManagerListener pode ser usada para monitorar eventos de sessão, como criação, suspensão, retomada e encerramento. O framework suspende automaticamente as sessões quando o app de envio é colocado em segundo plano e tenta retomar elas quando o app retorna ao primeiro plano (ou é reiniciado após um encerramento anormal/súbito do app enquanto uma sessão estava ativa).

Se a caixa de diálogo do Google Cast estiver sendo usada, as sessões serão criadas e eliminadas automaticamente em resposta aos gestos do usuário. Caso contrário, o app pode iniciar e encerrar sessões explicitamente usando métodos em GCKSessionManager.

Se o app precisar fazer um processamento especial em resposta a eventos do ciclo de vida da sessão, ele poderá registrar uma ou mais instâncias de GCKSessionManagerListener com o GCKSessionManager. GCKSessionManagerListener é um protocolo que define callbacks para eventos como início e término da sessão.

Transferência de stream

A preservação do estado da sessão é a base da transferência de streaming, em que os usuários podem mover streams de áudio e vídeo entre dispositivos usando comandos de voz, o app Google Home ou telas inteligentes. A mídia para de ser reproduzida em um dispositivo (a origem) e continua em outro (o destino). Qualquer dispositivo Cast com o firmware mais recente pode servir como origem ou destino em uma transferência de streaming.

Para receber o novo dispositivo de destino durante a transferência de streaming, use a propriedade GCKCastSession#device durante o callback [sessionManager:didResumeCastSession:].

Consulte Transferência de stream no Web Receiver para mais informações.

Reconexão automática

O framework do Google Cast adiciona uma lógica de reconexão para processar automaticamente a reconexão em muitos casos extremos sutis, como:

• Recuperar-se de uma perda temporária de Wi-Fi
• Recuperar do modo de suspensão do dispositivo
• Recuperar o app em segundo plano
• Recuperar se o app falhar

Como o controle de mídia funciona

Se uma sessão do Google Cast for estabelecida com um app de receptor da Web que ofereça suporte ao namespace de mídia, uma instância de GCKRemoteMediaClient será criada automaticamente pelo framework. Ela poderá ser acessada como a propriedade remoteMediaClient da instância GCKCastSession.

Todos os métodos em GCKRemoteMediaClient que emitem solicitações para o receptor da Web vão retornar um objeto GCKRequest, que pode ser usado para rastrear essa solicitação. Um GCKRequestDelegate pode ser atribuído a esse objeto para receber notificações sobre o resultado final da operação.

Espera-se que a instância de GCKRemoteMediaClient seja compartilhada por várias partes do app, e alguns componentes internos do framework, como a caixa de diálogo do Google Cast e os minicontroles de mídia, compartilham a instância. Para isso, o GCKRemoteMediaClient oferece suporte ao registro de vários GCKRemoteMediaClientListeners.

Definir metadados de mídia

A classe GCKMediaMetadata representa informações sobre um item de mídia que você quer transmitir. O exemplo a seguir cria uma nova instância GCKMediaMetadata de um filme e define o título, o subtítulo, o nome do estúdio de gravação e duas imagens.

Swift

let metadata = GCKMediaMetadata()
metadata.setString("Big Buck Bunny (2008)", forKey: kGCKMetadataKeyTitle)
metadata.setString("Big Buck Bunny tells the story of a giant rabbit with a heart bigger than " +
  "himself. When one sunny day three rodents rudely harass him, something " +
  "snaps... and the rabbit ain't no bunny anymore! In the typical cartoon " +
  "tradition he prepares the nasty rodents a comical revenge.",
                   forKey: kGCKMetadataKeySubtitle)
metadata.addImage(GCKImage(url: URL(string: "https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/images/BigBuckBunny.jpg")!,
                           width: 480,
                           height: 360))

Objective-C

GCKMediaMetadata *metadata = [[GCKMediaMetadata alloc]
                                initWithMetadataType:GCKMediaMetadataTypeMovie];
[metadata setString:@"Big Buck Bunny (2008)" forKey:kGCKMetadataKeyTitle];
[metadata setString:@"Big Buck Bunny tells the story of a giant rabbit with a heart bigger than "
 "himself. When one sunny day three rodents rudely harass him, something "
 "snaps... and the rabbit ain't no bunny anymore! In the typical cartoon "
 "tradition he prepares the nasty rodents a comical revenge."
             forKey:kGCKMetadataKeySubtitle];
[metadata addImage:[[GCKImage alloc]
                    initWithURL:[[NSURL alloc] initWithString:@"https://commondatastorage.googleapis.com/"
                                 "gtv-videos-bucket/sample/images/BigBuckBunny.jpg"]
                    width:480
                    height:360]];

Consulte a seção Seleção e armazenamento em cache de imagens para saber como usar imagens com metadados de mídia.

Carregar mídia

Para carregar um item de mídia, crie uma instância de GCKMediaInformation usando os metadados da mídia. Em seguida, receba o GCKCastSession atual e use o GCKRemoteMediaClient para carregar a mídia no app do receptor. Em seguida, use GCKRemoteMediaClient para controlar um app de player de mídia em execução no receptor, como para reproduzir, pausar e parar.

Swift

let url = URL.init(string: "https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4")
guard let mediaURL = url else {
  print("invalid mediaURL")
  return
}

let mediaInfoBuilder = GCKMediaInformationBuilder.init(contentURL: mediaURL)
mediaInfoBuilder.streamType = GCKMediaStreamType.none;
mediaInfoBuilder.contentType = "video/mp4"
mediaInfoBuilder.metadata = metadata;
mediaInformation = mediaInfoBuilder.build()

guard let mediaInfo = mediaInformation else {
  print("invalid mediaInformation")
  return
}

if let request = sessionManager.currentSession?.remoteMediaClient?.loadMedia(mediaInfo) {
  request.delegate = self
}

Objective-C

GCKMediaInformationBuilder *mediaInfoBuilder =
  [[GCKMediaInformationBuilder alloc] initWithContentURL:
   [NSURL URLWithString:@"https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4"]];
mediaInfoBuilder.streamType = GCKMediaStreamTypeNone;
mediaInfoBuilder.contentType = @"video/mp4";
mediaInfoBuilder.metadata = metadata;
self.mediaInformation = [mediaInfoBuilder build];

GCKRequest *request = [self.sessionManager.currentSession.remoteMediaClient loadMedia:self.mediaInformation];
if (request != nil) {
  request.delegate = self;
}

Consulte também a seção sobre como usar faixas de mídia.

Formato de vídeo 4K

Para determinar o formato de vídeo da mídia, use a propriedade videoInfo de GCKMediaStatus para acessar a instância atual de GCKVideoInfo. Essa instância contém o tipo de formato de TV HDR e a altura e a largura em pixels. As variantes do formato 4K são indicadas na propriedade hdrType pelos valores de tipo enumerado GCKVideoInfoHDRType.

Adicionar minicontroles

De acordo com a Lista de verificação de design do Cast, um app remetente precisa oferecer um controle persistente conhecido como minicontrole, que aparece quando o usuário sai da página de conteúdo atual. O minicontrole oferece acesso instantâneo e um lembrete visível para a sessão atual do Google Cast.

O framework do Cast oferece uma barra de controle, GCKUIMiniMediaControlsViewController, que pode ser adicionada às cenas em que você quer mostrar o minicontrole.

Quando o app de envio está reproduzindo uma transmissão ao vivo de vídeo ou áudio, o SDK mostra automaticamente um botão de reprodução/parada no lugar do botão de assistir/pausar no minicontrolador.

Consulte Personalizar a interface do remetente do iOS para saber como o app do remetente pode configurar a aparência dos widgets do Google Cast.

Há duas maneiras de adicionar o minicontrole a um app de envio:

• Deixe que o framework do Google Cast gerencie o layout do minicontrole, envolvendo o controlador de visualização atual com o próprio controlador de visualização.
• Gerencie o layout do widget de minicontrole adicionando-o ao controlador de visualização existente fornecendo uma subvisualização no storyboard.

Encerrar usando o GCKUICastContainerViewController

A primeira é usar o GCKUICastContainerViewController, que envolve outro controle de visualização e adiciona um GCKUIMiniMediaControlsViewController na parte de baixo. Essa abordagem é limitada porque não é possível personalizar a animação nem configurar o comportamento do controlador de visualização do contêiner.

Essa primeira maneira geralmente é feita no método -[application:didFinishLaunchingWithOptions:] do representante do app:

Swift

func applicationDidFinishLaunching(_ application: UIApplication) {
  ...

  // Wrap main view in the GCKUICastContainerViewController and display the mini controller.
  let appStoryboard = UIStoryboard(name: "Main", bundle: nil)
  let navigationController = appStoryboard.instantiateViewController(withIdentifier: "MainNavigation")
  let castContainerVC =
          GCKCastContext.sharedInstance().createCastContainerController(for: navigationController)
  castContainerVC.miniMediaControlsItemEnabled = true
  window = UIWindow(frame: UIScreen.main.bounds)
  window!.rootViewController = castContainerVC
  window!.makeKeyAndVisible()

  ...
}

Objective-C

- (BOOL)application:(UIApplication *)application
        didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
  ...

  // Wrap main view in the GCKUICastContainerViewController and display the mini controller.
  UIStoryboard *appStoryboard = [UIStoryboard storyboardWithName:@"Main" bundle:nil];
  UINavigationController *navigationController =
          [appStoryboard instantiateViewControllerWithIdentifier:@"MainNavigation"];
  GCKUICastContainerViewController *castContainerVC =
          [[GCKCastContext sharedInstance] createCastContainerControllerForViewController:navigationController];
  castContainerVC.miniMediaControlsItemEnabled = YES;
  self.window = [[UIWindow alloc] initWithFrame:UIScreen.mainScreen.bounds];
  self.window.rootViewController = castContainerVC;
  [self.window makeKeyAndVisible];
  ...

}

Observação: opcional: o minicontrole é mostrado automaticamente quando o conteúdo está sendo reproduzido e fica oculto quando o controle expandido é exibido. Se você quiser controlar manualmente a visibilidade do minicontrole, adicione a variável e o setter/getter abaixo ao delegante do app:

Swift

var castControlBarsEnabled: Bool {
  set(enabled) {
    if let castContainerVC = self.window?.rootViewController as? GCKUICastContainerViewController {
      castContainerVC.miniMediaControlsItemEnabled = enabled
    } else {
      print("GCKUICastContainerViewController is not correctly configured")
    }
  }
  get {
    if let castContainerVC = self.window?.rootViewController as? GCKUICastContainerViewController {
      return castContainerVC.miniMediaControlsItemEnabled
    } else {
      print("GCKUICastContainerViewController is not correctly configured")
      return false
    }
  }
}

Objective-C

AppDelegate.h

@interface AppDelegate : UIResponder <UIApplicationDelegate>

@property (nonatomic, strong) UIWindow *window;
@property (nonatomic, assign) BOOL castControlBarsEnabled;

@end

AppDelegate.m

@implementation AppDelegate

...

- (void)setCastControlBarsEnabled:(BOOL)notificationsEnabled {
  GCKUICastContainerViewController *castContainerVC;
  castContainerVC =
      (GCKUICastContainerViewController *)self.window.rootViewController;
  castContainerVC.miniMediaControlsItemEnabled = notificationsEnabled;
}

- (BOOL)castControlBarsEnabled {
  GCKUICastContainerViewController *castContainerVC;
  castContainerVC =
      (GCKUICastContainerViewController *)self.window.rootViewController;
  return castContainerVC.miniMediaControlsItemEnabled;
}

...

@end

Incorporar no controlador de visualização

A segunda maneira é adicionar o minicontrole diretamente ao controlador de visualização usando createMiniMediaControlsViewController para criar uma instância de GCKUIMiniMediaControlsViewController e, em seguida, adicionar essa instância ao controlador de visualização do contêiner como uma visualização secundária.

Configure o controlador de visualização no delegado do app:

Swift

func application(_ application: UIApplication,
                 didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
  ...

  GCKCastContext.sharedInstance().useDefaultExpandedMediaControls = true
  window?.clipsToBounds = true

  let rootContainerVC = (window?.rootViewController as? RootContainerViewController)
  rootContainerVC?.miniMediaControlsViewEnabled = true

  ...

  return true
}

Objective-C

- (BOOL)application:(UIApplication *)application
    didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
  ...

  [GCKCastContext sharedInstance].useDefaultExpandedMediaControls = YES;

  self.window.clipsToBounds = YES;

  RootContainerViewController *rootContainerVC;
  rootContainerVC =
      (RootContainerViewController *)self.window.rootViewController;
  rootContainerVC.miniMediaControlsViewEnabled = YES;

  ...

  return YES;
}

No seu controlador de visualização raiz, crie uma instância GCKUIMiniMediaControlsViewController e adicione-a ao controlador de visualização do contêiner como uma visualização secundária:

Swift

let kCastControlBarsAnimationDuration: TimeInterval = 0.20

@objc(RootContainerViewController)
class RootContainerViewController: UIViewController, GCKUIMiniMediaControlsViewControllerDelegate {
  @IBOutlet weak private var _miniMediaControlsContainerView: UIView!
  @IBOutlet weak private var _miniMediaControlsHeightConstraint: NSLayoutConstraint!
  private var miniMediaControlsViewController: GCKUIMiniMediaControlsViewController!
  var miniMediaControlsViewEnabled = false {
    didSet {
      if self.isViewLoaded {
        self.updateControlBarsVisibility()
      }
    }
  }

  var overriddenNavigationController: UINavigationController?

  override var navigationController: UINavigationController? {

    get {
      return overriddenNavigationController
    }

    set {
      overriddenNavigationController = newValue
    }
  }
  var miniMediaControlsItemEnabled = false

  override func viewDidLoad() {
    super.viewDidLoad()
    let castContext = GCKCastContext.sharedInstance()
    self.miniMediaControlsViewController = castContext.createMiniMediaControlsViewController()
    self.miniMediaControlsViewController.delegate = self
    self.updateControlBarsVisibility()
    self.installViewController(self.miniMediaControlsViewController,
                               inContainerView: self._miniMediaControlsContainerView)
  }

  func updateControlBarsVisibility() {
    if self.miniMediaControlsViewEnabled && self.miniMediaControlsViewController.active {
      self._miniMediaControlsHeightConstraint.constant = self.miniMediaControlsViewController.minHeight
      self.view.bringSubview(toFront: self._miniMediaControlsContainerView)
    } else {
      self._miniMediaControlsHeightConstraint.constant = 0
    }
    UIView.animate(withDuration: kCastControlBarsAnimationDuration, animations: {() -> Void in
      self.view.layoutIfNeeded()
    })
    self.view.setNeedsLayout()
  }

  func installViewController(_ viewController: UIViewController?, inContainerView containerView: UIView) {
    if let viewController = viewController {
      self.addChildViewController(viewController)
      viewController.view.frame = containerView.bounds
      containerView.addSubview(viewController.view)
      viewController.didMove(toParentViewController: self)
    }
  }

  func uninstallViewController(_ viewController: UIViewController) {
    viewController.willMove(toParentViewController: nil)
    viewController.view.removeFromSuperview()
    viewController.removeFromParentViewController()
  }

  override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
    if segue.identifier == "NavigationVCEmbedSegue" {
      self.navigationController = (segue.destination as? UINavigationController)
    }
  }

...

Objective-C

RootContainerViewController.h

static const NSTimeInterval kCastControlBarsAnimationDuration = 0.20;

@interface RootContainerViewController () <GCKUIMiniMediaControlsViewControllerDelegate> {
  __weak IBOutlet UIView *_miniMediaControlsContainerView;
  __weak IBOutlet NSLayoutConstraint *_miniMediaControlsHeightConstraint;
  GCKUIMiniMediaControlsViewController *_miniMediaControlsViewController;
}

@property(nonatomic, weak, readwrite) UINavigationController *navigationController;

@property(nonatomic, assign, readwrite) BOOL miniMediaControlsViewEnabled;
@property(nonatomic, assign, readwrite) BOOL miniMediaControlsItemEnabled;

@end

RootContainerViewController.m

@implementation RootContainerViewController

- (void)viewDidLoad {
  [super viewDidLoad];
  GCKCastContext *castContext = [GCKCastContext sharedInstance];
  _miniMediaControlsViewController =
      [castContext createMiniMediaControlsViewController];
  _miniMediaControlsViewController.delegate = self;

  [self updateControlBarsVisibility];
  [self installViewController:_miniMediaControlsViewController
              inContainerView:_miniMediaControlsContainerView];
}

- (void)setMiniMediaControlsViewEnabled:(BOOL)miniMediaControlsViewEnabled {
  _miniMediaControlsViewEnabled = miniMediaControlsViewEnabled;
  if (self.isViewLoaded) {
    [self updateControlBarsVisibility];
  }
}

- (void)updateControlBarsVisibility {
  if (self.miniMediaControlsViewEnabled &&
      _miniMediaControlsViewController.active) {
    _miniMediaControlsHeightConstraint.constant =
        _miniMediaControlsViewController.minHeight;
    [self.view bringSubviewToFront:_miniMediaControlsContainerView];
  } else {
    _miniMediaControlsHeightConstraint.constant = 0;
  }
  [UIView animateWithDuration:kCastControlBarsAnimationDuration
                   animations:^{
                     [self.view layoutIfNeeded];
                   }];
  [self.view setNeedsLayout];
}

- (void)installViewController:(UIViewController *)viewController
              inContainerView:(UIView *)containerView {
  if (viewController) {
    [self addChildViewController:viewController];
    viewController.view.frame = containerView.bounds;
    [containerView addSubview:viewController.view];
    [viewController didMoveToParentViewController:self];
  }
}

- (void)uninstallViewController:(UIViewController *)viewController {
  [viewController willMoveToParentViewController:nil];
  [viewController.view removeFromSuperview];
  [viewController removeFromParentViewController];
}

- (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender {
  if ([segue.identifier isEqualToString:@"NavigationVCEmbedSegue"]) {
    self.navigationController =
        (UINavigationController *)segue.destinationViewController;
  }
}

...

@end

O GCKUIMiniMediaControlsViewControllerDelegate informa ao controlador de visualização do host quando o minicontrole precisa ficar visível:

Swift

  func miniMediaControlsViewController(_: GCKUIMiniMediaControlsViewController,
                                       shouldAppear _: Bool) {
    updateControlBarsVisibility()
  }
RootContainerViewController.swift

Objective-C

- (void)miniMediaControlsViewController:
            (GCKUIMiniMediaControlsViewController *)miniMediaControlsViewController
                           shouldAppear:(BOOL)shouldAppear {
  [self updateControlBarsVisibility];
}
RootContainerViewController.m

Adicionar controle expandido

A Lista de verificação de design do Google Cast exige que um app remetente forneça um controle expandido para a mídia transmitida. O controle expandido é uma versão em tela cheia do minicontrole.

O controle expandido é uma visualização em tela cheia que oferece controle total da reprodução de mídia remota. Essa visualização permite que um app de transmissão gerencie todos os aspectos gerenciáveis de uma sessão de transmissão, com exceção do controle de volume do Web Receiver e do ciclo de vida da sessão (conectar/parar transmissão). Ela também oferece todas as informações de status sobre a sessão de mídia (artes, título, subtítulo etc.).

A funcionalidade dessa visualização é implementada pela classe GCKUIExpandedMediaControlsViewController.

A primeira coisa que você precisa fazer é ativar o controle expandido padrão no contexto de transmissão. Modifique o delegante do app para ativar o controle expandido padrão:

Swift

func applicationDidFinishLaunching(_ application: UIApplication) {
  ..

  GCKCastContext.sharedInstance().useDefaultExpandedMediaControls = true

  ...
}

Objective-C

- (BOOL)application:(UIApplication *)application
didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
  ...

  [GCKCastContext sharedInstance].useDefaultExpandedMediaControls = YES;

  ..
}

Adicione o seguinte código ao seu view controller para carregar o controle expandido quando o usuário começar a transmitir um vídeo:

Swift

func playSelectedItemRemotely() {
  GCKCastContext.sharedInstance().presentDefaultExpandedMediaControls()

  ...

  // Load your media
  sessionManager.currentSession?.remoteMediaClient?.loadMedia(mediaInformation)
}

Objective-C

- (void)playSelectedItemRemotely {
  [[GCKCastContext sharedInstance] presentDefaultExpandedMediaControls];

  ...

  // Load your media
  [self.sessionManager.currentSession.remoteMediaClient loadMedia:mediaInformation];
}

O controle expandido também será iniciado automaticamente quando o usuário tocar no minicontrole.

Quando o app de envio está reproduzindo uma transmissão ao vivo de vídeo ou áudio, o SDK mostra automaticamente um botão de reprodução/parada no lugar do botão de assistir/pausar no controle expandido.

Consulte Aplicar estilos personalizados ao seu app iOS para saber como o app de envio pode configurar a aparência dos widgets do Google Cast.

Controle do volume

O framework de transmissão gerencia automaticamente o volume do app de envio. O framework é sincronizado automaticamente com o volume do receptor da Web para os widgets de interface fornecidos. Para sincronizar um controle deslizante fornecido pelo app, use GCKUIDeviceVolumeController.

Controle de volume com botão físico

Aviso: devido a mudanças no iOS, o controle do volume de uma sessão do Google Cast usando os botões físicos de volume não é compatível com o iOS 15 e versões mais recentes. Estamos analisando alternativas para restaurar essa funcionalidade em uma versão futura.

Os botões físicos de volume no dispositivo de envio podem ser usados para mudar o volume da sessão do Google Cast no Web Receiver usando a flag physicalVolumeButtonsWillControlDeviceVolume no GCKCastOptions, que é definida no GCKCastContext.

Swift

let criteria = GCKDiscoveryCriteria(applicationID: kReceiverAppID)
let options = GCKCastOptions(discoveryCriteria: criteria)
options.physicalVolumeButtonsWillControlDeviceVolume = true
GCKCastContext.setSharedInstanceWith(options)

Objective-C

GCKDiscoveryCriteria *criteria = [[GCKDiscoveryCriteria alloc]
                                          initWithApplicationID:kReceiverAppID];
GCKCastOptions *options = [[GCKCastOptions alloc]
                                          initWithDiscoveryCriteria :criteria];
options.physicalVolumeButtonsWillControlDeviceVolume = YES;
[GCKCastContext setSharedInstanceWithOptions:options];

Solucionar erros

É muito importante que os apps de envio processem todos os callbacks de erro e decidam a melhor resposta para cada estágio do ciclo de vida do Cast. O app pode mostrar caixas de diálogo de erro para o usuário ou pode encerrar a sessão do Google Cast.

Logging

GCKLogger é um singleton usado para geração de registros pelo framework. Use o GCKLoggerDelegate para personalizar o processamento de mensagens de registro.

Usando o GCKLogger, o SDK produz a saída de registro na forma de mensagens de depuração, erros e avisos. Essas mensagens de registro ajudam na depuração e são úteis para resolver e identificar problemas. Por padrão, a saída do registro é suprimida, mas, ao atribuir um GCKLoggerDelegate, o app de envio pode receber essas mensagens do SDK e registrá-las no console do sistema.

Swift

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate, GCKLoggerDelegate {
  let kReceiverAppID = kGCKDefaultMediaReceiverApplicationID
  let kDebugLoggingEnabled = true

  var window: UIWindow?

  func applicationDidFinishLaunching(_ application: UIApplication) {
    ...

    // Enable logger.
    GCKLogger.sharedInstance().delegate = self

    ...
  }

  // MARK: - GCKLoggerDelegate

  func logMessage(_ message: String,
                  at level: GCKLoggerLevel,
                  fromFunction function: String,
                  location: String) {
    if (kDebugLoggingEnabled) {
      print(function + " - " + message)
    }
  }
}

Objective-C

AppDelegate.h

@interface AppDelegate () <GCKLoggerDelegate>
@end

AppDelegate.m

@implementation AppDelegate

static NSString *const kReceiverAppID = @"AABBCCDD";
static const BOOL kDebugLoggingEnabled = YES;

- (BOOL)application:(UIApplication *)application
didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
  ...

  // Enable logger.
  [GCKLogger sharedInstance].delegate = self;

  ...

  return YES;
}

...

#pragma mark - GCKLoggerDelegate

- (void)logMessage:(NSString *)message
           atLevel:(GCKLoggerLevel)level
      fromFunction:(NSString *)function
          location:(NSString *)location {
  if (kDebugLoggingEnabled) {
    NSLog(@"%@ - %@, %@", function, message, location);
  }
}

@end

Para ativar as mensagens de depuração e detalhadas, adicione esta linha ao código depois de definir o delegado (mostrado anteriormente):

Swift

let filter = GCKLoggerFilter.init()
filter.minimumLevel = GCKLoggerLevel.verbose
GCKLogger.sharedInstance().filter = filter

Objective-C

GCKLoggerFilter *filter = [[GCKLoggerFilter alloc] init];
[filter setMinimumLevel:GCKLoggerLevelVerbose];
[GCKLogger sharedInstance].filter = filter;

Também é possível filtrar as mensagens de registro produzidas por GCKLogger. Defina o nível mínimo de registro por classe, por exemplo:

Swift

let filter = GCKLoggerFilter.init()
filter.setLoggingLevel(GCKLoggerLevel.verbose, forClasses: ["GCKUICastButton",
                                                            "GCKUIImageCache",
                                                            "NSMutableDictionary"])
GCKLogger.sharedInstance().filter = filter

Objective-C

GCKLoggerFilter *filter = [[GCKLoggerFilter alloc] init];
[filter setLoggingLevel:GCKLoggerLevelVerbose
             forClasses:@[@"GCKUICastButton",
                          @"GCKUIImageCache",
                          @"NSMutableDictionary"
                          ]];
[GCKLogger sharedInstance].filter = filter;

Os nomes de classe podem ser literais ou padrões glob, por exemplo, GCKUI\* e GCK\*Session.