Intégrer Cast à votre application iOS

Ce guide du développeur explique comment ajouter la compatibilité avec Google Cast à votre application émettrice iOS à l'aide du SDK de l'émetteur iOS.

L'appareil mobile ou l'ordinateur portable est l'émetteur qui contrôle la lecture, et l'appareil Google Cast est le récepteur qui affiche le contenu sur le téléviseur.

Le framework de l'expéditeur fait référence au binaire de la bibliothèque de classes Cast et aux ressources associées présentes au moment de l'exécution sur l'expéditeur. L'application émettrice ou l'application Cast désigne une application qui s'exécute également sur l'émetteur. L'application réceptrice Web fait référence à l'application HTML exécutée sur le récepteur Web.

Le framework de l'expéditeur utilise une conception de rappel asynchrone pour informer l'application émettrice des événements et pour passer d'un état à un autre du cycle de vie de l'application Cast.

Déroulement des opérations de l'application

Les étapes suivantes décrivent le flux d'exécution général standard d'une application iOS émettrice :

  • Le framework Cast démarre GCKDiscoveryManager en fonction des propriétés fournies dans GCKCastOptions pour commencer à rechercher des appareils.
  • Lorsque l'utilisateur clique sur l'icône Cast, le framework affiche la boîte de dialogue Cast avec la liste des appareils Cast détectés.
  • Lorsque l'utilisateur sélectionne un appareil Cast, le framework tente de lancer l'application Web Receiver sur l'appareil Cast.
  • Le framework appelle des rappels dans l'application émettrice pour confirmer que l'application réceptrice Web a été lancée.
  • Le framework crée un canal de communication entre l'application émettrice et l'application réceptrice Web.
  • Le framework utilise le canal de communication pour charger et contrôler la lecture de contenus multimédias sur le récepteur Web.
  • Le framework synchronise l'état de lecture multimédia entre l'expéditeur et le récepteur Web : lorsque l'utilisateur effectue des actions dans l'UI de l'expéditeur, le framework transmet ces requêtes de contrôle multimédia au récepteur Web. Lorsque le récepteur Web envoie des mises à jour de l'état multimédia, le framework met à jour l'état de l'UI de l'expéditeur.
  • Lorsque l'utilisateur clique sur l'icône Cast pour se déconnecter de l'appareil Cast, le framework déconnecte l'application émettrice du récepteur Web.

Pour résoudre les problèmes liés à votre émetteur, vous devez activer la journalisation.

Pour obtenir la liste complète de toutes les classes, méthodes et événements du framework Google Cast pour iOS, consultez la documentation de référence de l'API Google Cast pour iOS. Les sections suivantes décrivent les étapes à suivre pour intégrer Cast à votre application iOS.

Appeler des méthodes à partir du thread principal

Initialiser le contexte Cast

Le framework Cast possède un objet singleton global, GCKCastContext, qui coordonne toutes les activités du framework. Cet objet doit être initialisé au début du cycle de vie de l'application, généralement dans la méthode -[application:didFinishLaunchingWithOptions:] du délégué de l'application, afin que la reprise automatique de la session au redémarrage de l'application émettrice puisse se déclencher correctement.

Un objet GCKCastOptions doit être fourni lors de l'initialisation de GCKCastContext. Cette classe contient des options qui affectent le comportement du framework. Le plus important est l'ID d'application du récepteur Web, qui permet de filtrer les résultats de découverte et de lancer l'application de récepteur Web lorsqu'une session Cast est démarrée.

La méthode -[application:didFinishLaunchingWithOptions:] est également un bon endroit pour configurer un délégué de journalisation afin de recevoir les messages de journalisation du framework. Elles peuvent être utiles pour le débogage et le dépannage.

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

Widgets d'interface utilisateur Cast

Le SDK Cast pour iOS fournit les widgets suivants, qui sont conformes à la checklist de conception Cast :

  • Superposition d'introduction : la classe GCKCastContext dispose d'une méthode, presentCastInstructionsViewControllerOnceWithCastButton, qui peut être utilisée pour mettre en avant l'icône Cast la première fois qu'un récepteur Web est disponible. L'application émettrice peut personnaliser le texte, la position du titre et le bouton "Ignorer".

  • Icône Cast : À partir de la version 4.6.0 du SDK de l'émetteur Cast pour iOS, l'icône Cast est toujours visible lorsque l'appareil émetteur est connecté au Wi-Fi. La première fois que l'utilisateur appuie sur l'icône Cast après avoir lancé l'application, une boîte de dialogue d'autorisation s'affiche pour lui permettre d'accorder à l'application l'accès au réseau local pour les appareils du réseau. Ensuite, lorsque l'utilisateur appuie sur l'icône Cast, une boîte de dialogue Cast s'affiche et liste les appareils détectés. Lorsque l'utilisateur appuie sur l'icône Cast alors que l'appareil est connecté, les métadonnées multimédias actuelles (telles que le titre, le nom du studio d'enregistrement et une vignette) s'affichent ou l'utilisateur peut se déconnecter de l'appareil Cast. Lorsque l'utilisateur appuie sur l'icône Cast alors qu'aucun appareil n'est disponible, un écran s'affiche pour lui expliquer pourquoi les appareils sont introuvables et comment résoudre le problème.

  • Mini-contrôleur : lorsque l'utilisateur caste du contenu et qu'il a quitté la page de contenu actuelle ou le contrôleur développé pour accéder à un autre écran de l'application émettrice, le mini-contrôleur s'affiche en bas de l'écran pour lui permettre de voir les métadonnées du contenu multimédia en cours de diffusion et de contrôler la lecture.

  • Contrôleur développé : lorsque l'utilisateur caste du contenu, s'il clique sur la notification multimédia ou le mini-contrôleur, le contrôleur développé se lance. Il affiche les métadonnées du contenu multimédia en cours de lecture et fournit plusieurs boutons pour contrôler la lecture multimédia.

Ajouter un bouton Cast

Le framework fournit un composant de bouton Cast en tant que sous-classe UIButton. Il peut être ajouté à la barre de titre de l'application en l'encapsulant dans un UIBarButtonItem. Une sous-classe UIViewController type peut installer un bouton Cast comme suit :

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];

Par défaut, appuyer sur le bouton ouvre la boîte de dialogue Cast fournie par le framework.

GCKUICastButton peut également être ajouté directement au storyboard.

Configurer la détection d'appareils

Dans le framework, la découverte d'appareils s'effectue automatiquement. Il n'est pas nécessaire de démarrer ou d'arrêter explicitement le processus de découverte, sauf si vous implémentez une UI personnalisée.

La découverte dans le framework est gérée par la classe GCKDiscoveryManager, qui est une propriété de GCKCastContext. Le framework fournit un composant de boîte de dialogue Cast par défaut pour la sélection et le contrôle des appareils. La liste des appareils est classée par ordre lexicographique en fonction du nom descriptif de l'appareil.

Fonctionnement de la gestion des sessions

Le SDK Cast introduit le concept de session Cast, dont l'établissement combine les étapes de connexion à un appareil, de lancement (ou de participation) d'une application Web Receiver, de connexion à cette application et d'initialisation d'un canal de contrôle multimédia. Pour en savoir plus sur les sessions Cast et le cycle de vie du récepteur Web, consultez le guide sur le cycle de vie des applications du récepteur Web.

Les sessions sont gérées par la classe GCKSessionManager, qui est une propriété de GCKCastContext. Les sessions individuelles sont représentées par des sous-classes de la classe GCKSession. Par exemple, GCKCastSession représente les sessions avec des appareils Cast. Vous pouvez accéder à la session Cast actuellement active (le cas échéant) en tant que propriété currentCastSession de GCKSessionManager.

L'interface GCKSessionManagerListener permet de surveiller les événements de session, tels que la création, la suspension, la reprise et l'arrêt d'une session. Le framework suspend automatiquement les sessions lorsque l'application émettrice passe en arrière-plan et tente de les reprendre lorsqu'elle revient au premier plan (ou est relancée après un arrêt anormal/brusque de l'application alors qu'une session était active).

Si la boîte de dialogue Cast est utilisée, les sessions sont créées et supprimées automatiquement en réponse aux gestes de l'utilisateur. Sinon, l'application peut démarrer et terminer des sessions explicitement via des méthodes sur GCKSessionManager.

Si l'application doit effectuer un traitement spécial en réponse aux événements de cycle de vie de la session, elle peut enregistrer une ou plusieurs instances GCKSessionManagerListener auprès de GCKSessionManager. GCKSessionManagerListener est un protocole qui définit des rappels pour des événements tels que le début et la fin d'une session, etc.

Transfert de diffusion

La préservation de l'état de la session est à la base du transfert de diffusion, qui permet aux utilisateurs de déplacer des flux audio et vidéo existants d'un appareil à l'autre à l'aide de commandes vocales, de l'application Google Home ou d'écrans connectés. La lecture du contenu multimédia s'arrête sur un appareil (la source) et se poursuit sur un autre (la destination). Tout appareil Cast équipé du dernier micrologiciel peut servir de source ou de destination dans un transfert de diffusion.

Pour obtenir le nouvel appareil de destination lors du transfert de diffusion, utilisez la propriété GCKCastSession#device lors du rappel [sessionManager:didResumeCastSession:].

Pour en savoir plus, consultez Transfert de diffusion sur le récepteur Web.

Reconnexion automatique

Le framework Cast ajoute une logique de reconnexion pour gérer automatiquement la reconnexion dans de nombreux cas particuliers, par exemple :

  • Récupération après une perte temporaire de connexion Wi-Fi
  • Sortir de la mise en veille de l'appareil
  • Récupérer après l'exécution de l'application en arrière-plan
  • Récupérer l'application si elle a planté

Fonctionnement du contrôle multimédia

Si une session Cast est établie avec une application de récepteur Web compatible avec l'espace de noms multimédia, une instance de GCKRemoteMediaClient est créée automatiquement par le framework. Elle est accessible en tant que propriété remoteMediaClient de l'instance GCKCastSession.

Toutes les méthodes de GCKRemoteMediaClient qui envoient des requêtes au récepteur Web renvoient un objet GCKRequest qui peut être utilisé pour suivre cette requête. Un GCKRequestDelegate peut être attribué à cet objet pour recevoir des notifications sur le résultat final de l'opération.

L'instance de GCKRemoteMediaClient peut être partagée par plusieurs parties de l'application. En effet, certains composants internes du framework, tels que la boîte de dialogue Cast et les mini-commandes multimédias, partagent l'instance. Pour ce faire, GCKRemoteMediaClient accepte l'enregistrement de plusieurs GCKRemoteMediaClientListener.

Définir les métadonnées de contenus multimédias

La classe GCKMediaMetadata représente les informations sur un élément multimédia que vous souhaitez caster. L'exemple suivant crée une instance GCKMediaMetadata d'un film et définit le titre, le sous-titre, le nom du studio d'enregistrement et deux images.

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]];

Consultez la section Sélection et mise en cache des images pour en savoir plus sur l'utilisation des images avec les métadonnées multimédias.

Charger le contenu multimédia

Pour charger un élément multimédia, créez une instance GCKMediaInformation à l'aide des métadonnées de l'élément multimédia. Ensuite, récupérez l'objet GCKCastSession actuel et utilisez son GCKRemoteMediaClient pour charger le contenu multimédia dans l'application réceptrice. Vous pouvez ensuite utiliser GCKRemoteMediaClient pour contrôler une application de lecteur multimédia exécutée sur le récepteur, par exemple pour lire, mettre en pause et arrêter.

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

Consultez également la section sur l'utilisation des pistes multimédias.

Format vidéo 4K

Pour déterminer le format vidéo de votre contenu multimédia, utilisez la propriété videoInfo de GCKMediaStatus pour obtenir l'instance actuelle de GCKVideoInfo. Cette instance contient le type de format de téléviseur HDR, ainsi que la hauteur et la largeur en pixels. Les variantes du format 4K sont indiquées dans la propriété hdrType par les valeurs d'énumération GCKVideoInfoHDRType.

Ajouter des mini-contrôleurs

Selon la checklist de conception Cast, une application émettrice doit fournir une commande persistante appelée mini-télécommande qui doit s'afficher lorsque l'utilisateur quitte la page de contenu actuelle. Le mini-contrôleur offre un accès instantané et un rappel visible de la session Cast en cours.

Le framework Cast fournit une barre de contrôle, GCKUIMiniMediaControlsViewController, qui peut être ajoutée aux scènes dans lesquelles vous souhaitez afficher la mini-télécommande.

Lorsque votre application émettrice lit un flux vidéo ou audio en direct, le SDK affiche automatiquement un bouton de lecture/arrêt à la place du bouton de lecture/pause dans le mini-contrôleur.

Consultez Personnaliser l'UI de l'émetteur iOS pour savoir comment votre application émettrice peut configurer l'apparence des widgets Cast.

Il existe deux façons d'ajouter le mini-contrôleur à une application émettrice :

  • Laissez le framework Cast gérer la mise en page du mini-contrôleur en encapsulant votre contrôleur de vue existant avec son propre contrôleur de vue.
  • Gérez vous-même la mise en page du widget mini-télécommande en l'ajoutant à votre contrôleur de vue existant en fournissant une sous-vue dans le storyboard.

Encapsuler à l'aide de GCKUICastContainerViewController

La première méthode consiste à utiliser GCKUICastContainerViewController, qui encapsule un autre contrôleur de vue et ajoute un GCKUIMiniMediaControlsViewController en bas. Cette approche est limitée, car vous ne pouvez pas personnaliser l'animation ni configurer le comportement du contrôleur de vue du conteneur.

Cette première méthode est généralement effectuée dans la méthode -[application:didFinishLaunchingWithOptions:] du délégué de l'application :

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];
  ...

}
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

Intégrer dans un contrôleur de vue existant

La deuxième méthode consiste à ajouter le mini-contrôleur directement à votre contrôleur de vue existant en utilisant createMiniMediaControlsViewController pour créer une instance GCKUIMiniMediaControlsViewController, puis en l'ajoutant au contrôleur de vue du conteneur en tant que sous-vue.

Configurez votre contrôleur de vue dans le délégué de l'application :

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

Dans votre contrôleur de vue racine, créez une instance GCKUIMiniMediaControlsViewController et ajoutez-la au contrôleur de vue du conteneur en tant que sous-vue :

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

GCKUIMiniMediaControlsViewControllerDelegate indique au contrôleur de vue hôte quand le mini-contrôleur doit être visible :

Swift
  func miniMediaControlsViewController(_: GCKUIMiniMediaControlsViewController,
                                       shouldAppear _: Bool) {
    updateControlBarsVisibility()
  }
Objective-C
- (void)miniMediaControlsViewController:
            (GCKUIMiniMediaControlsViewController *)miniMediaControlsViewController
                           shouldAppear:(BOOL)shouldAppear {
  [self updateControlBarsVisibility];
}

Ajouter un contrôleur développé

La checklist de conception Google Cast exige qu'une application émettrice fournisse un contrôleur développé pour le contenu multimédia diffusé. Le contrôleur développé est une version plein écran du mini-contrôleur.

Le contrôleur développé est une vue plein écran qui offre un contrôle total de la lecture multimédia à distance. Cette vue doit permettre à une application de diffusion de gérer tous les aspects gérables d'une session de diffusion, à l'exception du contrôle du volume du récepteur Web et du cycle de vie de la session (connexion/arrêt de la diffusion). Il fournit également toutes les informations d'état sur la session multimédia (illustration, titre, sous-titre, etc.).

La fonctionnalité de cette vue est implémentée par la classe GCKUIExpandedMediaControlsViewController.

La première chose à faire est d'activer le contrôleur développé par défaut dans le contexte Cast. Modifiez le délégué de l'application pour activer le contrôleur développé par défaut :

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

  GCKCastContext.sharedInstance().useDefaultExpandedMediaControls = true

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

  [GCKCastContext sharedInstance].useDefaultExpandedMediaControls = YES;

  ..
}

Ajoutez le code suivant à votre contrôleur de vue pour charger le contrôleur développé lorsque l'utilisateur commence à caster une vidéo :

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

Le contrôleur développé sera également lancé automatiquement lorsque l'utilisateur appuiera sur le mini-contrôleur.

Lorsque votre application émettrice lit un flux vidéo ou audio en direct, le SDK affiche automatiquement un bouton de lecture/arrêt à la place du bouton de lecture/pause dans le contrôleur développé.

Consultez Appliquer des styles personnalisés à votre application iOS pour savoir comment votre application émettrice peut configurer l'apparence des widgets Cast.

Réglage du volume

Le framework Cast gère automatiquement le volume de l'application émettrice. Il se synchronise automatiquement avec le volume du récepteur Web pour les widgets d'interface utilisateur fournis. Pour synchroniser un curseur fourni par l'application, utilisez GCKUIDeviceVolumeController.

Contrôle du volume par bouton physique

Les boutons de volume physiques de l'appareil émetteur peuvent être utilisés pour modifier le volume de la session Cast sur le récepteur Web à l'aide de l'option physicalVolumeButtonsWillControlDeviceVolume sur GCKCastOptions, qui est définie sur 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];

Gérer les erreurs

Il est très important que les applications émettrices gèrent tous les rappels d'erreur et décident de la meilleure réponse pour chaque étape du cycle de vie Cast. L'application peut afficher des boîtes de dialogue d'erreur à l'utilisateur ou décider de mettre fin à la session Cast.

Notez que certaines erreurs, y compris GCKErrorCode GCKErrorCodeCancelled, sont un comportement attendu.

N'essayez pas de relancer une connexion qui a échoué avec GCKErrorCodeCancelled. Le non-respect de ces bonnes pratiques peut entraîner un comportement inattendu.

Journalisation

GCKLogger est un singleton utilisé pour la journalisation par le framework. Utilisez GCKLoggerDelegate pour personnaliser la façon dont vous gérez les messages de journal.

À l'aide de GCKLogger, le SDK génère une sortie de journalisation sous la forme de messages de débogage, d'erreurs et d'avertissements. Ces messages de journal facilitent le débogage et sont utiles pour le dépannage et l'identification des problèmes. Par défaut, la sortie du journal est supprimée, mais en attribuant un GCKLoggerDelegate, l'application émettrice peut recevoir ces messages du SDK et les consigner dans la console système.

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

Pour activer également les messages de débogage et les messages détaillés, ajoutez cette ligne au code après avoir défini le délégué (comme indiqué précédemment) :

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;

Vous pouvez également filtrer les messages de journal produits par GCKLogger. Définissez le niveau de journalisation minimal par classe, par exemple :

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;

Les noms de classe peuvent être des noms littéraux ou des formats glob, par exemple GCKUI\* et GCK\*Session.

Précédent
Autorisations et visibilité sur iOS
Suivant
Personnaliser l'interface utilisateur