Ajouter des fonctionnalités avancées à votre application iOS

Coupures publicitaires

Le SDK expéditeur iOS est compatible avec les coupures publicitaires et les annonces associées dans une un flux multimédia donné.

Consultez le Présentation des coupures publicitaires Web receiver pour d'autres sur le fonctionnement des coupures publicitaires.

Bien que les coupures puissent être spécifiées à la fois au niveau de l'expéditeur et du destinataire, il est recommandé d'utiliser spécifiées sur Web Receiver et Android TV Receiver pour assurer la cohérence sur toutes les plates-formes.

Sur iOS, spécifiez les coupures publicitaires dans une commande de chargement avec GCKAdBreakClipInfo et 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]];

Vitesse de lecture variable

Votre application peut afficher l'élément multimédia en cours et en modifier la vitesse de lecture. Vous pouvez définir le taux en utilisant -[setPlaybackRate:] ou -[setPlaybackRate:customData:] sur GCKRemoteMediaClient, accédez à GCKUIPlaybackRateController à l'aide de playbackRateController du GCKUIMediaController et afficher la vitesse de lecture actuelle avec playbackRate des GCKUIPlaybackRateController.

Exemple de code

Les deux fichiers suivants implémentent GCKUIPlaybackRateController, qui contrôle la vitesse de lecture à l'aide d'une commande segmentée dont la vitesse est "normale", "demi-vitesse" et "double vitesse" boutons:

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

Ajouter un critère personnalisé

Le framework Cast propose deux méthodes pour créer une chaîne sur laquelle envoyer des messages personnalisés. vers un récepteur Web:

  1. GCKCastChannel est destiné à être sous-classé pour implémenter des canaux non triviaux qui ont l'état associé.
  2. GCKGenericChannel est fournie comme alternative au sous-classement ; il transmet les messages à un délégué afin qu'ils puissent être traités ailleurs.

Voici un exemple d'implémentation 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

Une chaîne peut être enregistrée à tout moment. si la session n'est pas en cours connecté, le canal est automatiquement connecté lorsque la session elle-même est connectée, à condition que l'espace de noms du canal soit présent dans la liste des espaces de noms compatibles des métadonnées de l'application Web Receiver.

Chaque critère personnalisé est défini par un espace de noms unique et doit commencer par le paramètre préfixe urn:x-cast:, par exemple, urn:x-cast:com.example.custom. Il est plusieurs critères personnalisés, chacun avec un espace de noms unique. La L'application Web Receiver peut également envoyer et recevoir messages utilisant le même espace de noms.

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

Pour fournir la logique qui doit s'exécuter lorsqu'un canal particulier devient connecté ou déconnecté, remplacez les éléments -[didConnect] et -[didDisconnect] si vous utilisez GCKCastChannel ou fournir des implémentations pour -[castChannelDidConnect:] et -[castChannelDidDisconnect:] méthodes de GCKGenericChannelDelegate si vous utilisez GCKGenericChannel.

Compatibilité avec la lecture automatique

Consultez la section Lecture automatique et API de mise en file d'attente.

Remplacer la sélection et la mise en cache des images

Plusieurs composants du framework (à savoir la boîte de dialogue Cast, le mini le contrôleur étendu GCKUIMediaController si cette option est configurée) affiche le visuel du contenu multimédia en cours de diffusion. Les URL à l'illustration sont généralement incluses GCKMediaMetadata pour les médias, mais l'application émettrice peut avoir une autre source pour les URL.

La GCKUIImagePicker Le protocole définit un moyen de sélectionner une image appropriée pour une utilisation donnée. et la taille souhaitée. Il comporte une seule méthode, -[getImageWithHints:fromMetadata:], qui prend un GCKUIImageHints et un GCKMediaMetadata en tant que paramètres et renvoie une GCKImage comme résultat. Le framework fournit une implémentation par défaut GCKUIImagePicker, qui sélectionne toujours la première image de la liste des images dans l'objet GCKMediaMetadata, mais l'application peut fournir une autre en définissant la propriété imagePicker de GCKCastContext singleton.

La GCKUIImageCache définit également un moyen de mettre en cache les images téléchargées par à l'aide du protocole HTTPS. Le framework fournit une implémentation par défaut GCKUIImageCache, qui stocke les fichiers image téléchargés dans le cache de l'application mais l'application peut fournir une autre implémentation en définissant propriété imageCache de GCKCastContext singleton.

Étapes suivantes

Les fonctionnalités que vous pouvez ajouter à votre application émettrice iOS sont maintenant terminées. Vous pouvez désormais créer une application émettrice pour une autre plate-forme (Android ou Web) ou créer un Web Receiver.

Précédent
Mise en file d'attente