Aggiungi funzionalità avanzate alla tua app per iOS

Interruzioni pubblicitarie

L'SDK Sender per iOS supporta le interruzioni pubblicitarie e gli annunci companion all'interno di un determinato stream multimediale.

Per scoprire di più sul funzionamento delle interruzioni pubblicitarie, consulta la Panoramica delle interruzioni pubblicitarie per i ricevitori web.

Sebbene le interruzioni possano essere specificate sia sul mittente che sul ricevente, è consigliabile specificarle sul Ricevitore web e sul Ricevitore Android TV per mantenere un comportamento coerente sulle varie piattaforme.

Su iOS, specifica le interruzioni pubblicitarie in un comando di caricamento utilizzando GCKAdBreakClipInfo e 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]];

Velocità di riproduzione variabile

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

Codice di esempio

I due file seguenti implementano GCKUIPlaybackRateController, che controlla la velocità di riproduzione utilizzando un controllo segmentato con i pulsanti "Normale", "Metà velocità" e "Doppia velocità":

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

Aggiungere un canale personalizzato

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

  1. GCKCastChannel è destinato a essere sottoclassificato per implementare canali non banali con stato associato.
  2. GCKGenericChannel viene fornito come alternativa alla sottoclassificazione; passa i messaggi ricevuti a un delegato in modo che possano essere elaborati altrove.

Ecco un esempio di implementazione di 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

Un canale può essere registrato in qualsiasi momento. Se la sessione non è attualmente in stato di connessione, il canale si connetterà automaticamente quando la sessione stessa sarà connessa, a condizione che il relativo spazio dei nomi sia presente nell'elenco degli spazi dei nomi supportati dei metadati dell'app Web Receiver.

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

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);
}

Per fornire la logica da eseguire quando un determinato canale viene collegato o disconnesso, sostituisci i metodi -[didConnect] e -[didDisconnect] se utilizzi GCKCastChannel oppure fornisci implementazioni per i metodi -[castChannelDidConnect:] e -[castChannelDidDisconnect:] di GCKGenericChannelDelegate se utilizzi GCKGenericChannel.

Supporto della riproduzione automatica

Consulta le API di riproduzione automatica e coda.

Sostituire la selezione e la memorizzazione nella cache delle immagini

Vari componenti del framework (ovvero la finestra di dialogo Trasmetti, il mini controller, il controller espanso e GCKUIMediaController, se configurato in questo modo) mostreranno l'artwork dei contenuti multimediali attualmente trasmessi. Gli URL all'artwork dell'immagine sono in genere inclusi nel GCKMediaMetadata per i contenuti multimediali, ma l'app mittente potrebbe avere un'origine alternativa per gli URL.

Il protocollo GCKUIImagePicker definisce un mezzo per selezionare un'immagine appropriata per un determinato utilizzo e le dimensioni desiderate. Ha un unico metodo, -[getImageWithHints:fromMetadata:], che prende un oggetto GCKUIImageHints e un oggetto GCKMediaMetadata come parametri e restituisce un oggetto GCKImage come risultato. Il framework fornisce un'implementazione predefinita di GCKUIImagePicker che seleziona sempre la prima immagine nell'elenco di immagini nell'oggetto GCKMediaMetadata, ma l'app può fornire un'implementazione alternativa impostando la proprietà imagePicker del GCKCastContext singleton.

Il protocollo GCKUIImageCache definisce anche un mezzo per memorizzare nella cache le immagini scaricate dal framework utilizzando HTTPS. Il framework fornisce un'implementazione predefinita di GCKUIImageCache che memorizza i file immagine scaricati nella directory cache dell'app, ma l'app può fornire un'implementazione alternativa impostando la proprietà imageCache del GCKCastContext singleton.

Passaggi successivi

Ecco le funzionalità che puoi aggiungere all'app mittente per iOS. Ora puoi creare un'app mittente per un'altra piattaforma (Android o web) o un Apparato di ricezione web.

Indietro
Coda