הוספת תכונות מתקדמות לאפליקציה ל-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 מספקת שתי דרכים ליצור ערוץ לשליחת הודעות מותאמות אישית אל 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 כתוצאה. המסגרת מספקת הטמעה שמוגדרת כברירת מחדל של GCKUIImagePicker, שתמיד בוחרת את התמונה הראשונה ברשימת התמונות באובייקט GCKMediaMetadata, אבל האפליקציה יכולה לספק הטמעה חלופית על ידי הגדרת המאפיין imagePicker של הסינגלטון GCKCastContext.

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

השלבים הבאים

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

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