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

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

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

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

אפשר לציין את ההפסקות גם אצל השולח וגם אצל המקבל, אבל מומלץ לציין אותן ב-WebReceiver וב-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())

יעד ג'

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 Aware יכולה גם לשלוח ולקבל הודעות באמצעות אותו מרחב שמות.

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 (כלומר, תיבת הדו-שיח 'העברה', המיני-בקר, הבקר המורחב וה-GCKUIMediaController אם הוגדר) יציגו גרפיקה של המדיה שמועברת כרגע. כתובות ה-URL של גרפיקה לתמונות נכללות בדרך כלל ב-GCKMediaMetadata של המדיה, אבל באפליקציית השולח יכול להיות מקור חלופי לכתובות ה-URL.

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

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

השלבים הבאים

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