הוספת תכונות מתקדמות לאפליקציה ל-iOS

הפסקות למודעות

ערכת ה-SDK לשליחת מודעות ל-iOS מספקת תמיכה בפסקות למודעות ובמודעות נלוות בסטרימינג של מדיה נתון.

למידע נוסף על אופן הפעולה של הפסקות למודעות, קראו את הסקירה הכללית בנושא הפסקות למודעות במכשירי קצה לאינטרנט.

אפשר לציין הפסקות גם בשולח וגם בנמען, אבל מומלץ לציין אותן בנגן האינטרנט ובנגן Android TV כדי לשמור על התנהגות עקבית בפלטפורמות השונות.

ב-iOS, מציינים הפסקות למודעות בפקודת טעינה באמצעות GCKAdBreakClipInfo ו-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]];

מהירות הפעלה משתנה

האפליקציה יכולה להציג ולשנות את קצב ההפעלה של פריט המדיה הנוכחי. אפשר להגדיר את הקצב באמצעות -[setPlaybackRate:] או -[setPlaybackRate:customData:] ב-GCKRemoteMediaClient, לגשת ל-GCKUIPlaybackRateController באמצעות playbackRateController ב-GCKUIMediaController ולהציג את קצב ההפעלה הנוכחי באמצעות playbackRate ב-GCKUIPlaybackRateController.

קוד לדוגמה

בשני הקבצים הבאים מוטמע GCKUIPlaybackRateController, שמאפשר לשלוט בקצב ההפעלה באמצעות פקדים מחולקים עם לחצנים 'רגיל', 'מהירות כפולה' ו'מהירות חצי':

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

הוספת ערוץ מותאם אישית

מסגרת Cast מספקת שתי דרכים ליצור ערוץ לשליחת הודעות בהתאמה אישית למקלט אינטרנט:

  1. GCKCastChannel הוא מיועד ליצירת תת-סוגים כדי להטמיע ערוצים מורכבים שיש להם מצב משויך.
  2. GCKGenericChannel הוא חלופה ליצירת תת-כיתות. הוא מעביר את ההודעות שהוא מקבל למעביר כדי שניתן יהיה לעבד אותן במקום אחר.

דוגמה להטמעה של 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

אפשר לרשום ערוץ בכל שלב. אם הסשן לא במצב מחובר, הערוץ יתחבר באופן אוטומטי כשהסשן עצמו יתחבר, בתנאי שמרחב השמות של הערוץ נמצא ברשימת מרחבי השמות הנתמכים במטא-נתונים של אפליקציית Web Receiver.

כל ערוץ מותאם אישית מוגדר על ידי מרחב שמות ייחודי, והוא חייב להתחיל בתחילית urn:x-cast:, לדוגמה, urn:x-cast:com.example.custom. אפשר ליצור כמה ערוצים מותאמים אישית, לכל אחד מהם מרחבי שמות ייחודיים. אפליקציית Web Receiver יכולה גם לשלוח ולקבל הודעות באמצעות אותו מרחב שמות.

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

כדי לספק לוגיקה שצריך להריץ כשערוץ מסוים מתחבר או מתנתק, משנים את הגדרות ברירת המחדל של השיטות -[didConnect] ו--[didDisconnect] אם משתמשים ב-GCKCastChannel, או מספקים הטמעות לשיטות -[castChannelDidConnect:] ו--[castChannelDidDisconnect:] של GCKGenericChannelDelegate אם משתמשים ב-GCKGenericChannel.

תמיכה בהפעלה אוטומטית

ממשקי API להפעלה אוטומטית ולתורים

שינוי ברירת המחדל של בחירת התמונות ואחסון ב-cache

רכיבים שונים של המסגרת (כלומר תיבת הדו-שיח של Cast, הבקר המיני, הבקר המורחב ו-GCKUIMediaController, אם הוא מוגדר כך) יציגים גרפיקה של המדיה שמעבירים כרגע. כתובות ה-URL של הגרפיקה של התמונה נכללות בדרך כלל ב-GCKMediaMetadata של המדיה, אבל יכול להיות שבאפליקציה של השולח יש מקור חלופי לכתובות ה-URL.

פרוטוקול GCKUIImagePicker מגדיר דרך לבחור תמונה מתאימה לשימוש נתון ולגודל הרצוי. יש לו שיטה אחת, -[getImageWithHints:fromMetadata:], שמקבלת אובייקט GCKUIImageHints ואובייקט GCKMediaMetadata כפרמטרים, ומחזירה אובייקט GCKImage כתוצאה. המסגרת מספקת הטמעה שמוגדרת כברירת מחדל של GCKUIImagePicker, שבה תמיד נבחרת התמונה הראשונה ברשימת התמונות באובייקט GCKMediaMetadata. עם זאת, האפליקציה יכולה לספק הטמעה חלופית על ידי הגדרת המאפיין imagePicker של ה-singleton‏ GCKCastContext.

בפרוטוקול GCKUIImageCache מוגדר גם אמצעי לשמירת תמונות במטמון שהמסגרת מורידת באמצעות HTTPS. המסגרת מספקת הטמעה שמוגדרת כברירת מחדל של GCKUIImageCache, שמאחסנת קובצי תמונות שהורדתם בספריית המטמון של האפליקציה. עם זאת, האפליקציה יכולה לספק הטמעה חלופית על ידי הגדרת המאפיין imageCache של ה-singleton GCKCastContext.

השלבים הבאים

זהו הסיום של התכונות שאפשר להוסיף לאפליקציית השליחה ל-iOS. עכשיו אפשר ליצור אפליקציית שליחה לפלטפורמה אחרת (Android או אינטרנט), או ליצור אפליקציית קליטה לאינטרנט.

הקודם
המתנה בתור