Ihrer iOS-App erweiterte Funktionen hinzufügen

Werbeunterbrechungen

Das iOS-Sender-SDK unterstützt Werbeunterbrechungen und Companion-Anzeigen in einem bestimmten Mediastream.

Weitere Informationen zur Funktionsweise von Werbeunterbrechungen findest du in der Übersicht über Werbeunterbrechungen für Web Receiver.

Werbeunterbrechungen können sowohl auf dem Sender als auch auf dem Empfänger angegeben werden. Es wird jedoch empfohlen, sie auf dem Web Receiver und dem Android TV-Empfänger anzugeben, um ein einheitliches Verhalten auf allen Plattformen zu gewährleisten.

Geben Sie unter iOS Werbeunterbrechungen in einem Ladebefehl mit GCKAdBreakClipInfo und GCKAdBreakInfo an:

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

Variable Wiedergabegeschwindigkeit

Ihre App kann die Wiedergabegeschwindigkeit für die aktuelle Mediendatei anzeigen und ändern. Du kannst die Geschwindigkeit mit -[setPlaybackRate:] oder -[setPlaybackRate:customData:] des GCKRemoteMediaClient festlegen, mit playbackRateController des GCKUIMediaController auf GCKUIPlaybackRateController zugreifen und die aktuelle Wiedergabegeschwindigkeit mit playbackRate des GCKUIPlaybackRateController anzeigen.

Beispielcode

In den folgenden beiden Dateien wird GCKUIPlaybackRateController implementiert, um die Wiedergabegeschwindigkeit über ein segmentiertes Steuerelement mit den Schaltflächen „Normal“, „Halbe Geschwindigkeit“ und „Doppelte Geschwindigkeit“ zu steuern:

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

Benutzerdefinierten Channel hinzufügen

Das Cast-Framework bietet zwei Möglichkeiten, einen Kanal zum Senden benutzerdefinierter Nachrichten an einen Webempfänger zu erstellen:

  1. GCKCastChannel ist als Unterklasse gedacht, um nicht triviale Kanäle mit zugehörigem Status zu implementieren.
  2. GCKGenericChannel wird als Alternative zur Erstellung von Unterklassen bereitgestellt. Die empfangenen Nachrichten werden an einen Bevollmächtigten weitergeleitet, damit sie an anderer Stelle verarbeitet werden können.

Hier ein Beispiel für eine GCKCastChannel-Implementierung:

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

Ein Kanal kann jederzeit registriert werden. Wenn die Sitzung derzeit nicht verbunden ist, wird der Kanal automatisch verbunden, sobald die Sitzung verbunden ist, sofern der Namespace des Kanals in der Liste der unterstützten Namespaces der Metadaten der Web Receiver-Anwendung vorhanden ist.

Jeder benutzerdefinierte Kanal wird durch einen eindeutigen Namespace definiert und muss mit dem Präfix urn:x-cast: beginnen, z. B. urn:x-cast:com.example.custom. Es ist möglich, mehrere benutzerdefinierte Kanäle mit jeweils einem eindeutigen Namespace zu haben. Die Web-Empfänger-App kann auch Nachrichten über denselben Namespace senden und empfangen.

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

Wenn Sie Logik bereitstellen möchten, die ausgeführt werden soll, wenn ein bestimmter Kanal verbunden oder getrennt wird, überschreiben Sie die Methoden -[didConnect] und -[didDisconnect], wenn Sie GCKCastChannel verwenden, oder stellen Sie Implementierungen für die Methoden -[castChannelDidConnect:] und -[castChannelDidDisconnect:] von GCKGenericChannelDelegate bereit, wenn Sie GCKGenericChannel verwenden.

Autoplay unterstützen

Weitere Informationen findest du unter Autoplay & Queueing APIs.

Bildauswahl und Caching überschreiben

Verschiedene Komponenten des Frameworks (der Cast-Dialog, die Mini-Steuerung, die erweiterte Steuerung und die GCKUIMediaController, sofern konfiguriert) zeigen Cover für die aktuell gestreamten Medien an. Die URLs zu den Bild-Artworks sind normalerweise in den GCKMediaMetadata für die Medien enthalten, die Sender-App kann jedoch eine alternative Quelle für die URLs haben.

Das Protokoll GCKUIImagePicker definiert eine Möglichkeit, ein geeignetes Bild für eine bestimmte Verwendung und gewünschte Größe auszuwählen. Sie hat eine einzelne Methode, -[getImageWithHints:fromMetadata:], die ein GCKUIImageHints-Objekt und ein GCKMediaMetadata-Objekt als Parameter verwendet und ein GCKImage-Objekt als Ergebnis zurückgibt. Das Framework bietet eine Standardimplementierung von GCKUIImagePicker, die immer das erste Bild in der Liste der Bilder im GCKMediaMetadata-Objekt auswählt. Die App kann jedoch eine alternative Implementierung bereitstellen, indem sie die imagePicker-Property des GCKCastContext-Singletons festlegt.

Das Protokoll GCKUIImageCache definiert auch eine Möglichkeit, Bilder im Cache zu speichern, die vom Framework über HTTPS heruntergeladen werden. Das Framework bietet eine Standardimplementierung von GCKUIImageCache, die heruntergeladene Bilddateien im Cache-Verzeichnis der App speichert. Die App kann jedoch eine alternative Implementierung bereitstellen, indem sie die Property imageCache des Singletons GCKCastContext festlegt.

Nächste Schritte

Damit sind die Funktionen, die Sie Ihrer iOS-Sender-App hinzufügen können, vollständig. Sie können jetzt eine Sender-App für eine andere Plattform (Android oder Web) oder einen Web-Receiver erstellen.

Zurück
Warteschlange