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

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

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

בסקירה הכללית על הפסקות למודעות ב-Web Receiver מוסבר איך פועלות הפסקות למודעות.

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

ב-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 Framework יש שתי דרכים ליצור ערוץ לשליחת הודעות בהתאמה אישית אל Web Receiver:

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 להפעלה אוטומטית ולהוספה לתור.

שינוי ברירת המחדל של בחירת התמונות והשמירה שלהן במטמון

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

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

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

השלבים הבאים

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