अपने iOS ऐप्लिकेशन में बेहतर सुविधाएं जोड़ना

विज्ञापन के लिए ब्रेक

iOS सेंडर SDK टूल, दिए गए मीडिया स्ट्रीम में विज्ञापन के लिए ब्रेक और साथ-साथ चलने वाले विज्ञापनों के लिए सहायता देता है.

विज्ञापन के लिए ब्रेक कैसे काम करते हैं, इस बारे में ज़्यादा जानने के लिए, वेब रिसीवर के लिए विज्ञापन के लिए ब्रेक की खास जानकारी देखें.

मैसेज भेजने और पाने वाले, दोनों के लिए ब्रेक तय किए जा सकते हैं. हालांकि, हमारा सुझाव है कि इनकी जानकारी वेब रिसीवर और Android TV रिसीवर पर भी दी जानी चाहिए, ताकि सभी प्लैटफ़ॉर्म पर एक जैसा अनुभव दिया जा सके.

iOS पर, लोड कमांड में 'विज्ञापन के लिए ब्रेक' की जानकारी देने के लिए, GCKAdBreakClipInfo और GCKAdBreakInfo का इस्तेमाल करें:

स्विफ़्ट

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

मकसद-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]];

वैरिएबल प्लेबैक रेट

आपका ऐप्लिकेशन, मौजूदा मीडिया आइटम को चलाने की स्पीड दिखा सकता है और उसमें बदलाव कर सकता है. दर सेट करने के लिए, GCKRemoteMediaClient के -[setPlaybackRate:] या -[setPlaybackRate:customData:] का इस्तेमाल किया जा सकता है. GCKUIMediaController के playbackRateController का इस्तेमाल करके GCKUIPlaybackRateController को ऐक्सेस किया जा सकता है और GCKUIPlaybackRateController में से playbackRate का इस्तेमाल करके मौजूदा वीडियो रेट दिखाया जा सकता है.

नमूना कोड

इन दो फ़ाइलों में GCKUIPlaybackRateController लागू किया गया है. यह वीडियो चलाने की दर को कंट्रोल करने के लिए, सेगमेंट किए गए ऐसे कंट्रोल का इस्तेमाल करता है जिसमें "सामान्य", "आधी स्पीड", और "डबल स्पीड" जैसे बटन होते हैं:

स्विफ़्ट

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

मकसद-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

कस्टम चैनल जोड़ें

वेब रिसीवर को पसंद के मुताबिक मैसेज भेजने के लिए, कास्ट फ़्रेमवर्क दो तरीके से चैनल बनाता है:

1. GCKCastChannel को, ऐसे छोटे चैनलों को लागू करने के लिए सब-क्लास में बांटा गया है जो आपस में जुड़े हैं.
2. GCKGenericChannel को, सब-क्लासिंग के विकल्प के तौर पर उपलब्ध कराया जाता है. यह अपने मिलने वाले मैसेज किसी डेलीगेट को भेजता है, ताकि उन्हें कहीं और प्रोसेस किया जा सके.

यहां GCKCastChannel को लागू करने का एक उदाहरण दिया गया है:

स्विफ़्ट

class HGCTextChannel: GCKCastChannel {
  override func didReceiveTextMessage(_ message: String) {
    print("received message: \(message)")
  }
}

मकसद-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

चैनल को किसी भी समय रजिस्टर किया जा सकता है. अगर सेशन मौजूदा समय में कनेक्ट नहीं है, तो सेशन के कनेक्ट होने पर चैनल अपने-आप कनेक्ट हो जाएगा. हालांकि, इसके लिए ज़रूरी है कि वेब रिसीवर ऐप्लिकेशन के मेटाडेटा की इस्तेमाल किए जा सकने वाले नेमस्पेस में चैनल का नेमस्पेस मौजूद हो.

हर कस्टम चैनल को एक खास नेमस्पेस से तय किया जाता है और उसे urn:x-cast: प्रीफ़िक्स से शुरू होना चाहिए, जैसे कि urn:x-cast:com.example.custom. कई कस्टम चैनल हो सकते हैं और हर चैनल का एक यूनीक नेमस्पेस होता है. वेब रिसीवर ऐप्लिकेशन भी, उसी नेमस्पेस का इस्तेमाल करके मैसेज भेज और पा सकता है.

स्विफ़्ट

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

मकसद-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);
}

किसी चैनल के कनेक्ट या डिसकनेक्ट होने पर लागू होने वाला लॉजिक उपलब्ध कराएं. इसके लिए, GCKCastChannel का इस्तेमाल करने पर, -[didConnect] और -[didDisconnect] तरीकों को बदलें. इसके अलावा, अगर GCKGenericChannel का इस्तेमाल किया जा रहा है, तो GCKGenericChannelDelegate के -[castChannelDidConnect:] और-[castChannelDidDisconnect:] तरीकों को लागू करने की जानकारी दें.

अपने-आप चलने की सुविधा के साथ काम करना

अपने-आप चलने और सूची बनाने के एपीआई देखें.

इमेज चुनना और कैश मेमोरी में सेव करना बदलें

अगर कॉन्फ़िगर किया गया हो, तो फ़्रेमवर्क के अलग-अलग कॉम्पोनेंट (जैसे, कास्ट डायलॉग, मिनी कंट्रोलर, बड़ा किया गया कंट्रोलर, और GCKUIMediaController) में, कास्ट किए जा रहे मौजूदा मीडिया का आर्टवर्क दिखेगा. आम तौर पर, मीडिया के लिए इमेज आर्टवर्क के यूआरएल GCKMediaMetadata में शामिल किए जाते हैं. हालांकि, भेजने वाले ऐप्लिकेशन के पास यूआरएल के लिए कोई दूसरा सोर्स हो सकता है.

GCKUIImagePicker प्रोटोकॉल, दिए गए इस्तेमाल और साइज़ के लिए सही इमेज चुनने का तरीका बताता है. इसमें एक ही तरीका -[getImageWithHints:fromMetadata:] होता है. इसमें GCKUIImageHints ऑब्जेक्ट और GCKMediaMetadata ऑब्जेक्ट को पैरामीटर के तौर पर दिखाया जाता है और नतीजे के तौर पर GCKImage ऑब्जेक्ट दिखाया जाता है. यह फ़्रेमवर्क, GCKUIImagePicker को डिफ़ॉल्ट रूप से लागू करने की सुविधा देता है, जो हमेशा GCKMediaMetadata ऑब्जेक्ट में मौजूद इमेज की सूची से पहली इमेज को चुनता है. हालांकि, ऐप्लिकेशन GCKCastContext सिंगलटन की imagePicker प्रॉपर्टी को सेट करके, एक और तरीका लागू कर सकता है.

GCKUIImageCache प्रोटोकॉल, उन इमेज को कैश मेमोरी में सेव करने का तरीका भी बताता है जिन्हें एचटीटीपीएस का इस्तेमाल करके, फ़्रेमवर्क से डाउनलोड किया गया है. यह फ़्रेमवर्क, GCKUIImageCache को डिफ़ॉल्ट रूप से लागू करने का विकल्प देता है, जो डाउनलोड की गई इमेज फ़ाइलों को ऐप्लिकेशन की कैश डायरेक्ट्री में सेव करता है. हालांकि, ऐप्लिकेशन GCKCastContext सिंगलटन की imageCache प्रॉपर्टी को सेट करके, इसे लागू करने का वैकल्पिक तरीका उपलब्ध करा सकता है.

अगले चरण

इसके साथ उन सुविधाओं के बारे में जानकारी दी गई है जिन्हें iOS सेंडर ऐप्लिकेशन में जोड़ा जा सकता है. अब आपके पास किसी दूसरे प्लैटफ़ॉर्म (Android या वेब) के लिए, सेंडर ऐप्लिकेशन बनाने या वेब रिसीवर बनाने का विकल्प है.