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

Dodaj zaawansowane funkcje do swojej aplikacji na iOS

Przerwy na reklamy

Pakiet SDK Sender SDK na iOS zapewnia obsługę przerw na reklamy i reklam towarzyszących w danego strumienia multimediów.

Zobacz Omówienie przerw na reklamy w odbiorniku internetowym, aby dowiedzieć się więcej jak działają przerwy na reklamę.

Chociaż przerwy można określić zarówno u nadawcy, jak i u odbiorcy, zalecamy, aby były one określone na odbiorniku internetowym oraz Odbiornik Android TV, aby zachować spójność zachowania użytkowników na różnych platformach.

W systemie iOS przerwy na reklamy należy określić w poleceniu wczytywania za pomocą polecenia 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ć stawkę za pomocą: -[setPlaybackRate:] lub -[setPlaybackRate:customData:] z GCKRemoteMediaClient, uzyskaj dostęp do GCKUIPlaybackRateController za pomocą playbackRateController GCKUIMediaController i wyświetl aktualną szybkość odtwarzania za pomocą parametru playbackRate GCKUIPlaybackRateController.

Przykładowy kod

Te 2 pliki implementują element GCKUIPlaybackRateController, który zawiera elementy sterujące szybkości odtwarzania za pomocą podzielonego na segmenty elementu sterującego o „normalnej” i „połowie prędkości” oraz „podwójna prędkość” Przyciski:

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 przesyłania umożliwia utworzenie kanału do wysyłania niestandardowych komunikatów na 2 sposoby do odbiornika internetowego:

GCKCastChannel ma być podklasyfikowaną, aby zaimplementować proste kanały, które mają jako stan powiązany.
GCKGenericChannel jest traktowana jako alternatywa dla podklasyfikacji; przechodzi weryfikację otrzymanej i przetwarzanie ich 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 kanał zostanie automatycznie połączony, czy sama sesja jest połączona, o ile przestrzeń nazw kanału znajduje się w znajdującą się na liście metadanych obsługiwanych przestrzeni nazw odbiornika internetowego.

Każdy kanał niestandardowy jest definiowany przez unikalną przestrzeń nazw i musi zaczynać się od prefiks urn:x-cast:, na przykład urn:x-cast:com.example.custom. Jest aby mieć wiele kanałów niestandardowych, każdy z unikalną przestrzenią nazw. Aplikacja Web Receiver może również 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 dostarczyć logikę, która musi zostać wykonana, gdy określony kanał podłączone lub odłączone, zastąp -[didConnect] i -[didDisconnect] w przypadku użycia funkcji GCKCastChannel lub udostępnia implementacje dla -[castChannelDidConnect:] i Metody -[castChannelDidDisconnect:] GCKGenericChannelDelegate jeśli używasz GCKGenericChannel.

Obsługa autoodtwarzania

Zobacz Autoodtwarzanie i API do kolejkowania.

Zastąp wybór obrazów i buforowanie

Różne komponenty platformy (takie jak okno Cast, mini kontroler, rozwinięty kontroler GCKUIMediaController jeśli została skonfigurowana), wyświetla grafikę aktualnie przesyłanych multimediów. Adresy URL do grafiki obrazu są zwykle dostępne w GCKMediaMetadata dla multimediów, ale aplikacja nadawcy może mieć alternatywne źródło adresów URL.

GCKUIImagePicker określa sposób wyboru obrazu odpowiedniego do danego zastosowania i odpowiedni rozmiar. Ma jedną metodę: -[getImageWithHints:fromMetadata:], który zajmuje GCKUIImageHints. i GCKMediaMetadata jako parametry i zwraca GCKImage jako wynik. Platforma ta udostępnia domyślną implementację GCKUIImagePicker, który zawsze wybiera pierwszy obraz na liście obrazów w: obiektu GCKMediaMetadata, ale aplikacja może dostarczyć funkcji alternatywnej przez skonfigurowanie właściwości imagePicker sekcji GCKCastContext i sington.

GCKUIImageCache określa też sposób zapisywania w pamięci podręcznej obrazów pobieranych przez platformy korzystającej z protokołu HTTPS. Platforma ta udostępnia domyślną implementację GCKUIImageCache, który przechowuje pobrane pliki obrazów w pamięci podręcznej aplikacji , ale aplikacja może zapewnić alternatywną implementację, ustawiając parametr Właściwość imageCache komponentu GCKCastContext. singleton.

Dalsze kroki

To już wszystkie funkcje, które możesz dodać do aplikacji Sender na iOS. Teraz możesz utworzyć aplikację nadawcy dla innej platformy (Android lub Internet), lub utwórz odbiornik internetowy.

Wstecz

Kolejkowanie