Dodaj zaawansowane funkcje do swojej aplikacji na iOS

Przerwy na reklamy

Pakiet SDK nadawcy na iOS obsługuje przerwy na reklamę i reklamy towarzyszące w danym strumieniu multimediów.

Więcej informacji o tym, jak działają przerwy na reklamę, znajdziesz w artykule Przegląd przerw na reklamę w odbiorniku internetowym.

Przerwy można określić zarówno po stronie nadawcy, jak i odbiornika, ale zalecamy, aby były one określone w odbiorniku internetowym i odbiorniku Android TV, aby zachować spójne działanie na różnych platformach.

W systemie iOS określ przerwy na reklamę w poleceniu wczytywania, używając GCKAdBreakClipInfo i 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]];

Zmienna szybkość odtwarzania

Aplikacja może wyświetlać i zmieniać szybkość odtwarzania bieżącego elementu multimedialnego. Szybkość możesz ustawić za pomocą właściwości -[setPlaybackRate:] lub -[setPlaybackRate:customData:] interfejsu GCKRemoteMediaClient, uzyskać dostęp do GCKUIPlaybackRateController za pomocą właściwości playbackRateController interfejsu GCKUIMediaController i wyświetlić bieżącą szybkość odtwarzania za pomocą właściwości playbackRate interfejsu GCKUIPlaybackRateController.

Przykładowy kod

Te 2 pliki implementują element GCKUIPlaybackRateController, który kontroluje szybkość odtwarzania za pomocą elementu sterującego z przyciskami „normalna”, „pół szybkości” i „podwójna szybkość”:

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

Dodawanie kanału niestandardowego

Platforma Cast umożliwia utworzenie kanału do wysyłania wiadomości niestandardowych do odbiornika internetowego na 2 sposoby:

  1. GCKCastChannel jest przeznaczona do tworzenia podklas w celu implementacji nietrywialnych kanałów, które mają powiązany stan.
  2. GCKGenericChannel jest alternatywą dla podklas. Przekazuje otrzymane wiadomości do delegata, aby można je było przetworzyć w innym miejscu.

Oto przykład implementacji 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

Kanał można zarejestrować w dowolnym momencie. Jeśli sesja nie jest obecnie połączona, kanał zostanie automatycznie połączony, gdy sesja zostanie połączona, pod warunkiem że przestrzeń nazw kanału znajduje się na liście obsługiwanych przestrzeni nazw w metadanych aplikacji odbiornika internetowego.

Każdy kanał niestandardowy jest definiowany przez unikalną przestrzeń nazw i musi zaczynać się od prefiksu urn:x-cast:, na przykład urn:x-cast:com.example.custom. Możesz mieć wiele kanałów niestandardowych, z których każdy ma unikalną przestrzeń nazw. Aplikacja odbiornika internetowego może też wysyłać i odbierać wiadomości przy użyciu tej samej przestrzeni nazw.

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

Aby zapewnić logikę, która musi zostać wykonana, gdy dany kanał zostanie połączony lub rozłączony, zastąp metody -[didConnect] i -[didDisconnect], jeśli używasz GCKCastChannel, lub podaj implementacje metod -[castChannelDidConnect:] i -[castChannelDidDisconnect:] interfejsu GCKGenericChannelDelegate, jeśli używasz GCKGenericChannel.

Obsługa autoodtwarzania

Zobacz interfejsy API autoodtwarzania i kolejkowania.

Zastępowanie wyboru i buforowania obrazów

Różne komponenty platformy (czyli okno Cast, miniodtwarzacz, rozszerzony odtwarzacz i GCKUIMediaController, jeśli jest skonfigurowany) będą wyświetlać grafikę aktualnie przesyłanych multimediów. Adresy URL grafiki są zwykle zawarte w GCKMediaMetadata multimediów, ale aplikacja nadawcy może mieć alternatywne źródło adresów URL.

Protokół GCKUIImagePicker określa sposób wyboru odpowiedniego obrazu do danego zastosowania i żądanego rozmiaru. Ma jedną metodę, -[getImageWithHints:fromMetadata:], która przyjmuje obiekt GCKUIImageHints i obiekt GCKMediaMetadata jako parametry i zwraca obiekt GCKImage jako wynik. Platforma udostępnia domyślną implementację GCKUIImagePicker, która zawsze wybiera pierwszy obraz z listy obrazów w obiekcie GCKMediaMetadata, ale aplikacja może udostępnić alternatywną implementację, ustawiając właściwość imagePicker obiektu pojedynczego GCKCastContext.

Protokół GCKUIImageCache definiuje też sposób buforowania obrazów pobieranych przez platformę za pomocą protokołu HTTPS. Platforma udostępnia domyślną implementację interfejsu GCKUIImageCache, która przechowuje pobrane pliki graficzne w katalogu pamięci podręcznej aplikacji, ale aplikacja może udostępniać alternatywną implementację, ustawiając właściwość imageCache obiektu pojedynczego GCKCastContext.

Dalsze kroki

To już wszystkie funkcje, które możesz dodać do aplikacji nadawczej na iOS. Możesz teraz utworzyć aplikację nadawczą na inną platformę (Android lub sieć) albo aplikację odbiornika internetowego.

Wstecz
Kolejkowanie