Ihrer iOS-App erweiterte Funktionen hinzufügen

Werbeunterbrechungen

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

Weitere Informationen zu Werbeunterbrechungen finden Sie in der Übersicht zu Werbeunterbrechungen im Web Receiver für weitere Informationen dazu, wie Werbeunterbrechungen funktionieren.

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

Geben Sie auf 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

In Ihrer App können Sie die Wiedergabegeschwindigkeit für das aktuelle Media-Element anzeigen und ändern. Sie können die Geschwindigkeit mit -[setPlaybackRate:] oder -[setPlaybackRate:customData:] von GCKRemoteMediaClient festlegen, auf GCKUIPlaybackRateController mit playbackRateController von GCKUIMediaController zugreifen und die aktuelle Wiedergabegeschwindigkeit mit playbackRate von GCKUIPlaybackRateController anzeigen.

Beispielcode

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

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 Channel zu erstellen, um benutzerdefinierte Nachrichten an einen Web Receiver zu senden:

  1. GCKCastChannel soll untergeordnet werden, um nicht triviale Channels mit zugehörigem Status zu implementieren.
  2. GCKGenericChannel wird als Alternative zur Unterordnung bereitgestellt. Es übergibt die empfangenen Nachrichten an einen Delegaten, damit sie an anderer Stelle verarbeitet werden können.

Hier ist 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 Channel kann jederzeit registriert werden. Wenn sich die Sitzung derzeit nicht im verbundenen Status befindet, wird die Verbindung zum Channel automatisch hergestellt, wenn die Sitzung selbst verbunden ist. Voraussetzung dafür ist, dass der Namespace des Channels in der Liste der unterstützten Namespaces der Web Receiver-App-Metadaten vorhanden ist.

Jeder benutzerdefinierte Channel 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 können mehrere benutzerdefinierte Channels mit jeweils einem eindeutigen Namespace vorhanden sein. Die Web Receiver-App kann auch Nachrichten mit demselben 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 muss, wenn eine Verbindung zu einem bestimmten Channel hergestellt oder getrennt wird, überschreiben Sie die -[didConnect] und -[didDisconnect] Methoden, wenn Sie GCKCastChannel verwenden. Alternativ können Sie Implementierungen für die -[castChannelDidConnect:] und -[castChannelDidDisconnect:] Methoden von GCKGenericChannelDelegate bereitstellen, wenn Sie GCKGenericChannel verwenden.

Automatische Wiedergabe unterstützen

Weitere Informationen finden Sie unter APIs für automatische Wiedergabe und Warteschlangen.

Bildauswahl und -caching überschreiben

In verschiedenen Komponenten des Frameworks (nämlich im Cast-Dialogfeld, im Mini Controller, im erweiterten Controller und im GCKUIMediaController, falls so konfiguriert) werden Grafiken für die aktuell gestreamten Medien angezeigt. Die URLs zu den Grafiken sind in der Regel in den GCKMediaMetadata für die Medien enthalten. Die Sender-App kann jedoch eine alternative Quelle für die URLs haben.

Das GCKUIImagePicker -Protokoll definiert eine Möglichkeit, ein geeignetes Bild für eine bestimmte Verwendung und gewünschte Größe auszuwählen. Es hat eine einzige 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 in dem GCKMediaMetadata Objekt auswählt. Die App kann jedoch eine alternative Implementierung bereitstellen, indem sie die imagePicker Eigenschaft des GCKCastContext Singleton festlegt.

Das GCKUIImageCache Protokoll definiert auch eine Möglichkeit, Bilder zu cachen, 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 imageCache-Eigenschaft des GCKCastContext -Singleton festlegt.

Nächste Schritte

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

Zurück
Warteschlange