Ta strona została przetłumaczona przez Cloud Translation API.

Dodaj zaawansowane funkcje do swojej aplikacji na iOS

Przerwy na reklamy

Pakiet SDK iOS Sender zapewnia obsługę przerw na reklamy i reklam towarzyszących w określonym strumieniu multimediów.

Przeczytaj omówienie przerw na reklamy w odbiorniku internetowym, aby dowiedzieć się więcej o tym, jak działają przerwy na reklamy.

Chociaż przerwy można określić zarówno u nadawcy, jak i u odbiorcy, zalecamy to jednak zrobić w odbiorniku internetowym i odbiorniku Android TV, aby zachować spójność działania na różnych platformach.

W systemie iOS przerwy na reklamy możesz określić w poleceniu wczytywania za pomocą właściwości 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ą funkcji -[setPlaybackRate:] lub -[setPlaybackRate:customData:] funkcji GCKRemoteMediaClient, uzyskać dostęp do GCKUIPlaybackRateController za pomocą elementu playbackRateController z GCKUIMediaController i wyświetlić aktualną szybkość odtwarzania za pomocą parametru playbackRate z GCKUIPlaybackRateController.

Przykładowy kod

W tych 2 plikach zaimplementowano element GCKUIPlaybackRateController, który steruje szybkością odtwarzania za pomocą segmentacji zawierającej przyciski „normalna”, „połowa prędkości” i „podwójna prędkość”:

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 wysyłającego niestandardowe wiadomości do odbiornika internetowego na 2 sposoby:

GCKCastChannel należy do podklasyfikacji, aby zaimplementować proste kanały, które mają stan powiązany.
Obiekt GCKGenericChannel jest dostępny jako alternatywa dla podklasy. Przekazuje odebrane wiadomości do przedstawiciela, aby można było 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 dowolnym momencie. Jeśli sesja nie jest obecnie w stanie połączenia, kanał zostanie automatycznie połączony po połączeniu sesji, o ile przestrzeń nazw kanału znajduje się na liście obsługiwanych przestrzeni nazw aplikacji Odbiornik internetowy.

Każdy kanał niestandardowy jest definiowany przez unikalną przestrzeń nazw i musi zaczynać się 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 Receiver może też wysyłać i odbierać wiadomości w 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 być wykonywana, gdy określony kanał zostanie połączony lub odłączony, zastąp metody -[didConnect] i -[didDisconnect], jeśli używasz GCKCastChannel, lub podaj implementacje metod -[castChannelDidConnect:] i -[castChannelDidDisconnect:] metody GCKGenericChannelDelegate, jeśli używasz GCKGenericChannel.

Obsługa autoodtwarzania

Przeczytaj artykuł Interfejsy API autoodtwarzania i kolejek.

Zastąp wybór obrazów i buforowanie

Różne komponenty platformy (takie jak okno Cast, minikontroler, rozwinięty kontroler i GCKUIMediaController – jeśli zostały skonfigurowane) będą wyświetlać grafikę aktualnie przesyłanych multimediów. Adresy URL grafiki są zwykle zawarte w elemencie GCKMediaMetadata multimediów, ale aplikacja nadawcy może mieć alternatywne źródło tych adresów.

Protokół GCKUIImagePicker określa sposoby wyboru odpowiedniego obrazu do danego zastosowania i pożądanego rozmiaru. Ma on jedną metodę (-[getImageWithHints:fromMetadata:]), która jako parametry pobiera obiekt GCKUIImageHints i obiekt GCKMediaMetadata, a jako wynik 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, ale aplikacja może zapewnić alternatywną implementację, ustawiając właściwość imagePicker obiektu singleton GCKCastContext.

Protokół GCKUIImageCache określa również sposób buforowania obrazów pobranych przez platformę za pomocą protokołu HTTPS. Platforma udostępnia domyślną implementację tagu GCKUIImageCache, który przechowuje pobrane pliki obrazów w katalogu pamięci podręcznej aplikacji. Aplikacja może jednak zapewnić alternatywną implementację, ustawiając właściwość imageCache klasy GCKCastContext singleton.

Dalsze kroki

To już wszystkie funkcje, które możesz dodać do aplikacji nadawcy na iOS. Możesz teraz utworzyć aplikację nadawcy na inną platformę (na Androida lub internet) lub odbiornik internetowy.

Wstecz

Kolejkowanie