iOS ऐप्लिकेशन को कास्ट करें

1. खास जानकारी

इस कोडलैब में, आपको यह सिखाया जाएगा कि Google Cast की सुविधा वाले डिवाइस पर कॉन्टेंट कास्ट करने के लिए, मौजूदा iOS वीडियो ऐप्लिकेशन में कैसे बदलाव करें.

Google Cast क्या है?

Google Cast की मदद से, लोग अपने फ़ोन या टैबलेट पर मौजूद कॉन्टेंट को टीवी पर कास्ट कर सकते हैं. इसके बाद, उपयोगकर्ता अपने मोबाइल डिवाइस का इस्तेमाल, टीवी पर मीडिया चलाने के लिए रिमोट कंट्रोल के तौर पर कर सकते हैं.

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

Google Cast की डिज़ाइन चेकलिस्ट इसलिए दी गई है, ताकि Cast की सुविधा इस्तेमाल करने वाले लोगों को सभी प्लैटफ़ॉर्म पर एक जैसा और आसान अनुभव मिल सके.

हम क्या बनाने जा रहे हैं?

इस कोडलैब को पूरा करने के बाद, आपके पास एक iOS वीडियो ऐप्लिकेशन होगा. यह ऐप्लिकेशन, Google Cast की सुविधा वाले डिवाइस पर वीडियो कास्ट कर सकेगा.

आपको क्या सीखने को मिलेगा

• किसी सैंपल वीडियो ऐप्लिकेशन में Google Cast SDK जोड़ने का तरीका.
• Google Cast डिवाइस चुनने के लिए, कास्ट बटन जोड़ने का तरीका.
• कास्ट डिवाइस से कनेक्ट करने और मीडिया रिसीवर लॉन्च करने का तरीका.
• वीडियो कास्ट करने का तरीका.
• अपने ऐप्लिकेशन में कास्ट मिनी कंट्रोलर जोड़ने का तरीका.
• बड़ा किया गया कंट्रोलर जोड़ने का तरीका.
• इंट्रोडक्ट्री ओवरले जोड़ने का तरीका.
• कास्ट करने की सुविधा वाले विजेट को पसंद के मुताबिक बनाने का तरीका.
• Cast Connect को इंटिग्रेट करने का तरीका

आपको किन चीज़ों की ज़रूरत होगी

• Xcode का नया वर्शन.
• iOS 9 या उसके बाद के वर्शन वाला मोबाइल डिवाइस या Xcode Simulator.
• अपने मोबाइल डिवाइस को डेवलपमेंट कंप्यूटर से कनेक्ट करने के लिए, यूएसबी डेटा केबल (अगर किसी डिवाइस का इस्तेमाल किया जा रहा है).
• Google Cast की सुविधा वाला कोई डिवाइस, जैसे कि Chromecast या Android TV. इस डिवाइस में इंटरनेट ऐक्सेस की सुविधा कॉन्फ़िगर की गई हो.
• एचडीएमआई इनपुट वाला टीवी या मॉनिटर.
• Cast Connect इंटिग्रेशन की जांच करने के लिए, Chromecast with Google TV की ज़रूरत होती है. हालांकि, Codelab के बाकी हिस्सों के लिए इसकी ज़रूरत नहीं होती. अगर आपके पास ऐसा कोई डिवाइस नहीं है, तो इस ट्यूटोरियल के आखिर में दिए गए कास्ट कनेक्ट की सुविधा जोड़ें चरण को छोड़ दें.

अनुभव

• आपको iOS डेवलपमेंट के बारे में पहले से जानकारी होनी चाहिए.
• आपको टीवी देखने का तरीका भी पता होना चाहिए :)

2. सैंपल कोड पाना

आपके पास सैंपल कोड को अपने कंप्यूटर पर डाउनलोड करने का विकल्प होता है...

file_downloadसोर्स कोड डाउनलोड करें

इसके बाद, डाउनलोड की गई zip फ़ाइल को अनपैक करें.

3. सैंपल ऐप्लिकेशन चलाना

सबसे पहले, आइए देखते हैं कि पूरा किया गया सैंपल ऐप्लिकेशन कैसा दिखता है. यह ऐप्लिकेशन, बुनियादी वीडियो प्लेयर है. उपयोगकर्ता, सूची से कोई वीडियो चुन सकता है. इसके बाद, वह वीडियो को डिवाइस पर चला सकता है या उसे Google Cast डिवाइस पर कास्ट कर सकता है.

कोड डाउनलोड हो जाने के बाद, यहां दिए गए निर्देशों में बताया गया है कि Xcode में पूरा किया गया सैंपल ऐप्लिकेशन कैसे खोला और चलाया जाता है:

अक्सर पूछे जाने वाले सवाल

• Xcode को कैसे इंस्टॉल करें?
• CocoaPods को कैसे सेट अप करें?

CocoaPods सेटअप करना

CocoaPods को सेट अप करने के लिए, अपनी कंसोल पर जाएं और macOS पर उपलब्ध डिफ़ॉल्ट Ruby का इस्तेमाल करके इसे इंस्टॉल करें:

sudo gem install cocoapods

अगर आपको कोई समस्या होती है, तो डिपेंडेंसी मैनेजर को डाउनलोड और इंस्टॉल करने के लिए, आधिकारिक दस्तावेज़ देखें.

प्रोजेक्ट सेटअप करना

1. अपने टर्मिनल पर जाएं और codelab डायरेक्ट्री पर जाएं.
2. Podfile से डिपेंडेंसी इंस्टॉल करें.

cd app-done
pod update
pod install

3. Xcode खोलें और Open another project... को चुनें
4. सैंपल कोड फ़ोल्डर में मौजूद app-done डायरेक्ट्री से CastVideos-ios.xcworkspace फ़ाइल चुनें.

ऐप्लिकेशन चलाएं

टारगेट और सिम्युलेटर चुनें. इसके बाद, ऐप्लिकेशन चलाएं:

कुछ सेकंड बाद, आपको वीडियो ऐप्लिकेशन दिखने लगेगा.

जब आपको इनकमिंग नेटवर्क कनेक्शन स्वीकार करने के बारे में सूचना दिखे, तो ‘अनुमति दें' पर क्लिक करना न भूलें. अगर इस विकल्प को स्वीकार नहीं किया जाता है, तो Cast आइकॉन नहीं दिखेगा.

कास्ट करें बटन पर क्लिक करें और अपना Google Cast डिवाइस चुनें.

कोई वीडियो चुनें और 'चलाएं' बटन पर क्लिक करें.

वीडियो, आपके Google Cast डिवाइस पर चलने लगेगा.

आपको बड़ा किया गया कंट्रोलर दिखेगा. वीडियो चलाने या रोकने के लिए, 'चलाएं/रोकें' बटन का इस्तेमाल किया जा सकता है.

वीडियो की सूची पर वापस जाएं.

अब स्क्रीन पर सबसे नीचे एक मिनी कंट्रोलर दिख रहा है.

वीडियो को रिसीवर पर रोकने के लिए, मिनी कंट्रोलर में मौजूद 'रोकें' बटन पर क्लिक करें. वीडियो को फिर से चलाने के लिए, मिनी कंट्रोलर में मौजूद 'चलाएं' बटन पर क्लिक करें.

Google Cast डिवाइस पर कास्ट करना बंद करने के लिए, कास्ट करें बटन पर क्लिक करें.

4. स्टार्ट प्रोजेक्ट तैयार करना

हमने जो ऐप्लिकेशन डाउनलोड किया है उसमें Google Cast की सुविधा जोड़ने की ज़रूरत है. इस कोडलैब में, हम Google Cast से जुड़े कुछ शब्दों का इस्तेमाल करेंगे:

• सेंडर ऐप्लिकेशन, मोबाइल डिवाइस या लैपटॉप पर चलता है,
• Google Cast डिवाइस पर रिसीवर ऐप्लिकेशन चलता है.

प्रोजेक्ट सेटअप करना

अब Xcode का इस्तेमाल करके, स्टार्टर प्रोजेक्ट पर काम किया जा सकता है:

1. अपने टर्मिनल पर जाएं और codelab डायरेक्ट्री पर जाएं.
2. Podfile से डिपेंडेंसी इंस्टॉल करें.

cd app-start
pod update
pod install

3. Xcode खोलें और Open another project... को चुनें
4. सैंपल कोड फ़ोल्डर में मौजूद app-start डायरेक्ट्री से CastVideos-ios.xcworkspace फ़ाइल चुनें.

ऐप डिज़ाइन

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

ऐप्लिकेशन में दो मुख्य व्यू कंट्रोलर होते हैं: MediaTableViewController और MediaViewController.

MediaTableViewController

यह UITableViewController, MediaListModel इंस्टेंस से वीडियो की सूची दिखाता है. वीडियो की सूची और उनसे जुड़ा मेटाडेटा, रिमोट सर्वर पर JSON फ़ाइल के तौर पर होस्ट किया जाता है. MediaListModel इस JSON को फ़ेच करता है और इसे प्रोसेस करके, MediaItem ऑब्जेक्ट की सूची बनाता है.

MediaItem ऑब्जेक्ट, किसी वीडियो और उससे जुड़े मेटाडेटा को मॉडल करता है. जैसे, वीडियो का टाइटल, ब्यौरा, इमेज का यूआरएल, और स्ट्रीम का यूआरएल.

MediaTableViewController, MediaListModel इंस्टेंस बनाता है. इसके बाद, खुद को MediaListModelDelegate के तौर पर रजिस्टर करता है, ताकि मीडिया मेटाडेटा डाउनलोड होने पर उसे सूचना मिल सके. इससे वह टेबल व्यू लोड कर पाता है.

उपयोगकर्ता को वीडियो के थंबनेल की सूची दिखाई जाती है. साथ ही, हर वीडियो के बारे में कम शब्दों में जानकारी दी जाती है. किसी आइटम को चुनने पर, उससे जुड़ा MediaItem, MediaViewController को पास किया जाता है.

MediaViewController

यह व्यू कंट्रोलर, किसी वीडियो के बारे में मेटाडेटा दिखाता है. साथ ही, उपयोगकर्ता को मोबाइल डिवाइस पर वीडियो को स्थानीय तौर पर चलाने की अनुमति देता है.

व्यू कंट्रोलर में LocalPlayerView, कुछ मीडिया कंट्रोल, और चुने गए वीडियो का ब्यौरा दिखाने के लिए टेक्स्ट एरिया होता है. प्लेयर, स्क्रीन के ऊपरी हिस्से को कवर करता है. इससे वीडियो के बारे में ज़्यादा जानकारी देने के लिए, स्क्रीन के निचले हिस्से में जगह मिल जाती है. उपयोगकर्ता, स्थानीय वीडियो को चला/रोका जा सकता है या उसे आगे-पीछे किया जा सकता है.

अक्सर पूछे जाने वाले सवाल

• Google Cast क्या है?
• मैं Google Cast डेवलपर कैसे बनूं?

5. 'कास्ट करें' बटन जोड़ना

Cast की सुविधा वाले ऐप्लिकेशन में, हर व्यू कंट्रोलर में Cast बटन दिखता है. 'कास्ट करें' बटन पर क्लिक करने से, कास्ट किए जा सकने वाले डिवाइसों की सूची दिखती है. उपयोगकर्ता इनमें से कोई डिवाइस चुन सकता है. अगर उपयोगकर्ता, भेजने वाले डिवाइस पर स्थानीय कॉन्टेंट चला रहा था, तो कास्ट डिवाइस चुनने पर, उस कास्ट डिवाइस पर कॉन्टेंट चलना शुरू हो जाता है या फिर से शुरू हो जाता है. कास्ट सेशन के दौरान, उपयोगकर्ता किसी भी समय कास्ट बटन पर क्लिक करके, आपके ऐप्लिकेशन को कास्ट डिवाइस पर कास्ट करना बंद कर सकता है. उपयोगकर्ता को आपके ऐप्लिकेशन की किसी भी स्क्रीन पर, कास्ट करने वाले डिवाइस से कनेक्ट या डिसकनेक्ट करने की सुविधा मिलनी चाहिए. इसके बारे में Google Cast की डिज़ाइन चेकलिस्ट में बताया गया है.

कॉन्फ़िगरेशन

स्टार्ट प्रोजेक्ट के लिए, आपको वही डिपेंडेंसी और Xcode सेटअप करना होगा जो आपने सैंपल ऐप्लिकेशन के लिए किया था. उस सेक्शन पर वापस जाएं और GoogleCast.framework को स्टार्ट ऐप्लिकेशन प्रोजेक्ट में जोड़ने के लिए, वही चरण अपनाएं.

डेटा लेयर में इवेंट बनाने की प्रोसेस

Cast फ़्रेमवर्क में एक ग्लोबल सिंगलटन ऑब्जेक्ट होता है, जिसे GCKCastContext कहा जाता है. यह फ़्रेमवर्क की सभी गतिविधियों को मैनेज करता है. इस ऑब्जेक्ट को ऐप्लिकेशन के लाइफ़साइकल की शुरुआत में ही शुरू करना ज़रूरी है. आम तौर पर, इसे ऐप्लिकेशन डेलिगेट के application(_:didFinishLaunchingWithOptions:) तरीके में शुरू किया जाता है, ताकि सेंडर ऐप्लिकेशन के रीस्टार्ट होने पर, सेशन अपने-आप फिर से शुरू हो सके और डिवाइसों को स्कैन किया जा सके.

GCKCastContext को शुरू करते समय, GCKCastOptions ऑब्जेक्ट देना ज़रूरी है. इस क्लास में ऐसे विकल्प होते हैं जो फ़्रेमवर्क के व्यवहार पर असर डालते हैं. इनमें सबसे अहम है रिसीवर ऐप्लिकेशन आईडी. इसका इस्तेमाल, कास्ट डिवाइस खोजने के नतीजों को फ़िल्टर करने के लिए किया जाता है. साथ ही, जब कास्ट सेशन शुरू होता है, तब रिसीवर ऐप्लिकेशन लॉन्च करने के लिए भी इसका इस्तेमाल किया जाता है.

application(_:didFinishLaunchingWithOptions:) तरीका, लॉगिंग डेलिगेट को सेट अप करने के लिए भी एक अच्छा तरीका है, ताकि Cast फ़्रेमवर्क से लॉगिंग मैसेज मिल सकें. ये डीबग करने और समस्या हल करने में काम आ सकते हैं.

Cast की सुविधा वाला ऐप्लिकेशन डेवलप करने के लिए, आपको Cast डेवलपर के तौर पर रजिस्टर करना होगा. इसके बाद, आपको अपने ऐप्लिकेशन के लिए ऐप्लिकेशन आईडी पाना होगा. इस कोडलैब के लिए, हम एक सैंपल ऐप्लिकेशन आईडी का इस्तेमाल करेंगे.

उपयोगकर्ता की डिफ़ॉल्ट सेटिंग से ऐप्लिकेशन आईडी के साथ AppDelegate.swift को शुरू करने के लिए, AppDelegate.swift में यह कोड जोड़ें. साथ ही, Google Cast फ़्रेमवर्क के लिए एक लॉगर जोड़ें:GCKCastContext

import GoogleCast

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
  fileprivate var enableSDKLogging = true

  ...

  func application(_: UIApplication,
                   didFinishLaunchingWithOptions _: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {

    ...
    let options = GCKCastOptions(discoveryCriteria: GCKDiscoveryCriteria(applicationID: kReceiverAppID))
    options.physicalVolumeButtonsWillControlDeviceVolume = true
    GCKCastContext.setSharedInstanceWith(options)

    window?.clipsToBounds = true
    setupCastLogging()
    ...
  }
  ...
  func setupCastLogging() {
    let logFilter = GCKLoggerFilter()
    let classesToLog = ["GCKDeviceScanner", "GCKDeviceProvider", "GCKDiscoveryManager", "GCKCastChannel",
                        "GCKMediaControlChannel", "GCKUICastButton", "GCKUIMediaController", "NSMutableDictionary"]
    logFilter.setLoggingLevel(.verbose, forClasses: classesToLog)
    GCKLogger.sharedInstance().filter = logFilter
    GCKLogger.sharedInstance().delegate = self
  }
}

...

// MARK: - GCKLoggerDelegate

extension AppDelegate: GCKLoggerDelegate {
  func logMessage(_ message: String,
                  at _: GCKLoggerLevel,
                  fromFunction function: String,
                  location: String) {
    if enableSDKLogging {
      // Send SDK's log messages directly to the console.
      print("\(location): \(function) - \(message)")
    }
  }
}

कास्ट बटन

GCKCastContext को शुरू करने के बाद, हमें कास्ट करने का बटन जोड़ना होगा, ताकि उपयोगकर्ता कास्ट करने के लिए कोई डिवाइस चुन सके. Cast SDK, Cast बटन कॉम्पोनेंट उपलब्ध कराता है. इसे GCKUICastButton कहा जाता है. यह UIButton सबक्लास के तौर पर उपलब्ध होता है. इसे ऐप्लिकेशन के टाइटल बार में जोड़ा जा सकता है. इसके लिए, इसे UIBarButtonItem में रैप करना होगा. हमें MediaTableViewController और MediaViewController, दोनों में Cast बटन जोड़ना होगा.

MediaTableViewController.swift और MediaViewController.swift में यह कोड जोड़ें:

import GoogleCast

@objc(MediaTableViewController)
class MediaTableViewController: UITableViewController, GCKSessionManagerListener,
  MediaListModelDelegate, GCKRequestDelegate {
  private var castButton: GCKUICastButton!
  ...
  override func viewDidLoad() {
    print("MediaTableViewController - viewDidLoad")
    super.viewDidLoad()

    ...
    castButton = GCKUICastButton(frame: CGRect(x: CGFloat(0), y: CGFloat(0),
                                               width: CGFloat(24), height: CGFloat(24)))
    // Overwrite the UIAppearance theme in the AppDelegate.
    castButton.tintColor = UIColor.white
    navigationItem.rightBarButtonItem = UIBarButtonItem(customView: castButton)

    ...
  }
  ...
}

इसके बाद, अपनी MediaViewController.swift में यह कोड जोड़ें:

import GoogleCast

@objc(MediaViewController)
class MediaViewController: UIViewController, GCKSessionManagerListener, GCKRemoteMediaClientListener,
  LocalPlayerViewDelegate, GCKRequestDelegate {
  private var castButton: GCKUICastButton!
  ...
  override func viewDidLoad() {
    super.viewDidLoad()
    print("in MediaViewController viewDidLoad")
    ...
    castButton = GCKUICastButton(frame: CGRect(x: CGFloat(0), y: CGFloat(0),
                                               width: CGFloat(24), height: CGFloat(24)))
    // Overwrite the UIAppearance theme in the AppDelegate.
    castButton.tintColor = UIColor.white
    navigationItem.rightBarButtonItem = UIBarButtonItem(customView: castButton)

    ...
  }
  ...
}

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

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

6. वीडियो कॉन्टेंट कास्ट करना

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

मीडिया कास्ट करना

अगर आपको किसी कास्ट डिवाइस पर मीडिया चलाना है, तो यह तरीका अपनाएं:

1. Cast SDK से GCKMediaInformation ऑब्जेक्ट बनाएं. यह ऑब्जेक्ट, मीडिया आइटम को मॉडल करता है.
2. उपयोगकर्ता, Cast डिवाइस से कनेक्ट करके आपके रिसीवर ऐप्लिकेशन को लॉन्च करता है.
3. GCKMediaInformation ऑब्जेक्ट को अपने रिसीवर में लोड करें और कॉन्टेंट चलाएं.
4. मीडिया के स्टेटस को ट्रैक करता है.
5. उपयोगकर्ता के इंटरैक्शन के आधार पर, रिसीवर को वीडियो चलाने के निर्देश भेजें.

पहले चरण में, एक ऑब्जेक्ट को दूसरे ऑब्जेक्ट से मैप किया जाता है. GCKMediaInformation एक ऐसा ऑब्जेक्ट है जिसे Cast SDK समझता है और MediaItem, मीडिया आइटम के लिए हमारे ऐप्लिकेशन का एनकैप्सुलेशन है. हम आसानी से MediaItem को GCKMediaInformation से मैप कर सकते हैं. हम पिछले सेक्शन में, दूसरे चरण को पहले ही पूरा कर चुके हैं. Cast SDK की मदद से, तीसरा चरण आसानी से पूरा किया जा सकता है.

सैंपल ऐप्लिकेशन MediaViewController, इस enum का इस्तेमाल करके पहले से ही लोकल और रिमोट प्लेबैक के बीच अंतर करता है:

enum PlaybackMode: Int {
  case none = 0
  case local
  case remote
}

private var playbackMode = PlaybackMode.none

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

फ़िलहाल, लोकल प्लेयर हमेशा लोकल प्लेबैक की स्थिति में होता है, क्योंकि इसे कास्टिंग की स्थितियों के बारे में कोई जानकारी नहीं होती. हमें Cast फ़्रेमवर्क में होने वाले स्टेट ट्रांज़िशन के आधार पर, यूज़र इंटरफ़ेस (यूआई) को अपडेट करना होगा. उदाहरण के लिए, अगर हम कास्टिंग शुरू करते हैं, तो हमें लोकल प्लेबैक को रोकना होगा और कुछ कंट्रोल को बंद करना होगा. इसी तरह, अगर हम इस व्यू कंट्रोलर में कास्ट करना बंद कर देते हैं, तो हमें लोकल प्लेबैक पर स्विच करना होगा. इसके लिए, हमें Cast फ़्रेमवर्क से जनरेट होने वाले अलग-अलग इवेंट को सुनना होगा.

कास्ट सेशन का मैनेजमेंट

Cast फ़्रेमवर्क के लिए, Cast सेशन में ये चरण शामिल होते हैं: किसी डिवाइस से कनेक्ट करना, लॉन्च करना (या शामिल होना), रिसीवर ऐप्लिकेशन से कनेक्ट करना, और अगर ज़रूरी हो, तो मीडिया कंट्रोल चैनल शुरू करना. मीडिया कंट्रोल चैनल की मदद से, Cast फ़्रेमवर्क, रिसीवर मीडिया प्लेयर से मैसेज भेजता और पाता है.

जब उपयोगकर्ता, कास्ट करने के बटन से कोई डिवाइस चुनता है, तो कास्टिंग सेशन अपने-आप शुरू हो जाएगा. साथ ही, जब उपयोगकर्ता डिसकनेक्ट करता है, तो यह अपने-आप बंद हो जाएगा. नेटवर्क से जुड़ी समस्याओं की वजह से, रिसीवर सेशन से फिर से कनेक्ट करने की प्रोसेस को भी Cast फ़्रेमवर्क अपने-आप मैनेज करता है.

कास्ट सेशन को GCKSessionManager मैनेज करता है. इसे GCKCastContext.sharedInstance().sessionManager के ज़रिए ऐक्सेस किया जा सकता है. GCKSessionManagerListener कॉलबैक का इस्तेमाल, सेशन इवेंट को मॉनिटर करने के लिए किया जा सकता है. जैसे, सेशन बनाना, निलंबित करना, फिर से शुरू करना, और खत्म करना.

सबसे पहले, हमें अपने सेशन लिसनर को रजिस्टर करना होगा और कुछ वैरिएबल को शुरू करना होगा:

class MediaViewController: UIViewController, GCKSessionManagerListener,
  GCKRemoteMediaClientListener, LocalPlayerViewDelegate, GCKRequestDelegate {

  ...
  private var sessionManager: GCKSessionManager!
  ...

  required init?(coder: NSCoder) {
    super.init(coder: coder)

    sessionManager = GCKCastContext.sharedInstance().sessionManager

    ...
  }

  override func viewWillAppear(_ animated: Bool) {
    ...

    let hasConnectedSession: Bool = (sessionManager.hasConnectedSession())
    if hasConnectedSession, (playbackMode != .remote) {
      populateMediaInfo(false, playPosition: 0)
      switchToRemotePlayback()
    } else if sessionManager.currentSession == nil, (playbackMode != .local) {
      switchToLocalPlayback()
    }

    sessionManager.add(self)

    ...
  }

  override func viewWillDisappear(_ animated: Bool) {
    ...

    sessionManager.remove(self)
    sessionManager.currentCastSession?.remoteMediaClient?.remove(self)
    ...
    super.viewWillDisappear(animated)
  }

  func switchToLocalPlayback() {
    ...

    sessionManager.currentCastSession?.remoteMediaClient?.remove(self)

    ...
  }

  func switchToRemotePlayback() {
    ...

    sessionManager.currentCastSession?.remoteMediaClient?.add(self)

    ...
  }


  // MARK: - GCKSessionManagerListener

  func sessionManager(_: GCKSessionManager, didStart session: GCKSession) {
    print("MediaViewController: sessionManager didStartSession \(session)")
    setQueueButtonVisible(true)
    switchToRemotePlayback()
  }

  func sessionManager(_: GCKSessionManager, didResumeSession session: GCKSession) {
    print("MediaViewController: sessionManager didResumeSession \(session)")
    setQueueButtonVisible(true)
    switchToRemotePlayback()
  }

  func sessionManager(_: GCKSessionManager, didEnd _: GCKSession, withError error: Error?) {
    print("session ended with error: \(String(describing: error))")
    let message = "The Casting session has ended.\n\(String(describing: error))"
    if let window = appDelegate?.window {
      Toast.displayMessage(message, for: 3, in: window)
    }
    setQueueButtonVisible(false)
    switchToLocalPlayback()
  }

  func sessionManager(_: GCKSessionManager, didFailToStartSessionWithError error: Error?) {
    if let error = error {
      showAlert(withTitle: "Failed to start a session", message: error.localizedDescription)
    }
    setQueueButtonVisible(false)
  }

  func sessionManager(_: GCKSessionManager,
                      didFailToResumeSession _: GCKSession, withError _: Error?) {
    if let window = UIApplication.shared.delegate?.window {
      Toast.displayMessage("The Casting session could not be resumed.",
                           for: 3, in: window)
    }
    setQueueButtonVisible(false)
    switchToLocalPlayback()
  }

  ...
}

MediaViewController में, हमें कास्ट डिवाइस से कनेक्ट या डिसकनेक्ट होने पर सूचना चाहिए, ताकि हम लोकल प्लेयर पर स्विच कर सकें. ध्यान दें कि कनेक्टिविटी में रुकावट सिर्फ़ आपके मोबाइल डिवाइस पर चल रहे ऐप्लिकेशन की वजह से नहीं आती. ऐसा किसी दूसरे मोबाइल डिवाइस पर चल रहे आपके (या किसी दूसरे) ऐप्लिकेशन की वजह से भी हो सकता है.

फ़िलहाल, चालू सेशन को GCKCastContext.sharedInstance().sessionManager.currentCastSession के तौर पर ऐक्सेस किया जा सकता है. उपयोगकर्ता के जेस्चर के जवाब में, सेशन अपने-आप बनते और बंद होते हैं. ये जेस्चर, कास्ट करने के डायलॉग से किए जाते हैं.

मीडिया लोड हो रहा है

Cast SDK में, GCKRemoteMediaClient, रिसीवर डिवाइस पर रिमोट मीडिया प्लेबैक को मैनेज करने के लिए, एपीआई का एक सेट उपलब्ध कराता है. मीडिया चलाने की सुविधा देने वाले GCKCastSession के लिए, एसडीके GCKRemoteMediaClient का इंस्टेंस अपने-आप बना देगा. इसे GCKCastSession इंस्टेंस की remoteMediaClient प्रॉपर्टी के तौर पर ऐक्सेस किया जा सकता है.

MediaViewController.swift में यह कोड जोड़ें, ताकि रिसीवर पर फ़िलहाल चुना गया वीडियो लोड हो सके:

@objc(MediaViewController)
class MediaViewController: UIViewController, GCKSessionManagerListener,
  GCKRemoteMediaClientListener, LocalPlayerViewDelegate, GCKRequestDelegate {
  ...

  @objc func playSelectedItemRemotely() {
    loadSelectedItem(byAppending: false)
  }

  /**
   * Loads the currently selected item in the current cast media session.
   * @param appending If YES, the item is appended to the current queue if there
   * is one. If NO, or if
   * there is no queue, a new queue containing only the selected item is created.
   */
  func loadSelectedItem(byAppending appending: Bool) {
    print("enqueue item \(String(describing: mediaInfo))")
    if let remoteMediaClient = sessionManager.currentCastSession?.remoteMediaClient {
      let mediaQueueItemBuilder = GCKMediaQueueItemBuilder()
      mediaQueueItemBuilder.mediaInformation = mediaInfo
      mediaQueueItemBuilder.autoplay = true
      mediaQueueItemBuilder.preloadTime = TimeInterval(UserDefaults.standard.integer(forKey: kPrefPreloadTime))
      let mediaQueueItem = mediaQueueItemBuilder.build()
      if appending {
        let request = remoteMediaClient.queueInsert(mediaQueueItem, beforeItemWithID: kGCKMediaQueueInvalidItemID)
        request.delegate = self
      } else {
        let queueDataBuilder = GCKMediaQueueDataBuilder(queueType: .generic)
        queueDataBuilder.items = [mediaQueueItem]
        queueDataBuilder.repeatMode = remoteMediaClient.mediaStatus?.queueRepeatMode ?? .off

        let mediaLoadRequestDataBuilder = GCKMediaLoadRequestDataBuilder()
        mediaLoadRequestDataBuilder.mediaInformation = mediaInfo
        mediaLoadRequestDataBuilder.queueData = queueDataBuilder.build()

        let request = remoteMediaClient.loadMedia(with: mediaLoadRequestDataBuilder.build())
        request.delegate = self
      }
    }
  }
  ...
}

अब रिमोट प्लेबैक की सुविधा के लिए, Cast Session लॉजिक का इस्तेमाल करने के लिए, मौजूदा तरीकों को अपडेट करें:

required init?(coder: NSCoder) {
  super.init(coder: coder)
  ...
  castMediaController = GCKUIMediaController()
  ...
}

func switchToLocalPlayback() {
  print("switchToLocalPlayback")
  if playbackMode == .local {
    return
  }
  setQueueButtonVisible(false)
  var playPosition: TimeInterval = 0
  var paused: Bool = false
  var ended: Bool = false
  if playbackMode == .remote {
    playPosition = castMediaController.lastKnownStreamPosition
    paused = (castMediaController.lastKnownPlayerState == .paused)
    ended = (castMediaController.lastKnownPlayerState == .idle)
    print("last player state: \(castMediaController.lastKnownPlayerState), ended: \(ended)")
  }
  populateMediaInfo((!paused && !ended), playPosition: playPosition)
  sessionManager.currentCastSession?.remoteMediaClient?.remove(self)
  playbackMode = .local
}

func switchToRemotePlayback() {
  print("switchToRemotePlayback; mediaInfo is \(String(describing: mediaInfo))")
  if playbackMode == .remote {
    return
  }
  // If we were playing locally, load the local media on the remote player
  if playbackMode == .local, (_localPlayerView.playerState != .stopped), (mediaInfo != nil) {
    print("loading media: \(String(describing: mediaInfo))")
    let paused: Bool = (_localPlayerView.playerState == .paused)
    let mediaQueueItemBuilder = GCKMediaQueueItemBuilder()
    mediaQueueItemBuilder.mediaInformation = mediaInfo
    mediaQueueItemBuilder.autoplay = !paused
    mediaQueueItemBuilder.preloadTime = TimeInterval(UserDefaults.standard.integer(forKey: kPrefPreloadTime))
    mediaQueueItemBuilder.startTime = _localPlayerView.streamPosition ?? 0
    let mediaQueueItem = mediaQueueItemBuilder.build()

    let queueDataBuilder = GCKMediaQueueDataBuilder(queueType: .generic)
    queueDataBuilder.items = [mediaQueueItem]
    queueDataBuilder.repeatMode = .off

    let mediaLoadRequestDataBuilder = GCKMediaLoadRequestDataBuilder()
    mediaLoadRequestDataBuilder.queueData = queueDataBuilder.build()

    let request = sessionManager.currentCastSession?.remoteMediaClient?.loadMedia(with: mediaLoadRequestDataBuilder.build())
    request?.delegate = self
  }
  _localPlayerView.stop()
  _localPlayerView.showSplashScreen()
  setQueueButtonVisible(true)
  sessionManager.currentCastSession?.remoteMediaClient?.add(self)
  playbackMode = .remote
}

/* Play has been pressed in the LocalPlayerView. */
func continueAfterPlayButtonClicked() -> Bool {
  let hasConnectedCastSession = sessionManager.hasConnectedCastSession
  if mediaInfo != nil, hasConnectedCastSession() {
    // Display an alert box to allow the user to add to queue or play
    // immediately.
    if actionSheet == nil {
      actionSheet = ActionSheet(title: "Play Item", message: "Select an action", cancelButtonText: "Cancel")
      actionSheet?.addAction(withTitle: "Play Now", target: self,
                             selector: #selector(playSelectedItemRemotely))
    }
    actionSheet?.present(in: self, sourceView: _localPlayerView)
    return false
  }
  return true
}

अब अपने फ़ोन या टैबलेट पर ऐप्लिकेशन चलाएं. कास्ट करने की सुविधा वाले डिवाइस से कनेक्ट करें और वीडियो चलाना शुरू करें. आपको रिसीवर पर वीडियो चलता हुआ दिखेगा.

7. मिनी कंट्रोलर

Cast डिज़ाइन चेकलिस्ट के मुताबिक, Cast की सुविधा वाले सभी ऐप्लिकेशन में मिनी कंट्रोलर उपलब्ध होना चाहिए. यह तब दिखता है, जब उपयोगकर्ता मौजूदा कॉन्टेंट पेज से हट जाता है. मिनी कंट्रोलर की मदद से, मौजूदा कास्ट सेशन को तुरंत ऐक्सेस किया जा सकता है. साथ ही, यह कास्ट सेशन के बारे में सूचना भी दिखाता है.

Cast SDK, कंट्रोल बार GCKUIMiniMediaControlsViewController उपलब्ध कराता है. इसे उन सीन में जोड़ा जा सकता है जिनमें आपको लगातार दिखने वाले कंट्रोल दिखाने हैं.

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

AppDelegate.swift फ़ाइल में बदलाव करें और if useCastContainerViewController शर्त के लिए, यहां दिया गया कोड इस तरीके से जोड़ें:

func application(_: UIApplication,
                 didFinishLaunchingWithOptions _: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
  ...
  let appStoryboard = UIStoryboard(name: "Main", bundle: nil)
  guard let navigationController = appStoryboard.instantiateViewController(withIdentifier: "MainNavigation")
    as? UINavigationController else { return false }
  let castContainerVC = GCKCastContext.sharedInstance().createCastContainerController(for: navigationController)
    as GCKUICastContainerViewController
  castContainerVC.miniMediaControlsItemEnabled = true
  window = UIWindow(frame: UIScreen.main.bounds)
  window?.rootViewController = castContainerVC
  window?.makeKeyAndVisible()
  ...
}

मिनी कंट्रोलर की विज़िबिलिटी को कंट्रोल करने के लिए, इस प्रॉपर्टी और सेटर/गेटर को जोड़ें. हम इनका इस्तेमाल बाद के सेक्शन में करेंगे:

var isCastControlBarsEnabled: Bool {
    get {
      if useCastContainerViewController {
        let castContainerVC = (window?.rootViewController as? GCKUICastContainerViewController)
        return castContainerVC!.miniMediaControlsItemEnabled
      } else {
        let rootContainerVC = (window?.rootViewController as? RootContainerViewController)
        return rootContainerVC!.miniMediaControlsViewEnabled
      }
    }
    set(notificationsEnabled) {
      if useCastContainerViewController {
        var castContainerVC: GCKUICastContainerViewController?
        castContainerVC = (window?.rootViewController as? GCKUICastContainerViewController)
        castContainerVC?.miniMediaControlsItemEnabled = notificationsEnabled
      } else {
        var rootContainerVC: RootContainerViewController?
        rootContainerVC = (window?.rootViewController as? RootContainerViewController)
        rootContainerVC?.miniMediaControlsViewEnabled = notificationsEnabled
      }
    }
  }

ऐप्लिकेशन चलाएं और कोई वीडियो कास्ट करें. जब रिसीवर पर वीडियो चलने लगे, तब आपको हर सीन के सबसे नीचे मिनी कंट्रोलर दिखेगा. मिनी कंट्रोलर का इस्तेमाल करके, रिमोट पर चल रहे वीडियो को कंट्रोल किया जा सकता है. ब्राउज़ करने की गतिविधि और लोकल प्लेयर की गतिविधि के बीच नेविगेट करने पर, मिनी कंट्रोलर की स्थिति, रिसीवर पर मीडिया प्लेबैक की स्थिति के साथ सिंक होनी चाहिए.

8. सामान्य जानकारी देने वाला ओवरले

Google Cast के डिज़ाइन की चेकलिस्ट के मुताबिक, सेंडर ऐप्लिकेशन को मौजूदा उपयोगकर्ताओं के लिए कास्ट बटन दिखाना ज़रूरी है. इससे उन्हें पता चलेगा कि सेंडर ऐप्लिकेशन अब कास्ट करने की सुविधा के साथ काम करता है. साथ ही, इससे Google Cast का इस्तेमाल करने वाले नए लोगों को भी मदद मिलती है.

GCKCastContext क्लास में एक तरीका है, presentCastInstructionsViewControllerOnce. इसका इस्तेमाल, Cast बटन को पहली बार उपयोगकर्ताओं को दिखाए जाने पर हाइलाइट करने के लिए किया जा सकता है. MediaViewController.swift और MediaTableViewController.swift में यह कोड जोड़ें:

override func viewDidLoad() {
  ...

  NotificationCenter.default.addObserver(self, selector: #selector(castDeviceDidChange),
                                         name: NSNotification.Name.gckCastStateDidChange,
                                         object: GCKCastContext.sharedInstance())
}

@objc func castDeviceDidChange(_: Notification) {
  if GCKCastContext.sharedInstance().castState != .noDevicesAvailable {
    // You can present the instructions on how to use Google Cast on
    // the first time the user uses you app
    GCKCastContext.sharedInstance().presentCastInstructionsViewControllerOnce(with: castButton)
  }
}

अपने फ़ोन या टैबलेट पर ऐप्लिकेशन चलाएँ. आपको शुरुआती जानकारी देने वाला ओवरले दिखेगा.

9. बड़ा किया गया कंट्रोलर

Google Cast डिज़ाइन चेकलिस्ट के मुताबिक, सेंडर ऐप्लिकेशन को कास्ट किए जा रहे मीडिया के लिए बड़ा किया गया कंट्रोलर उपलब्ध कराना होगा. बड़ा किया गया कंट्रोलर, मिनी कंट्रोलर का फ़ुल स्क्रीन वर्शन होता है.

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

इस व्यू की सुविधा, GCKUIExpandedMediaControlsViewController क्लास से लागू की जाती है.

सबसे पहले, आपको कास्ट कॉन्टेक्स्ट में डिफ़ॉल्ट रूप से बड़ा किया गया कंट्रोलर चालू करना होगा. डिफ़ॉल्ट रूप से बड़ा किया गया कंट्रोलर चालू करने के लिए, AppDelegate.swift में बदलाव करें:

import GoogleCast

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
  ...

  func application(_: UIApplication,
                   didFinishLaunchingWithOptions _: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    ...
    // Add after the setShareInstanceWith(options) is set.
    GCKCastContext.sharedInstance().useDefaultExpandedMediaControls = true
    ...
  }
  ...
}

जब उपयोगकर्ता वीडियो कास्ट करना शुरू करे, तब बड़े किए गए कंट्रोलर को लोड करने के लिए, MediaViewController.swift में यह कोड जोड़ें:

@objc func playSelectedItemRemotely() {
  ...
  appDelegate?.isCastControlBarsEnabled = false
  GCKCastContext.sharedInstance().presentDefaultExpandedMediaControls()
}

उपयोगकर्ता के मिनी कंट्रोलर पर टैप करने पर, बड़ा किया गया कंट्रोलर भी अपने-आप लॉन्च हो जाएगा.

ऐप्लिकेशन चलाएं और कोई वीडियो कास्ट करें. आपको बड़ा किया गया कंट्रोलर दिखेगा. वीडियो की सूची पर वापस जाएं. इसके बाद, मिनी कंट्रोलर पर क्लिक करने से, बड़ा किया गया कंट्रोलर फिर से लोड हो जाएगा.

10. Cast Connect की सुविधा जोड़ना

Cast Connect लाइब्रेरी की मदद से, मौजूदा सेंडर ऐप्लिकेशन, Cast प्रोटोकॉल के ज़रिए Android TV ऐप्लिकेशन से कम्यूनिकेट कर सकते हैं. Cast Connect, Cast के इन्फ़्रास्ट्रक्चर पर काम करता है. इसमें आपका Android TV ऐप्लिकेशन, रिसीवर के तौर पर काम करता है.

डिपेंडेंसी

अपने Podfile में, पक्का करें कि google-cast-sdk, 4.4.8 या इसके बाद वाले वर्शन पर सेट हो. इसके बारे में यहां बताया गया है. अगर आपने फ़ाइल में कोई बदलाव किया है, तो बदलाव को अपने प्रोजेक्ट के साथ सिंक करने के लिए, कंसोल से pod update चलाएं.

pod 'google-cast-sdk', '>=4.4.8'

GCKLaunchOptions

Android TV ऐप्लिकेशन लॉन्च करने के लिए, जिसे Android रिसीवर भी कहा जाता है, हमें GCKLaunchOptions ऑब्जेक्ट में androidReceiverCompatible फ़्लैग को सही पर सेट करना होगा. यह GCKLaunchOptions ऑब्जेक्ट यह तय करता है कि रिसीवर को कैसे लॉन्च किया जाए. साथ ही, इसे GCKCastOptions को पास किया जाता है. ये GCKCastOptions, GCKCastContext.setSharedInstanceWith का इस्तेमाल करके शेयर किए गए इंस्टेंस में सेट किए जाते हैं.

अपनी AppDelegate.swift फ़ाइल में ये लाइनें जोड़ें:

let options = GCKCastOptions(discoveryCriteria:
                          GCKDiscoveryCriteria(applicationID: kReceiverAppID))
...
/** Following code enables CastConnect */
let launchOptions = GCKLaunchOptions()
launchOptions.androidReceiverCompatible = true
options.launchOptions = launchOptions

GCKCastContext.setSharedInstanceWith(options)

लॉन्च क्रेडेंशियल सेट करना

भेजने वाले व्यक्ति के लिए, GCKCredentialsData को यह बताने के लिए सेट किया जा सकता है कि सेशन में कौन शामिल हो रहा है. credentials एक स्ट्रिंग है, जिसे उपयोगकर्ता तय कर सकता है. हालांकि, यह ज़रूरी है कि आपका ATV ऐप्लिकेशन इसे समझ सके. GCKCredentialsData को सिर्फ़ लॉन्च या शामिल होने के समय, आपके Android TV ऐप्लिकेशन को पास किया जाता है. अगर कनेक्ट रहने के दौरान इसे फिर से सेट किया जाता है, तो इसे Android TV ऐप्लिकेशन पर नहीं भेजा जाएगा.

लॉन्च क्रेडेंशियल सेट करने के लिए, GCKLaunchOptions सेट होने के बाद किसी भी समय GCKCredentialsData को तय किया जाना चाहिए. इसे दिखाने के लिए, आइए Creds बटन के लिए लॉजिक जोड़ते हैं, ताकि सेशन शुरू होने पर क्रेडेंशियल सेट किए जा सकें. अपने MediaTableViewController.swift में यह कोड जोड़ें:

class MediaTableViewController: UITableViewController, GCKSessionManagerListener, MediaListModelDelegate, GCKRequestDelegate {
  ...
  private var credentials: String? = nil
  ...
  override func viewDidLoad() {
    ...
    navigationItem.leftBarButtonItem = UIBarButtonItem(title: "Creds", style: .plain,
                                                       target: self, action: #selector(toggleLaunchCreds))
    ...
    setLaunchCreds()
  }
  ...
  @objc func toggleLaunchCreds(_: Any){
    if (credentials == nil) {
        credentials = "{\"userId\":\"id123\"}"
    } else {
        credentials = nil
    }
    Toast.displayMessage("Launch Credentials: "+(credentials ?? "Null"), for: 3, in: appDelegate?.window)
    print("Credentials set: "+(credentials ?? "Null"))
    setLaunchCreds()
  }
  ...
  func setLaunchCreds() {
    GCKCastContext.sharedInstance()
        .setLaunch(GCKCredentialsData(credentials: credentials))
  }
}

लोड करने के अनुरोध पर क्रेडेंशियल सेट करना

अपने वेब और Android TV रिसीवर ऐप्लिकेशन, दोनों पर credentials को मैनेज करने के लिए, loadSelectedItem फ़ंक्शन के तहत अपनी MediaTableViewController.swift क्लास में यह कोड जोड़ें:

let mediaLoadRequestDataBuilder = GCKMediaLoadRequestDataBuilder()
...
mediaLoadRequestDataBuilder.credentials = credentials
...

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

Cast Connect की जांच करना

Chromecast with Google TV पर Android TV APK इंस्टॉल करने का तरीका

1. अपने Android TV डिवाइस का आईपी पता ढूंढें. आम तौर पर, यह सेटिंग > नेटवर्क और इंटरनेट > (आपके डिवाइस से कनेक्ट किए गए नेटवर्क का नाम) में उपलब्ध होता है. दाईं ओर, आपको नेटवर्क पर मौजूद आपके डिवाइस की जानकारी और आईपी पते की जानकारी दिखेगी.
2. टर्मिनल का इस्तेमाल करके, एडीबी के ज़रिए अपने डिवाइस से कनेक्ट करने के लिए, डिवाइस के आईपी पते का इस्तेमाल करें:

$ adb connect <device_ip_address>:5555

3. अपने टर्मिनल विंडो में, कोडलैब के उन सैंपल के टॉप लेवल फ़ोल्डर पर जाएं जिन्हें आपने इस कोडलैब की शुरुआत में डाउनलोड किया था. उदाहरण के लिए:

$ cd Desktop/ios_codelab_src

4. इस फ़ोल्डर में मौजूद .apk फ़ाइल को अपने Android TV पर इंस्टॉल करने के लिए, यह कमांड चलाएं:

$ adb -s <device_ip_address>:5555 install android-tv-app.apk

5. अब आपको अपने Android TV डिवाइस पर, आपके ऐप्लिकेशन मेन्यू में वीडियो कास्ट करें नाम का ऐप्लिकेशन दिखेगा.
6. इसके बाद, ऐप्लिकेशन को किसी एम्युलेटर या मोबाइल डिवाइस पर बनाएं और चलाएं. Android TV डिवाइस के साथ कास्ट सेशन शुरू करने पर, अब यह आपके Android TV पर Android Receiver ऐप्लिकेशन लॉन्च करेगा. iOS डिवाइस से वीडियो चलाने पर, वह Android TV डिवाइस पर चलना चाहिए. साथ ही, Android TV डिवाइस के रिमोट का इस्तेमाल करके, वीडियो चलाने की सुविधा को कंट्रोल किया जा सकता हो.

11. कास्ट करने की सुविधा वाले विजेट को पसंद के मुताबिक बनाना

डेटा लेयर में इवेंट बनाने की प्रोसेस

App-Done फ़ोल्डर से शुरू करें. अपनी AppDelegate.swift फ़ाइल में, applicationDidFinishLaunchingWithOptions तरीके में यह कोड जोड़ें.

func application(_: UIApplication,
                 didFinishLaunchingWithOptions _: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
  ...
  let styler = GCKUIStyle.sharedInstance()
  ...
}

कोडलैब के इस मॉड्यूल के बाकी बचे हिस्से में बताए गए तरीके से, एक या उससे ज़्यादा बदलाव करने के बाद, नीचे दिए गए कोड को कॉल करके स्टाइल लागू करें

styler.apply()

कास्ट किए गए व्यू को पसंद के मुताबिक बनाना

Cast Application Framework मैनेज किए जाने वाले सभी व्यू को पसंद के मुताबिक बनाया जा सकता है. इसके लिए, सभी व्यू में स्टाइल से जुड़े डिफ़ॉल्ट दिशा-निर्देश होने चाहिए. उदाहरण के लिए, आइकॉन के रंग को बदलते हैं.

styler.castViews.iconTintColor = .lightGray

अगर ज़रूरत हो, तो हर स्क्रीन के हिसाब से डिफ़ॉल्ट सेटिंग बदली जा सकती हैं. उदाहरण के लिए, सिर्फ़ बड़े किए गए मीडिया कंट्रोलर के लिए, आइकॉन के रंग के लिए lightGrayColor को बदलने के लिए.

styler.castViews.mediaControl.expandedController.iconTintColor = .green

रंग बदलना

सभी व्यू के लिए बैकग्राउंड का रंग अपनी पसंद के मुताबिक बनाया जा सकता है. इसके अलावा, हर व्यू के लिए अलग-अलग रंग भी चुना जा सकता है. नीचे दिए गए कोड से, Cast Application Framework की मदद से उपलब्ध कराई गई सभी व्यू के लिए, बैकग्राउंड का रंग नीला सेट किया जाता है.

styler.castViews.backgroundColor = .blue
styler.castViews.mediaControl.miniController.backgroundColor = .yellow

फ़ॉन्ट बदलना

कास्ट व्यू में दिखने वाले अलग-अलग लेबल के लिए, फ़ॉन्ट को पसंद के मुताबिक बनाया जा सकता है. उदाहरण के तौर पर दिखाने के लिए, सभी फ़ॉन्ट को ‘Courier-Oblique' पर सेट करते हैं.

styler.castViews.headingTextFont = UIFont.init(name: "Courier-Oblique", size: 16) ?? UIFont.systemFont(ofSize: 16)
styler.castViews.mediaControl.headingTextFont = UIFont.init(name: "Courier-Oblique", size: 6) ?? UIFont.systemFont(ofSize: 6)

डिफ़ॉल्ट बटन की इमेज बदलना

प्रोजेक्ट में अपनी पसंद के मुताबिक इमेज जोड़ें. साथ ही, इमेज को बटन असाइन करके उन्हें स्टाइल करें.

let muteOnImage = UIImage.init(named: "yourImage.png")
if let muteOnImage = muteOnImage {
  styler.castViews.muteOnImage = muteOnImage
}

कास्ट बटन की थीम बदलना

UIAppearance प्रोटोकॉल का इस्तेमाल करके, कास्ट विजेट को भी थीम किया जा सकता है. यहां दिया गया कोड, GCKUICastButton को उन सभी व्यू पर थीम करता है जहां यह दिखता है:

GCKUICastButton.appearance().tintColor = UIColor.gray

12. बधाई हो

अब आपको iOS पर Cast SDK विजेट का इस्तेमाल करके, वीडियो ऐप्लिकेशन में कास्ट करने की सुविधा चालू करने का तरीका पता चल गया है.

ज़्यादा जानकारी के लिए, iOS Sender डेवलपर गाइड देखें.