Variable playback rate
Your app can display and change the playback rate for the current media item.
Set the rate using
-[setPlaybackRate:]
or -[setPlaybackRate:customData:]
Access the playback rate controller at
playbackRateController.
Display the current playback rate at
GCKUIPlaybackRateController.
Sample code
The following two files implement GCKUIPlaybackRateController which controls the playback rate using a segmented control that has "normal", "half speed", and "double speed" buttons.
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
Add a custom channel
The Cast framework retains the GCKCastChannel and GCKGenericChannel classes of Cast v2. The former class is meant to be subclassed to implement non-trivial channels that have associated state. The latter class is provided as an alternative to subclassing; it passes its received messages to a delegate so that they can be processed elsewhere.
In Cast v2, custom channels were enabled/disabled by registering/unregistering
them with the GCKDeviceManager
. That class is deprecated in CAF;
channels must now be registered/unregistered with the
GCKCastSession instead,
using its
-[addChannel:]
and
-[removeChannel:]
methods.
The Cast framework provides two ways to create a channel to send custom messages to a receiver:
- GCKCastChannel is meant to be subclassed to implement non-trivial channels that have associated state.
- GCKGenericChannel is provided as an alternative to subclassing; it passes its received messages to a delegate so that they can be processed elsewhere.
Here is an example of a GCKCastChannel implementation:
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
A channel can be registered at any time; if the session is not currently in a connected state, the channel will automatically become connected when the session itself is connected, provided that the channel's namespace is present in the receiver app metadata's list of supported namespaces.
Each custom channel is defined by a unique namespace and must start with the
prefix urn:x-cast:
, for example, urn:x-cast:com.example.custom
. It is
possible to have multiple custom channels, each with a unique namespace. The
receiver app can also send and receive
messages
using the same namespace.
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); }
To provide logic that needs to execute when a particular channel becomes
connected or disconnected, override the
-[didConnect]
and
-[didDisconnect]
methods if using GCKCastChannel
, or provide implementations for the
-[castChannelDidConnect:] and -[castChannelDidDisconnect:] methods of the
GCKGenericChannelDelegate
if using
GCKGenericChannel.
Supporting Autoplay
Override image selection and caching
Various components of the framework (namely the Cast dialog,
the mini controller, the expanded controller,
and the GCKUIMediaController
if so configured) will display artwork for the
currently casting media. The URLs to the image artwork are typically included in
the GCKMediaMetadata for the media, but the sender app may have an alternate
source for the URLs. The GCKUIImagePicker protocol defines a means for selecting
an appropriate image for a given usage and desired size. It has a single method,
-[getImageWithHints:fromMetadata:]
,
which takes a GCKUIImageHints object and a
GCKMediaMetadata object as parameters, and returns a GCKImage
object as a
result. The framework provides a default implementation of GCKUIImagePicker
which always selects the first image in the list of images in the
GKCMediaMetadata
object, but the app can provide an alternate implementation
by setting the imagePicker property of the GCKCastContext
singleton.
The GCKUIImageCache
protocol defines a means of caching images that are
downloaded by the framework via HTTPS. The framework provides oa default
implementation of GCKUIImageCache
which stores downloaded image files in the
app's cache directory, but the app can provide an alternate implementation by
setting the imageCache property of the GCKCastContext
singleton.
Next steps
This concludes the features that you can add to your iOS Sender app. You can now build a sender app for another platform (Android or Chrome), or build a receiver app.