Dodaj zaawansowane funkcje do swojej aplikacji na iOS

Przerwy na reklamy

Pakiet SDK dla nadawców na iOS zapewnia obsługę przerw na reklamę i reklam towarzyszących w danym strumieniu multimediów.

Więcej informacji o tym, jak działają przerwy na reklamy, znajdziesz w artykule o przerwach na reklamy w odbiorniku internetowym.

Przerwy można określić zarówno w przypadku nadawcy, jak i odbiorcy, ale zaleca się, aby były one określone w odbiorniku internetowym i odbiorniku Android TV. Pozwoli to zachować spójność działania na różnych platformach.

Na urządzeniu z iOS przerwy na reklamy określ w poleceniu wczytywania za pomocą 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. Możesz ustawić szybkość za pomocą -[setPlaybackRate:] lub -[setPlaybackRate:customData:] GCKRemoteMediaClient, uzyskać dostęp do GCKUIPlaybackRateController za pomocą playbackRateController parametru GCKUIMediaController i wyświetlić bieżącą szybkość odtwarzania za pomocą playbackRate z GCKUIPlaybackRateController.

Przykładowy kod

W tych 2 plikach zaimplementowano tag GCKUIPlaybackRateController, który steruje szybkością odtwarzania za pomocą podzielonego elementu sterującego z przyciskami „normalna”, „połowa prędkoś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 udostępnia 2 sposoby tworzenia kanału służącego do wysyłania niestandardowych wiadomości do odbiornika internetowego:

  1. Metoda GCKCastChannel jest podklasą do wdrażania nieprostych kanałów, które są powiązane ze stanem konta.
  2. klasa GCKGenericChannel jest alternatywą dla podklas; przekazuje odebrane wiadomości do przedstawiciela, aby mógł je 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 dowolnej chwili. Jeśli sesja nie jest obecnie w stanie połączenia, zostanie on połączony automatycznie po podłączeniu samej sesji, o ile przestrzeń nazw kanału znajduje się na liście obsługiwanych przestrzeni nazw w metadanych aplikacji odbiornika internetowego.

Każdy kanał niestandardowy jest zdefiniowany przez niepowtarzalną przestrzeń nazw i musi się zaczynać od prefiksu urn:x-cast:, np. urn:x-cast:com.example.custom. Możesz mieć wiele kanałów niestandardowych, każdy z unikalną przestrzenią nazw. Aplikacja Web Receivedr może też wysyłać i odbierać wiadomości, korzystając z 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ć działanie logiki, która jest uruchamiana po podłączeniu lub rozłączeniu danego kanału, zastąp metody -[didConnect] i -[didDisconnect], jeśli używasz GCKCastChannel, lub podaj implementacje metod -[castChannelDidConnect:] i -[castChannelDidDisconnect:] GCKGenericChannelDelegate, jeśli używasz GCKGenericChannel.

Obsługa autoodtwarzania

Zobacz Interfejsy API automatycznego odtwarzania i kolejkowania.

Zastąp wybór obrazu i zapisywanie w pamięci podręcznej

Różne komponenty platformy (np. okno przesyłania, minikontroler, rozwinięty kontroler i GCKUIMediaController, jeśli tak są skonfigurowane) wyświetlają elementy graficzne dla aktualnie przesyłanych multimediów. Adresy URL grafiki obrazu zwykle znajdują się w sekcji GCKMediaMetadata dotyczącej mediów, ale aplikacja nadawcy może mieć alternatywne źródło tych adresów.

Protokół GCKUIImagePicker określa sposoby wybierania obrazów odpowiednich do danego zastosowania i oczekiwanego rozmiaru. Ma jedną metodę -[getImageWithHints:fromMetadata:], która wybiera jako parametry obiekt GCKUIImageHints i obiekt GCKMediaMetadata, a w wyniku zwraca obiekt GCKImage. Platforma udostępnia domyślną implementację funkcji GCKUIImagePicker, która zawsze wybiera pierwszy obraz na liście obrazów w obiekcie GCKMediaMetadata. Aplikacja może jednak udostępniać implementację alternatywną, ustawiając właściwość imagePicker elementu GCKCastContext.

Protokół GCKUIImageCache określa też sposoby buforowania obrazów pobieranych przez platformę za pomocą HTTPS. Platforma udostępnia domyślną implementację GCKUIImageCache, która przechowuje pobrane pliki obrazów w katalogu pamięci podręcznej aplikacji. Aplikacja może jednak udostępniać inną implementację, ustawiając właściwość imageCache elementu GCKCastContext singleton.

Dalsze kroki

To już koniec funkcji, które możesz dodać do aplikacji nadawcy na iOS. Teraz możesz utworzyć aplikację nadawcy na inną platformę (Android lub internet) albo utworzyć odbiornik internetowy.