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

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

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

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

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

ב-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())

יעד ג'

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

יעד ג'

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

יעד ג'

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

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

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

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

יעד ג'

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

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

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

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

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

השלבים הבאים

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