Dodaj zaawansowane funkcje do swojej aplikacji na iOS

Przerwy na reklamę

Pakiet iOS Sender SDK 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 Omówienie przerw na reklamę w Web Receiver.

Przerwy można określać zarówno w nadajniku, jak i odbiorniku, ale zalecamy ich określanie w odbiorniku internetowym i odbiorniku Androida TV, aby zachować spójność działania na różnych platformach.

W iOS określ przerwy na reklamy 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:] w GCKRemoteMediaClient, uzyskać dostęp do GCKUIPlaybackRateController za pomocą playbackRateController w GCKUIMediaController oraz wyświetlić bieżącą szybkość odtwarzania za pomocą playbackRate w GCKUIPlaybackRateController.

Przykładowy kod

Te 2 pliki implementują funkcję GCKUIPlaybackRateController, która kontroluje szybkość odtwarzania za pomocą elementów sterujących z przyciskami „normalna”, „pół 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 oferuje 2 sposoby tworzenia kanału do wysyłania niestandardowych wiadomości do odbiornika internetowego:

  1. GCKCastChannel ma być podklasą w celu implementacji nieoczywistych kanałów, które mają powiązany stan.
  2. GCKGenericChannel jest alternatywą dla podklasyfikacji. Przekazuje odebrane wiadomości do delegowanego serwera, 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 połączy się sama sesja, pod warunkiem że przestrzeń nazw kanału jest obecna na liście obsługiwanych przestrzeni nazw w metadanych aplikacji Web Receiver.

Każdy kanał niestandardowy jest zdefiniowany za pomocą unikalnego przedrostka i musi zaczynać się od prefiksu urn:x-cast:, na przykład urn:x-cast:com.example.custom. Możesz mieć wiele niestandardowych kanałów, z których każdy ma unikalną przestrzeń nazw. Aplikacja Web Receiver może też wysyłać i odbierać wiadomości w ramach 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 ma być wykonywana, gdy dany kanał staje się połączony lub rozłączony, zastąpij metody -[didConnect] i -[didDisconnect], jeśli używasz interfejsu GCKCastChannel, lub zaimplementuj metody -[castChannelDidConnect:] i -[castChannelDidDisconnect:] interfejsu GCKGenericChannelDelegate, jeśli używasz interfejsu GCKGenericChannel.

Obsługa autoodtwarzania

Zobacz interfejsy API autoodtwarzania i kolejkowania.

Zastępowanie wyboru obrazu i przechowywania w pamięci podręcznej

Różne komponenty platformy (w tym okno przesyłania, minikontroler, rozszerzony kontroler i GCKUIMediaController, jeśli są skonfigurowane) będą wyświetlać grafikę dla przesyłanych obecnie multimediów. Adresy URL obrazów są zwykle uwzględnione w GCKMediaMetadata multimediów, ale aplikacja nadawcy może mieć alternatywne źródło adresów URL.

Protokół GCKUIImagePickerokreśla sposób wyboru odpowiedniego obrazu w zależności od jego zastosowania i pożądanego rozmiaru. Ma ona jedną metodę, -[getImageWithHints:fromMetadata:], która jako parametry przyjmuje obiekt GCKUIImageHints i obiekt GCKMediaMetadata, a w wyniku zwraca obiekt GCKImage. Platforma zapewnia domyślną implementację funkcji GCKUIImagePicker, która zawsze wybiera pierwszy obraz z listy obrazów w obiekcie GCKMediaMetadata, ale aplikacja może zastosować inną implementację, ustawiając właściwość imagePicker obiektu singletona GCKCastContext.

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

Dalsze kroki

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

Wstecz
Kolejkowanie