Aggiungi funzionalità avanzate alla tua app per iOS

Interruzioni pubblicitarie

L'SDK Sender per iOS fornisce supporto per interruzioni pubblicitarie e annunci companion all'interno di un un determinato stream multimediale.

Consulta le Panoramica delle interruzioni pubblicitarie di Web receiver per saperne di più informazioni sul funzionamento delle interruzioni pubblicitarie.

Anche se le interruzioni possono essere specificate sia sul mittente sia sul destinatario, è consigliabile che specificato sul WebRicevitore e Ricevitore Android TV per garantire coerenza il comportamento degli utenti sulle varie piattaforme.

Su iOS, specifica le interruzioni pubblicitarie in un comando di caricamento utilizzando GCKAdBreakClipInfo e GCKAdBreakInfo:

Rapido
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())
Obiettivo-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]];

Velocità di riproduzione variabile

La tua app può visualizzare e modificare la velocità di riproduzione dell'elemento multimediale corrente. Puoi impostare la tariffa utilizzando -[setPlaybackRate:] o -[setPlaybackRate:customData:] del GCKRemoteMediaClient, accedi a GCKUIPlaybackRateController utilizzando playbackRateController del GCKUIMediaController, e visualizza la velocità di riproduzione corrente utilizzando playbackRate del GCKUIPlaybackRateController

Codice di esempio

I due file seguenti implementano GCKUIPlaybackRateController che controlla la velocità di riproduzione utilizzando un controllo segmentato con "normale", "mezza velocità" e "doppia velocità" pulsanti:

Rapido
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
  }
}
Obiettivo-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

Aggiungi un canale personalizzato

Il framework Trasmetti offre due modi per creare un canale per inviare messaggi personalizzati a un ricevitore web:

  1. GCKCastChannel deve essere creato sottoclassi per implementare canali non banali che hanno stato associato.
  2. GCKGenericChannel viene fornita in alternativa alla creazione di sottoclassi; passa la sua a un delegato, in modo che possano essere elaborati altrove.

Ecco un esempio di implementazione di GCKCastChannel:

Rapido
class HGCTextChannel: GCKCastChannel {
  override func didReceiveTextMessage(_ message: String) {
    print("received message: \(message)")
  }
}
Obiettivo-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

Un canale può essere registrato in qualsiasi momento. se la sessione non è attualmente in un stato connesso, il canale verrà connesso automaticamente quando sia connessa, purché lo spazio dei nomi del canale sia presente dell'elenco dei metadati dell'app WebRicevitore per gli spazi dei nomi supportati.

Ogni canale personalizzato è definito da uno spazio dei nomi univoco e deve iniziare con prefisso urn:x-cast:, ad esempio urn:x-cast:com.example.custom. È possibile avere più canali personalizzati, ciascuno con uno spazio dei nomi unico. La L'app WebRicevitore può inoltre inviare e ricevere messaggi utilizzando lo stesso spazio dei nomi.

Rapido
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)")
}
Obiettivo-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);
}

per fornire una logica che deve essere eseguita quando un determinato canale connesso o disconnesso, esegui l'override di -[didConnect] e -[didDisconnect] se utilizzi GCKCastChannel oppure fornire implementazioni per -[castChannelDidConnect:] e -[castChannelDidDisconnect:] metodi del GCKGenericChannelDelegate se utilizzi GCKGenericChannel.

Riproduzione automatica supportata

Vedi Riproduzione automatica e API di accodamento.

Esegui override della selezione delle immagini e della memorizzazione nella cache

I vari componenti del framework (ovvero la finestra di dialogo Trasmetti, il il controller espanso GCKUIMediaController se configurato) mostrerà l'artwork dei contenuti multimediali attualmente trasmessi. Gli URL alla grafica dell'immagine sono generalmente inclusi nel GCKMediaMetadata per i contenuti multimediali, ma l'app del mittente potrebbe avere una fonte alternativa per gli URL.

La GCKUIImagePicker definisce un mezzo per la selezione di un'immagine appropriata per un determinato utilizzo e della dimensione desiderata. Ha un solo metodo, -[getImageWithHints:fromMetadata:], che richiede un GCKUIImageHints e un oggetto GCKMediaMetadata come parametro e restituisce un GCKImage come oggetto o il risultato finale. Il framework fornisce un'implementazione predefinita GCKUIImagePicker che seleziona sempre la prima immagine nell'elenco di immagini in l'oggetto GCKMediaMetadata, ma l'app può fornire un'alternativa dell'implementazione impostando la proprietà imagePicker GCKCastContext singleton.

La GCKUIImageCache definisce anche un mezzo per la memorizzazione nella cache delle immagini scaricate dal tramite HTTPS. Il framework fornisce un'implementazione predefinita GCKUIImageCache, che archivia i file immagine scaricati nella cache dell'app ma l'app può fornire un'implementazione alternativa impostando imageCache del GCKCastContext singleton.

Passaggi successivi

Con questo si conclude l'elenco delle funzionalità che puoi aggiungere all'app mittente per iOS. Ora puoi creare un'app mittente per un'altra piattaforma (Android o web), o crea un Web receiver.

Indietro
Coda