Struct AVPlayer 

pub struct AVPlayer { /* private fields */ }

Available on crate feature AVPlayer only.

AVPlayer offers a playback interface for single-item playback that’s sufficient for the implementation of playback controllers and playback user interfaces.

AVPlayer works equally well with local and remote media files, providing clients with appropriate information about readiness to play or about the need to await additional data before continuing.

Visual content of items played by an instance of AVPlayer can be displayed in a CoreAnimation layer of class AVPlayerLayer.

To allow clients to add and remove their objects as key-value observers safely, AVPlayer serializes notifications of changes that occur dynamically during playback on a dispatch queue. By default, this queue is the main queue. See dispatch_get_main_queue().

See also Apple’s documentation

Implementations

impl AVPlayer

pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>

Initializes an AVPlayer with no player items.

pub unsafe fn playerWithURL( url: &NSURL, mtm: MainThreadMarker, ) -> Retained<Self>

Returns an instance of AVPlayer that plays a single audiovisual resource referenced by URL.

Implicitly creates an AVPlayerItem. Clients can obtain the AVPlayerItem as it becomes the player’s currentItem.

• Parameter URL:

• Returns: An instance of AVPlayer

pub unsafe fn playerWithPlayerItem( item: Option<&AVPlayerItem>, mtm: MainThreadMarker, ) -> Retained<Self>

Available on crate feature AVPlayerItem only.

Create an AVPlayer that plays a single audiovisual item.

Useful in order to play items for which an AVAsset has previously been created. See -[AVPlayerItem initWithAsset:].

• Parameter item:

• Returns: An instance of AVPlayer

pub unsafe fn initWithURL(this: Allocated<Self>, url: &NSURL) -> Retained<Self>

Initializes an AVPlayer that plays a single audiovisual resource referenced by URL.

Implicitly creates an AVPlayerItem. Clients can obtain the AVPlayerItem as it becomes the player’s currentItem.

• Parameter URL:

• Returns: An instance of AVPlayer

pub unsafe fn initWithPlayerItem( this: Allocated<Self>, item: Option<&AVPlayerItem>, ) -> Retained<Self>

Available on crate feature AVPlayerItem only.

Create an AVPlayer that plays a single audiovisual item.

Useful in order to play items for which an AVAsset has previously been created. See -[AVPlayerItem initWithAsset:]. This method throws an exception if the item is not an AVPlayerItem, or if the item is associated with another AVPlayer.

• Parameter item:

• Returns: An instance of AVPlayer

pub unsafe fn status(&self) -> AVPlayerStatus

The ability of the receiver to be used for playback.

The value of this property is an AVPlayerStatus that indicates whether the receiver can be used for playback. When the value of this property is AVPlayerStatusFailed, the receiver can no longer be used for playback and a new instance needs to be created in its place. When this happens, clients can check the value of the error property to determine the nature of the failure. This property is key value observable.

pub unsafe fn error(&self) -> Option<Retained<NSError>>

If the receiver’s status is AVPlayerStatusFailed, this describes the error that caused the failure.

The value of this property is an NSError that describes what caused the receiver to no longer be able to play items. If the receiver’s status is not AVPlayerStatusFailed, the value of this property is nil.

impl AVPlayer

Methods declared on superclass NSObject.

pub unsafe fn new(mtm: MainThreadMarker) -> Retained<Self>

impl AVPlayer

AVPlayerPlaybackControl.

pub unsafe fn rate(&self) -> c_float

Indicates the desired rate of playback; 0.0 means “paused”, 1.0 indicates a desire to play at the natural rate of the current item.

Setting the value of rate to 0.0 pauses playback, causing the value of timeControlStatus to change to AVPlayerTimeControlStatusPaused. Setting the rate to a non-zero value causes the value of timeControlStatus to become either AVPlayerTimeControlStatusWaitingToPlayAtSpecifiedRate or AVPlayerTimeControlStatusPlaying, depending on whether sufficient media data has been buffered for playback to occur and whether the player’s default behavior of waiting in order to minimize stalling is permitted. See discussion of AVPlayerTimeControlStatus for more details.

AVPlayer can reset the desired rate to 0.0 when a change in overall state requires playback to be halted, such as when an interruption occurs on iOS, as announced by AVAudioSession, or when the playback buffer becomes empty and playback stalls while automaticallyWaitsToMinimizeStalling is NO.

The effective rate of playback may differ from the desired rate even while timeControlStatus is AVPlayerTimeControlStatusPlaying, if the processing algorithm in use for managing audio pitch requires quantization of playback rate. For information about quantization of rates for audio processing, see AVAudioProcessingSettings.h. You can always obtain the effective rate of playback from the currentItem’s timebase; see the timebase property of AVPlayerItem.

Before macOS 13, iOS 16, tvOS 16, and watchOS 9, this property must be accessed on the main thread/queue.

pub unsafe fn setRate(&self, rate: c_float)

Setter for rate.

pub unsafe fn defaultRate(&self) -> c_float

Indicates the rate at which to start playback when play is called; defaults to 1.0.

Setting this property does not imply playback starts automatically at this rate. Clients still have to kick off playback using play. Note that using setRate to start playback will skip using the value in this property nor would it update this property. Therefore, setRate:1.0 is no longer recommended as a means to start playback. Use play instead. Use setRate for operations like scanning where the rate is to be updated instantaneously. Invoking play again would restore playback at the rate set in this property.

The effective rate of playback may still differ from the default rate subject to restrictions imposed by the system. See documentation for the rate property for a discussion on when the desired rate does not translate to effective rate.

pub unsafe fn setDefaultRate(&self, default_rate: c_float)

Setter for defaultRate.

pub unsafe fn play(&self)

Signals the desire to begin playback at the rate set in the defaultRate.

For releases up to iOS version 16.0, macOS versions 13.0, tvOS 16.0 and watchOS 9.0, this is equivalent to setting the value of rate to 1.0. Starting from iOS version 16.0, macOS versions 13.0, tvOS 16.0 and watchOS 9.0, this will attempt to use the rate set in the defaultRate property. The effective rate of playback may differ from the defaultRate due to the reasons mentioned in the documentation of the rate property. Clients interested in knowing the effective rate can listen for AVPlayerRateDidChangeNotification notification.

Before macOS 13, iOS 16, tvOS 16, and watchOS 9, this method must be invoked on the main thread/queue.

pub unsafe fn pause(&self)

Pauses playback.

Equivalent to setting the value of rate to 0.0.

Before macOS 13, iOS 16, tvOS 16, and watchOS 9, this method must be invoked on the main thread/queue.

pub unsafe fn timeControlStatus(&self) -> AVPlayerTimeControlStatus

Indicates whether playback is currently paused indefinitely, suspended while waiting for appropriate conditions, or in progress.

For possible values and discussion, see AVPlayerTimeControlStatus.

When automaticallyWaitsToMinimizeStalling is YES, absent intervention in the form of invocations of -setRate: or -pause or, on iOS, an interruption that requires user intervention before playback can resume, the value of the property timeControlStatus automatically changes between AVPlayerTimeControlStatusPlaying and AVPlayerTimeControlStatusWaitingToPlayAtSpecifiedRate depending on whether sufficient media data is available to continue playback. This property is key value observable.

pub unsafe fn reasonForWaitingToPlay( &self, ) -> Option<Retained<AVPlayerWaitingReason>>

Indicates the reason for waiting when the value of timeControlStatus is AVPlayerTimeControlStatusWaitingToPlayAtSpecifiedRate

When the value of timeControlStatus is AVPlayerTimeControlStatusWaitingToPlayAtSpecifiedRate, this property describes why the player is currently waiting. It is nil otherwise. You can use the value of reasonForWaitingToPlay to show UI indicating the player’s waiting state conditionally. This property is key value observable. Possible values are AVPlayerWaitingWithNoItemToPlayReason, AVPlayerWaitingWhileEvaluatingBufferingRateReason, and AVPlayerWaitingToMinimizeStallsReason.

pub unsafe fn playImmediatelyAtRate(&self, rate: c_float)

Immediately plays the available media data at the specified rate.

When the player’s currentItem has a value of NO for playbackBufferEmpty, this method causes the value of rate to change to the specified rate, the value of timeControlStatus to change to AVPlayerTimeControlStatusPlaying, and the receiver to play the available media immediately, whether or not prior buffering of media data is sufficient to ensure smooth playback. If insufficient media data is buffered for playback to start (e.g. if the current item has a value of YES for playbackBufferEmpty), the receiver will act as if the buffer became empty during playback, except that no AVPlayerItemPlaybackStalledNotification will be posted.

Before macOS 13, iOS 16, tvOS 16, and watchOS 9, this method must be invoked on the main thread/queue.

impl AVPlayer

AVPlayerItemControl.

pub unsafe fn currentItem(&self) -> Option<Retained<AVPlayerItem>>

Available on crate feature AVPlayerItem only.

Indicates the current item of the player

pub unsafe fn replaceCurrentItemWithPlayerItem( &self, item: Option<&AVPlayerItem>, )

Available on crate feature AVPlayerItem only.

Replaces the player’s current item with the specified player item.

In all releases of iOS 4, invoking replaceCurrentItemWithPlayerItem: with an AVPlayerItem that’s already the receiver’s currentItem results in an exception being raised. Starting with iOS 5, it’s a no-op. This method throws an exception if the item already exists in the play queue.

• Parameter item: The AVPlayerItem that will become the player’s current item.

pub unsafe fn actionAtItemEnd(&self) -> AVPlayerActionAtItemEnd

Indicates the action that the player should perform when playback of an item reaches its end time.

This property throws an exception if set to AVPlayerActionAtItemEndAdvance on an AVPlayer which is not an AVQueuePlayer.

pub unsafe fn setActionAtItemEnd( &self, action_at_item_end: AVPlayerActionAtItemEnd, )

Setter for actionAtItemEnd.

impl AVPlayer

AVPlayerTimeControl.

pub unsafe fn currentTime(&self) -> CMTime

Available on crate feature objc2-core-media only.

Returns the current time of the current item.

Returns the current time of the current item. Not key-value observable; use -addPeriodicTimeObserverForInterval:queue:usingBlock: instead.

• Returns: A CMTime

pub unsafe fn seekToDate(&self, date: &NSDate)

Moves the playback cursor.

Use this method to seek to a specified time for the current player item. The time seeked to may differ from the specified time for efficiency. For sample accurate seeking see seekToTime:toleranceBefore:toleranceAfter:.

• Parameter date:

pub unsafe fn seekToDate_completionHandler( &self, date: &NSDate, completion_handler: &DynBlock<dyn Fn(Bool)>, )

Available on crate feature block2 only.

Moves the playback cursor and invokes the specified block when the seek operation has either been completed or been interrupted.

Use this method to seek to a specified time for the current player item and to be notified when the seek operation is complete. The completion handler for any prior seek request that is still in process will be invoked immediately with the finished parameter set to NO. If the new request completes without being interrupted by another seek request or by any other operation the specified completion handler will be invoked with the finished parameter set to YES. If no item is attached, the completion handler will be invoked immediately with the finished parameter set to NO.

• Parameter date:
• Parameter completionHandler:

Safety

completion_handler block must be sendable.

pub unsafe fn seekToTime(&self, time: CMTime)

Available on crate feature objc2-core-media only.

Moves the playback cursor.

Use this method to seek to a specified time for the current player item. The time seeked to may differ from the specified time for efficiency. For sample accurate seeking see seekToTime:toleranceBefore:toleranceAfter:.

• Parameter time:

pub unsafe fn seekToTime_toleranceBefore_toleranceAfter( &self, time: CMTime, tolerance_before: CMTime, tolerance_after: CMTime, )

Available on crate feature objc2-core-media only.

Moves the playback cursor within a specified time bound.

Use this method to seek to a specified time for the current player item. The time seeked to will be within the range [time-toleranceBefore, time+toleranceAfter] and may differ from the specified time for efficiency. Pass kCMTimeZero for both toleranceBefore and toleranceAfter to request sample accurate seeking which may incur additional decoding delay. Messaging this method with beforeTolerance:kCMTimePositiveInfinity and afterTolerance:kCMTimePositiveInfinity is the same as messaging seekToTime: directly.

• Parameter time:
• Parameter toleranceBefore:
• Parameter toleranceAfter:

pub unsafe fn seekToTime_completionHandler( &self, time: CMTime, completion_handler: &DynBlock<dyn Fn(Bool)>, )

Available on crate features block2 and objc2-core-media only.

Moves the playback cursor and invokes the specified block when the seek operation has either been completed or been interrupted.

Use this method to seek to a specified time for the current player item and to be notified when the seek operation is complete. The completion handler for any prior seek request that is still in process will be invoked immediately with the finished parameter set to NO. If the new request completes without being interrupted by another seek request or by any other operation the specified completion handler will be invoked with the finished parameter set to YES. If no item is attached, the completion handler will be invoked immediately with the finished parameter set to NO.

• Parameter time:
• Parameter completionHandler:

Safety

completion_handler block must be sendable.

pub unsafe fn seekToTime_toleranceBefore_toleranceAfter_completionHandler( &self, time: CMTime, tolerance_before: CMTime, tolerance_after: CMTime, completion_handler: &DynBlock<dyn Fn(Bool)>, )

Available on crate features block2 and objc2-core-media only.

Moves the playback cursor within a specified time bound and invokes the specified block when the seek operation has either been completed or been interrupted.

Use this method to seek to a specified time for the current player item and to be notified when the seek operation is complete. The time seeked to will be within the range [time-toleranceBefore, time+toleranceAfter] and may differ from the specified time for efficiency. Pass kCMTimeZero for both toleranceBefore and toleranceAfter to request sample accurate seeking which may incur additional decoding delay. Messaging this method with beforeTolerance:kCMTimePositiveInfinity and afterTolerance:kCMTimePositiveInfinity is the same as messaging seekToTime: directly. The completion handler for any prior seek request that is still in process will be invoked immediately with the finished parameter set to NO. If the new request completes without being interrupted by another seek request or by any other operation the specified completion handler will be invoked with the finished parameter set to YES. If no item is attached, the completion handler will be invoked immediately with the finished parameter set to NO.

• Parameter time:
• Parameter toleranceBefore:
• Parameter toleranceAfter:

Safety

completion_handler block must be sendable.

impl AVPlayer

AVPlayerAdvancedRateControl.

pub unsafe fn automaticallyWaitsToMinimizeStalling(&self) -> bool

Indicates that the player is allowed to delay playback at the specified rate in order to minimize stalling

When this property is YES, whenever 1) the rate is set from zero to non-zero or 2) the playback buffer becomes empty and playback stalls, the player will attempt to determine if, at the specified rate, its currentItem will play to the end without interruptions. Should it determine that such interruptions would occur and these interruptions can be avoided by delaying the start or resumption of playback, the value of timeControlStatus will become AVPlayerTimeControlStatusWaitingToPlayAtSpecifiedRate and playback will start automatically when the likelihood of stalling has been minimized.

You may want to set this property to NO when you need precise control over playback start times, e.g., when synchronizing multiple instances of AVPlayer, and you should set it to NO if you use an AVAssetResourceLoader delegate to load media data (more on this below). If the value of this property is NO, reasonForWaitingToPlay cannot assume a value of AVPlayerWaitingToMinimizeStallsReason. This implies that setting rate to a non-zero value in AVPlayerTimeControlStatusPaused will cause playback to start immediately as long as the playback buffer is not empty. When the playback buffer becomes empty during AVPlayerTimeControlStatusPlaying and playback stalls, playback state will switch to AVPlayerTimeControlStatusPaused and the rate will become 0.0.

Changing the value of this property to NO while the value of timeControlStatus is AVPlayerTimeControlStatusWaitingToPlayAtSpecifiedRate with a reasonForWaitingToPlay of AVPlayerWaitingToMinimizeStallsReason will cause the player to attempt playback at the specified rate immediately.

For clients linked against iOS 10.0 and running on that version or later or linked against macOS 10.12 and running on that version or later, the default value of this property is YES. In versions of iOS prior to iOS 10.0 and versions of macOS prior to 10.12, this property is unavailable, and the behavior of the AVPlayer corresponds to the type of content being played. For streaming content, including HTTP Live Streaming, the AVPlayer acts as if automaticallyWaitsToMinimizeStalling is YES. For file-based content, including file-based content accessed via progressive http download, the AVPlayer acts as if automaticallyWaitsToMinimizeStalling is NO.

If you employ an AVAssetResourceLoader delegate that loads media data for playback, you should set the value of your AVPlayer’s automaticallyWaitsToMinimizeStalling property to NO. Allowing the value of automaticallyWaitsToMinimizeStalling to remain YES when an AVAssetResourceLoader delegate is used for the loading of media data can result in poor start-up times for playback and poor recovery from stalls, because the behaviors provided by AVPlayer when automaticallyWaitsToMinimizeStalling has a value of YES depend on predictions of the future availability of media data that that do not function as expected when data is loaded via a client-controlled means, using the AVAssetResourceLoader delegate interface.

You can allow the value of automaticallyWaitsToMinimizeStalling to remain YES if you use an AVAssetResourceLoader delegate to manage content keys for FairPlay Streaming, to provide dynamically-generated master playlists for HTTP Live Streaming, or to respond to authentication challenges, but not to load media data for playback.

Before macOS 13, iOS 16, tvOS 16, and watchOS 9, this property must be accessed on the main thread/queue.

pub unsafe fn setAutomaticallyWaitsToMinimizeStalling( &self, automatically_waits_to_minimize_stalling: bool, )

Setter for automaticallyWaitsToMinimizeStalling.

pub unsafe fn setRate_time_atHostTime( &self, rate: c_float, item_time: CMTime, host_clock_time: CMTime, )

Available on crate feature objc2-core-media only.

Simultaneously sets the playback rate and the relationship between the current item’s current time and host time.

You can use this function to synchronize playback with an external activity.

The current item’s timebase is adjusted so that its time will be (or was) itemTime when host time is (or was) hostClockTime. In other words: if hostClockTime is in the past, the timebase’s time will be interpolated as though the timebase has been running at the requested rate since that time. If hostClockTime is in the future, the timebase will immediately start running at the requested rate from an earlier time so that it will reach the requested itemTime at the requested hostClockTime. (Note that the item’s time will not jump backwards, but instead will sit at itemTime until the timebase reaches that time.)

Note that setRate:time:atHostTime: is not supported when automaticallyWaitsToMinimizeStalling is YES. For clients linked against iOS 10.0 and later or macOS 12.0 and later, invoking setRate:time:atHostTime: when automaticallyWaitsToMinimizeStalling is YES will raise an NSInvalidArgument exception. Support for HTTP Live Streaming content requires iOS 11, tvOS 11, macOS 10.13 or later.

Before macOS 13, iOS 16, tvOS 16, and watchOS 9, this method must be invoked on the main thread/queue.

• Parameter itemTime: The time to start playback from, specified precisely (i.e., with zero tolerance). Pass kCMTimeInvalid to use the current item’s current time.
• Parameter hostClockTime: The host time at which to start playback. If hostClockTime is specified, the player will not ensure that media data is loaded before the timebase starts moving. If hostClockTime is kCMTimeInvalid, the rate and time will be set together, but without external synchronization; a host time in the near future will be used, allowing some time for media data loading.

pub unsafe fn prerollAtRate_completionHandler( &self, rate: c_float, completion_handler: Option<&DynBlock<dyn Fn(Bool)>>, )

Available on crate feature block2 only.

Begins loading media data to prime the render pipelines for playback from the current time with the given rate.

Once the completion handler is called with YES, the player’s rate can be set with minimal latency. The completion handler will be called with NO if the preroll is interrupted by a time change or incompatible rate change, or if preroll is not possible for some other reason. Call this method only when the rate is currently zero and only after the AVPlayer’s status has become AVPlayerStatusReadyToPlay. This method throws an exception if the status is not AVPlayerStatusReadyToPlay.

• Parameter rate: The intended rate for subsequent playback.
• Parameter completionHandler: The block that will be called when the preroll is either completed or is interrupted.

Safety

completion_handler block must be sendable.

pub unsafe fn cancelPendingPrerolls(&self)

Cancel any pending preroll requests and invoke the corresponding completion handlers if present.

Use this method to cancel and release the completion handlers for pending prerolls. The finished parameter of the completion handlers will be set to NO.

pub unsafe fn sourceClock(&self) -> Option<Retained<CMClock>>

Available on crate feature objc2-core-media only.

Set to override the automatic choice of source clock for item timebases.

NULL by default. This is most useful for synchronizing video-only movies with audio played via other means. IMPORTANT NOTE: If you specify a source clock other than the appropriate audio device clock, audio may drift out of sync.

pub unsafe fn setSourceClock(&self, source_clock: Option<&CMClock>)

Available on crate feature objc2-core-media only.

Setter for sourceClock.

impl AVPlayer

AVPlayerTimeObservation.

pub unsafe fn addPeriodicTimeObserverForInterval_queue_usingBlock( &self, interval: CMTime, queue: Option<&DispatchQueue>, block: &DynBlock<dyn Fn(CMTime)>, ) -> Retained<AnyObject>

Available on crate features block2 and dispatch2 and objc2-core-media only.

Requests invocation of a block during playback to report changing time.

The block is invoked periodically at the interval specified, interpreted according to the timeline of the current item. The block is also invoked whenever time jumps and whenever playback starts or stops. If the interval corresponds to a very short interval in real time, the player may invoke the block less frequently than requested. Even so, the player will invoke the block sufficiently often for the client to update indications of the current time appropriately in its end-user interface. Each call to -addPeriodicTimeObserverForInterval:queue:usingBlock: should be paired with a corresponding call to -removeTimeObserver:. Releasing the observer object without a call to -removeTimeObserver: will result in undefined behavior.

• Parameter interval: The interval of invocation of the block during normal playback, according to progress of the current time of the player.

• Parameter queue: The serial queue onto which block should be enqueued. If you pass NULL, the main queue (obtained using dispatch_get_main_queue()) will be used. Passing a concurrent queue to this method will result in undefined behavior.

• Parameter block: The block to be invoked periodically.

• Returns: An object conforming to the NSObject protocol. You must retain this returned value as long as you want the time observer to be invoked by the player. Pass this object to -removeTimeObserver: to cancel time observation.

Safety

• queue possibly has additional threading requirements.
• block block must be sendable.

pub unsafe fn addBoundaryTimeObserverForTimes_queue_usingBlock( &self, times: &NSArray<NSValue>, queue: Option<&DispatchQueue>, block: &DynBlock<dyn Fn()>, ) -> Retained<AnyObject>

Available on crate features block2 and dispatch2 only.

Requests invocation of a block when specified times are traversed during normal playback.

Each call to -addPeriodicTimeObserverForInterval:queue:usingBlock: should be paired with a corresponding call to -removeTimeObserver:. Releasing the observer object without a call to -removeTimeObserver: will result in undefined behavior.

• Parameter times: The times for which the observer requests notification, supplied as an array of NSValues carrying CMTimes.

• Parameter queue: The serial queue onto which block should be enqueued. If you pass NULL, the main queue (obtained using dispatch_get_main_queue()) will be used. Passing a concurrent queue to this method will result in undefined behavior.

• Parameter block: The block to be invoked when any of the specified times is crossed during normal playback.

• Returns: An object conforming to the NSObject protocol. You must retain this returned value as long as you want the time observer to be invoked by the player. Pass this object to -removeTimeObserver: to cancel time observation.

Safety

• queue possibly has additional threading requirements.
• block block must be sendable.

pub unsafe fn removeTimeObserver(&self, observer: &AnyObject)

Cancels a previously registered time observer.

Upon return, the caller is guaranteed that no new time observer blocks will begin executing. Depending on the calling thread and the queue used to add the time observer, an in-flight block may continue to execute after this method returns. You can guarantee synchronous time observer removal by enqueuing the call to -removeTimeObserver: on that queue. Alternatively, call dispatch_sync(queue, ^{}) after -removeTimeObserver: to wait for any in-flight blocks to finish executing. -removeTimeObserver: should be used to explicitly cancel each time observer added using -addPeriodicTimeObserverForInterval:queue:usingBlock: and -addBoundaryTimeObserverForTimes:queue:usingBlock:.

This method throws an exception for any of the following reasons:

• observer was added by a different instance of AVPlayer

• observer was not returned by -addPeriodicTimeObserverForInterval:queue:usingBlock:

• observer was not returned by -addBoundaryTimeObserverForTimes:queue:usingBlock:

• Parameter observer: An object returned by a previous call to -addPeriodicTimeObserverForInterval:queue:usingBlock: or -addBoundaryTimeObserverForTimes:queue:usingBlock:.

Safety

observer should be of the correct type.

impl AVPlayer

AVPlayerMediaControl.

pub unsafe fn volume(&self) -> c_float

Indicates the current audio volume of the player; 0.0 means “silence all audio”, 1.0 means “play at the full volume of the current item”.

iOS note: Do not use this property to implement a volume slider for media playback. For that purpose, use MPVolumeView, which is customizable in appearance and provides standard media playback behaviors that users expect. This property is most useful on iOS to control the volume of the AVPlayer relative to other audio output, not for volume control by end users.

pub unsafe fn setVolume(&self, volume: c_float)

Setter for volume.

pub unsafe fn isMuted(&self) -> bool

Indicates whether or not audio output of the player is muted. Only affects audio muting for the player instance and not for the device.

pub unsafe fn setMuted(&self, muted: bool)

Setter for isMuted.

impl AVPlayer

AVPlayerAutomaticMediaSelection.

pub unsafe fn appliesMediaSelectionCriteriaAutomatically(&self) -> bool

Indicates whether the receiver should apply the current selection criteria automatically to AVPlayerItems.

For clients linked against the iOS 7 SDK or later or against the macOS 10.9 SDK or later, the default is YES. For all others, the default is NO.

By default, AVPlayer applies selection criteria based on system preferences. To override the default criteria for any media selection group, use -[AVPlayer setMediaSelectionCriteria:forMediaCharacteristic:].

pub unsafe fn setAppliesMediaSelectionCriteriaAutomatically( &self, applies_media_selection_criteria_automatically: bool, )

Setter for appliesMediaSelectionCriteriaAutomatically.

pub unsafe fn setMediaSelectionCriteria_forMediaCharacteristic( &self, criteria: Option<&AVPlayerMediaSelectionCriteria>, media_characteristic: &AVMediaCharacteristic, )

Available on crate features AVMediaFormat and AVPlayerMediaSelectionCriteria only.

Applies automatic selection criteria for media that has the specified media characteristic.

Criteria will be applied to an AVPlayerItem when: a) It is made ready to play b) Specific media selections are made by -[AVPlayerItem selectMediaOption:inMediaSelectionGroup:] in a different group. The automatic choice in one group may be influenced by a specific selection in another group. c) Underlying system preferences change, e.g. system language, accessibility captions.

Specific selections made by -[AVPlayerItem selectMediaOption:inMediaSelectionGroup:] within any group will override automatic selection in that group until -[AVPlayerItem selectMediaOptionAutomaticallyInMediaSelectionGroup:] is received.

Before macOS 13, iOS 16, tvOS 16, and watchOS 9, this method must be invoked on the main thread/queue.

• Parameter criteria: An instance of AVPlayerMediaSelectionCriteria.
• Parameter mediaCharacteristic: The media characteristic for which the selection criteria are to be applied. Supported values include AVMediaCharacteristicAudible, AVMediaCharacteristicLegible, and AVMediaCharacteristicVisual.

pub unsafe fn mediaSelectionCriteriaForMediaCharacteristic( &self, media_characteristic: &AVMediaCharacteristic, ) -> Option<Retained<AVPlayerMediaSelectionCriteria>>

Available on crate features AVMediaFormat and AVPlayerMediaSelectionCriteria only.

Returns the automatic selection criteria for media that has the specified media characteristic.

• Parameter mediaCharacteristic: The media characteristic for which the selection criteria is to be returned. Supported values include AVMediaCharacteristicAudible, AVMediaCharacteristicLegible, and AVMediaCharacteristicVisual. Before macOS 13, iOS 16, tvOS 16, and watchOS 9, this method must be invoked on the main thread/queue.

impl AVPlayer

AVPlayerAudioDeviceSupport.

pub unsafe fn audioOutputDeviceUniqueID(&self) -> Option<Retained<NSString>>

Specifies the unique ID of the Core Audio output device used to play audio.

By default, the value of this property is nil, indicating that the default audio output device is used. Otherwise the value of this property is an NSString containing the unique ID of the Core Audio output device to be used for audio output.

Core Audio’s kAudioDevicePropertyDeviceUID is a suitable source of audio output device unique IDs.

pub unsafe fn setAudioOutputDeviceUniqueID( &self, audio_output_device_unique_id: Option<&NSString>, )

Setter for audioOutputDeviceUniqueID.

This is copied when set.

impl AVPlayer

AVPlayerExternalPlaybackSupport.

Methods for supporting “external playback” of video

“External playback” is a mode where video data is sent to an external device for full screen playback at its original fidelity. AirPlay Video playback is considered as an “external playback” mode.

In “external screen” mode (also known as mirroring and second display), video data is rendered on the host device (e.g. Mac and iPhone), rendered video is recompressed and transferred to the external device, and the external device decompresses and displays the video.

AVPlayerExternalPlaybackSupport properties affect AirPlay Video playback and are the replacement for the deprecated AVPlayerAirPlaySupport properties.

Additional note for iOS: AVPlayerExternalPlaybackSupport properties apply to the Lightning-based video adapters but do not apply to 30-pin-connector-based video output cables and adapters.

pub unsafe fn allowsExternalPlayback(&self) -> bool

Indicates whether the player allows switching to “external playback” mode. The default value is YES.

pub unsafe fn setAllowsExternalPlayback(&self, allows_external_playback: bool)

Setter for allowsExternalPlayback.

pub unsafe fn isExternalPlaybackActive(&self) -> bool

Indicates whether the player is currently playing video in “external playback” mode.

pub unsafe fn usesExternalPlaybackWhileExternalScreenIsActive(&self) -> bool

Indicates whether the player should automatically switch to “external playback” mode while the “external screen” mode is active in order to play video content and switching back to “external screen” mode as soon as playback is done. Brief transition may be visible on the external display when automatically switching between the two modes. The default value is NO. Has no effect if allowsExternalPlayback is NO.

pub unsafe fn setUsesExternalPlaybackWhileExternalScreenIsActive( &self, uses_external_playback_while_external_screen_is_active: bool, )

Setter for usesExternalPlaybackWhileExternalScreenIsActive.

pub unsafe fn externalPlaybackVideoGravity( &self, ) -> Retained<AVLayerVideoGravity>

Available on crate feature AVAnimation only.

Video gravity strictly for “external playback” mode, one of AVLayerVideoGravity* defined in AVAnimation.h

pub unsafe fn setExternalPlaybackVideoGravity( &self, external_playback_video_gravity: &AVLayerVideoGravity, )

Available on crate feature AVAnimation only.

Setter for externalPlaybackVideoGravity.

This is copied when set.

impl AVPlayer

AVPlayerProtectedContent.

Methods supporting protected content.

pub unsafe fn outputObscuredDueToInsufficientExternalProtection(&self) -> bool

Whether or not decoded output is being obscured due to insufficient external protection.

The value of this property indicates whether the player is purposefully obscuring the visual output of the current item because the requirement for an external protection mechanism is not met by the current device configuration. It is highly recommended that clients whose content requires external protection observe this property and set the playback rate to zero and display an appropriate user interface when the value changes to YES. This property is key value observable.

Note that the value of this property is dependent on the external protection requirements of the current item. These requirements are inherent to the content itself and cannot be externally specified. If the current item does not require external protection, the value of this property will be NO.

impl AVPlayer

AVPlayerPlaybackCapabilities.

pub unsafe fn availableHDRModes(mtm: MainThreadMarker) -> AVPlayerHDRMode

👎Deprecated: Use eligibleForHDRPlayback instead

An AVPlayerHDRMode value that indicates the HDR modes the device can play to an appropriate display. A value of 0 indicates that no HDR modes are supported.

This property indicates all of the HDR modes that the device can play. Each value indicates that an appropriate HDR display is available for the specified HDR mode. Additionally, the device must be capable of playing the specified HDR type. This property does not indicate whether video contains HDR content, whether HDR video is currently playing, or whether video is playing on an HDR display.

pub unsafe fn eligibleForHDRPlayback(mtm: MainThreadMarker) -> bool

Indicates whether HDR content can be played to an appropriate display.

This property is YES if an HDR display is available and the device is capable of playing HDR content from an appropriate AVAsset, NO otherwise. This property does not indicate whether video contains HDR content, whether HDR video is currently playing, or whether video is playing on an HDR display. This property is not KVO observable.

impl AVPlayer

AVPlayerVideoDecoderGPUSupport.

pub unsafe fn preferredVideoDecoderGPURegistryID(&self) -> u64

Specifies a registryID associated with a GPU that should be used for video decode.

By default, whenever possible, video decode will be performed on the GPU associated with the display on which the presenting CALayer is located. Decode will be transitioned to a new GPU if appropriate when the CALayer moves to a new display. This property overrides this default behavior, forcing decode to prefer an affinity to the GPU specified regardless of which GPU is being used to display the associated CALayer.

The GPU registryID can be obtained from the GPU MTLDevice using [MTLDevice registryID] or can be obtained from OpenGL or OpenCL.

pub unsafe fn setPreferredVideoDecoderGPURegistryID( &self, preferred_video_decoder_gpu_registry_id: u64, )

Setter for preferredVideoDecoderGPURegistryID.

impl AVPlayer

AVPlayerVideoDisplaySleepPrevention.

pub unsafe fn preventsDisplaySleepDuringVideoPlayback(&self) -> bool

Indicates whether video playback prevents display and device sleep.

Default is YES on iOS, tvOS and in Mac Catalyst apps. Default is NO on macOS. Setting this property to NO does not force the display to sleep, it simply stops preventing display sleep. Other apps or frameworks within your app may still be preventing display sleep for various reasons.

Before macOS 13, iOS 16, tvOS 16, and watchOS 9, this property must be accessed on the main thread/queue.

pub unsafe fn setPreventsDisplaySleepDuringVideoPlayback( &self, prevents_display_sleep_during_video_playback: bool, )

Setter for preventsDisplaySleepDuringVideoPlayback.

impl AVPlayer

AVPlayerAutomaticBackgroundPrevention.

pub unsafe fn preventsAutomaticBackgroundingDuringVideoPlayback(&self) -> bool

Indicates whether video playback prevents the app from automatically getting backgrounded.

Default value is YES. Setting this property to YES prevents an application that is playing video from automatically getting backgrounded. This property does not prevent the user from backgrounding the application.

pub unsafe fn setPreventsAutomaticBackgroundingDuringVideoPlayback( &self, prevents_automatic_backgrounding_during_video_playback: bool, )

Setter for preventsAutomaticBackgroundingDuringVideoPlayback.

impl AVPlayer

AVPlayerBackgroundSupport.

pub unsafe fn audiovisualBackgroundPlaybackPolicy( &self, ) -> AVPlayerAudiovisualBackgroundPlaybackPolicy

Controls the policy to be used in deciding how playback of audiovisual content should continue while the application transitions to background.

By default, the system is free to decide the background playback policy (AVPlayerAudiovisualBackgroundPlaybackPolicyAutomatic). If set to AVPlayerAudiovisualBackgroundPlaybackPolicyPauses, player will be paused on entering background. If set to AVPlayerAudiovisualBackgroundPlaybackPolicyContinuesIfPossible, the system makes the best effort to continue playback but the app also needs appropriate UIBackgroundModes for the system to let it continue running in the background. Note that this policy only applies to items with enabled video.

pub unsafe fn setAudiovisualBackgroundPlaybackPolicy( &self, audiovisual_background_playback_policy: AVPlayerAudiovisualBackgroundPlaybackPolicy, )

Setter for audiovisualBackgroundPlaybackPolicy.

impl AVPlayer

PlaybackCoordination.

pub unsafe fn playbackCoordinator( &self, ) -> Retained<AVPlayerPlaybackCoordinator>

Available on crate feature AVPlaybackCoordinator only.

The playback coordinator for this player.

If the playback coordinator is connected to other participants, rate changes and seeks on the current item will be automatically mirrored to all connected participants. Depending on policies, the coordinator may also intercept rate changes to non-zero to coordinate playback start with the rest of the group. Use [AVPlayer playImmediatelyAtRate:] to override the coordinated startup behavior and start playback immediately. This is useful to give users an opportunity to override waiting caused by other participants’ suspensions. Player configuration other than rate and seeks are not communicated to other participants and can be configured independently by each participant. A player with a connected playbackCoordinator will change behavior in situations that require the player to pause for internal reasons, such as a route change or a stall. When resuming after these events, the player will not resume at the stop time. Instead, it will attempt to rejoin the group, potentially seeking to match the other participant’s progress. It is left to the owner of the AVPlayer to ensure that all participants are playing the same item. See the discussion of AVPlaybackCoordinator for considerations about item transitions.

impl AVPlayer

AVPlayerOutputSupport.

pub unsafe fn videoOutput(&self) -> Option<Retained<AVPlayerVideoOutput>>

Available on crate feature AVPlayerOutput only.

The video output for this player, if one was set.

When an AVPlayerVideoOutput is associated with an AVPlayer, the AVPlayerVideoOutput can then be used to receive video-related samples during playback.

• NOTE: If an output is set while AVPlayer has a current item it may cause different data channels to be selected for that item, which can have a performance impact. As a result, when possible, it is best to set an output before setting items on an AVPlayer.

pub unsafe fn setVideoOutput(&self, video_output: Option<&AVPlayerVideoOutput>)

Available on crate feature AVPlayerOutput only.

Setter for videoOutput.

impl AVPlayer

AVPlayerResourceArbitrationSupport.

pub unsafe fn networkResourcePriority(&self) -> AVPlayerNetworkResourcePriority

Indicates the priority of this player for network bandwidth resource distribution.

This value determines the priority of the player during network resource allocation among all other players within the same application process. The default value for this is AVPlayerNetworkResourcePriorityDefault.

pub unsafe fn setNetworkResourcePriority( &self, network_resource_priority: AVPlayerNetworkResourcePriority, )

Setter for networkResourcePriority.

impl AVPlayer

This impl block contains no items.

AVPlayerSpatialAudioExperience.

impl AVPlayer

AVPlayerRoutingPlaybackArbitrationSupport.

pub unsafe fn audioOutputSuppressedDueToNonMixableAudioRoute(&self) -> bool

Whether the player’s audio output is suppressed due to being on a non-mixable audio route.

If YES, the player’s audio output is suppressed. The player is muted while on a non-mixable audio route and cannot play audio. The player’s mute property does not reflect the true mute status. If NO, the player’s audio output is not suppressed. The player may be muted or unmuted while on a non-mixable audio route and can play audio. The player’s mute property reflects the true mute status. In a non-mixable audio route, only one player can play audio. To play audio in non-mixable states, the player must be specified as the priority participant in AVRoutingPlaybackArbiter.preferredParticipantForNonMixableAudioRoutes. If this player becomes the preferred player, it will gain audio priority and suppress the audio of all other players. If another participant becomes the preferred participant, this player will lose audio priority and have their audio suppressed. This property is key-value observed.

impl AVPlayer

AVPlayerObservation.

pub unsafe fn isObservationEnabled(mtm: MainThreadMarker) -> bool

AVPlayer and other AVFoundation types can optionally be observed using Swift Observation.

When set to YES, new instances of AVPlayer, AVQueuePlayer, AVPlayerItem, and AVPlayerItemTrack are observable with Swift Observation. The default value is NO (not observable). An exception is thrown if this property is set YES after initializing any objects of these types, or if it is set to NO after any observable objects are initialized. In other words, all objects of these types must either be observable or not observable in an application instance.

For more information regarding management of class objects in SwiftUI, please refer to https://developer.apple.com/documentation/swiftui/state.

pub unsafe fn setObservationEnabled( observation_enabled: bool, mtm: MainThreadMarker, )

Setter for isObservationEnabled.

impl AVPlayer

AVPlayerDeprecated.

pub unsafe fn isClosedCaptionDisplayEnabled(&self) -> bool

👎Deprecated: Allow AVPlayer to enable closed captions automatically according to user preferences by ensuring that the value of appliesMediaSelectionCriteriaAutomatically is YES.

Indicates whether display of closed captions is enabled.

This property is deprecated.

When the value of appliesMediaSelectionCriteriaAutomatically is YES, the receiver will enable closed captions automatically either according to user preferences or, if you provide them, according to AVPlayerMediaSelectionCriteria for the media characteristic AVMediaCharacteristicLegible.

If you want to determine whether closed captions may be available for a given AVPlayerItem, you can examine the AVMediaSelectionOptions in the AVMediaSelectionGroup for the characteristic AVMediaCharacteristicLegible, as vended by -[AVAsset mediaSelectionGroupForMediaCharacteristic:]. See AVMediaCharacteristicTranscribesSpokenDialogForAccessibility and AVMediaCharacteristicDescribesMusicAndSoundForAccessibility as documented in AVMediaFormat.h for information about how to identify legible media selection options that offer the features of closed captions for accessibility purposes.

You can select or deselect a specific AVMediaSelectionOption via -[AVPlayerItem selectMediaOption:inMediaSelectionGroup:].

For further information about Media Accessibility preferences, see MediaAccessibility framework documentation.

pub unsafe fn setClosedCaptionDisplayEnabled( &self, closed_caption_display_enabled: bool, )

👎Deprecated: Allow AVPlayer to enable closed captions automatically according to user preferences by ensuring that the value of appliesMediaSelectionCriteriaAutomatically is YES.

Setter for isClosedCaptionDisplayEnabled.

pub unsafe fn masterClock(&self) -> Option<Retained<CMClock>>

👎Deprecated

Available on crate feature objc2-core-media only.

Use sourceClock instead.

pub unsafe fn setMasterClock(&self, master_clock: Option<&CMClock>)

👎Deprecated

Available on crate feature objc2-core-media only.

Setter for masterClock.

impl AVPlayer

This impl block contains no items.

AVPlayerInterstitialSupport.

Methods from Deref<Target = NSObject>

pub fn doesNotRecognizeSelector(&self, sel: Sel) -> !

Handle messages the object doesn’t recognize.

See Apple’s documentation for details.

Methods from Deref<Target = AnyObject>

pub fn class(&self) -> &'static AnyClass

Dynamically find the class of this object.

Panics

May panic if the object is invalid (which may be the case for objects returned from unavailable init/new methods).

Example

Check that an instance of NSObject has the precise class NSObject.

use objc2::ClassType;
use objc2::runtime::NSObject;

let obj = NSObject::new();
assert_eq!(obj.class(), NSObject::class());

pub unsafe fn get_ivar<T>(&self, name: &str) -> &T

where T: Encode,

👎Deprecated: this is difficult to use correctly, use Ivar::load instead.

Use Ivar::load instead.

Safety

The object must have an instance variable with the given name, and it must be of type T.

See Ivar::load_ptr for details surrounding this.

pub fn downcast_ref<T>(&self) -> Option<&T>

where T: DowncastTarget,

Attempt to downcast the object to a class of type T.

This is the reference-variant. Use Retained::downcast if you want to convert a retained object to another type.

Mutable classes

Some classes have immutable and mutable variants, such as NSString and NSMutableString.

When some Objective-C API signature says it gives you an immutable class, it generally expects you to not mutate that, even though it may technically be mutable “under the hood”.

So using this method to convert a NSString to a NSMutableString, while not unsound, is generally frowned upon unless you created the string yourself, or the API explicitly documents the string to be mutable.

See Apple’s documentation on mutability and on isKindOfClass: for more details.

Generic classes

Objective-C generics are called “lightweight generics”, and that’s because they aren’t exposed in the runtime. This makes it impossible to safely downcast to generic collections, so this is disallowed by this method.

You can, however, safely downcast to generic collections where all the type-parameters are AnyObject.

Panics

This works internally by calling isKindOfClass:. That means that the object must have the instance method of that name, and an exception will be thrown (if CoreFoundation is linked) or the process will abort if that is not the case. In the vast majority of cases, you don’t need to worry about this, since both root objects NSObject and NSProxy implement this method.

Examples

Cast an NSString back and forth from NSObject.

use objc2::rc::Retained;
use objc2_foundation::{NSObject, NSString};

let obj: Retained<NSObject> = NSString::new().into_super();
let string = obj.downcast_ref::<NSString>().unwrap();
// Or with `downcast`, if we do not need the object afterwards
let string = obj.downcast::<NSString>().unwrap();

Try (and fail) to cast an NSObject to an NSString.

use objc2_foundation::{NSObject, NSString};

let obj = NSObject::new();
assert!(obj.downcast_ref::<NSString>().is_none());

Try to cast to an array of strings.

use objc2_foundation::{NSArray, NSObject, NSString};

let arr = NSArray::from_retained_slice(&[NSObject::new()]);
// This is invalid and doesn't type check.
let arr = arr.downcast_ref::<NSArray<NSString>>();

This fails to compile, since it would require enumerating over the array to ensure that each element is of the desired type, which is a performance pitfall.

Downcast when processing each element instead.

use objc2_foundation::{NSArray, NSObject, NSString};

let arr = NSArray::from_retained_slice(&[NSObject::new()]);

for elem in arr {
    if let Some(data) = elem.downcast_ref::<NSString>() {
        // handle `data`
    }
}

Trait Implementations

impl AsRef<AVPlayer> for AVPlayer

fn as_ref(&self) -> &Self

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<AVPlayer> for AVQueuePlayer

fn as_ref(&self) -> &AVPlayer

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<AnyObject> for AVPlayer

fn as_ref(&self) -> &AnyObject

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<NSObject> for AVPlayer

fn as_ref(&self) -> &NSObject

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<AVPlayer> for AVQueuePlayer

fn borrow(&self) -> &AVPlayer

Immutably borrows from an owned value.

impl Borrow<AnyObject> for AVPlayer

fn borrow(&self) -> &AnyObject

Immutably borrows from an owned value.

impl Borrow<NSObject> for AVPlayer

fn borrow(&self) -> &NSObject

Immutably borrows from an owned value.

impl ClassType for AVPlayer

const NAME: &'static str = "AVPlayer"

The name of the Objective-C class that this type represents.

type Super = NSObject

The superclass of this class.

type ThreadKind = dyn MainThreadOnly

Whether the type can be used from any thread, or from only the main thread.

fn class() -> &'static AnyClass

Get a reference to the Objective-C class that this type represents.

fn as_super(&self) -> &Self::Super

Get an immutable reference to the superclass.

impl Debug for AVPlayer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for AVPlayer

type Target = NSObject

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Hash for AVPlayer

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Message for AVPlayer

fn retain(&self) -> Retained<Self>

where Self: Sized,

Increment the reference count of the receiver.

impl NSObjectProtocol for AVPlayer

fn isEqual(&self, other: Option<&AnyObject>) -> bool

where Self: Sized + Message,

Check whether the object is equal to an arbitrary other object.

fn hash(&self) -> usize

where Self: Sized + Message,

An integer that can be used as a table address in a hash table structure.

fn isKindOfClass(&self, cls: &AnyClass) -> bool

where Self: Sized + Message,

Check if the object is an instance of the class, or one of its subclasses.

fn is_kind_of<T>(&self) -> bool

where T: ClassType, Self: Sized + Message,

👎Deprecated: use isKindOfClass directly, or cast your objects with AnyObject::downcast_ref

Check if the object is an instance of the class type, or one of its subclasses.

fn isMemberOfClass(&self, cls: &AnyClass) -> bool

where Self: Sized + Message,

Check if the object is an instance of a specific class, without checking subclasses.

fn respondsToSelector(&self, aSelector: Sel) -> bool

where Self: Sized + Message,

Check whether the object implements or inherits a method with the given selector.

fn conformsToProtocol(&self, aProtocol: &AnyProtocol) -> bool

where Self: Sized + Message,

Check whether the object conforms to a given protocol.

fn description(&self) -> Retained<NSObject>

where Self: Sized + Message,

A textual representation of the object.

fn debugDescription(&self) -> Retained<NSObject>

where Self: Sized + Message,

A textual representation of the object to use when debugging.

fn isProxy(&self) -> bool

where Self: Sized + Message,

Check whether the receiver is a subclass of the NSProxy root class instead of the usual NSObject.

fn retainCount(&self) -> usize

where Self: Sized + Message,

The reference count of the object.

impl PartialEq for AVPlayer

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl RefEncode for AVPlayer

const ENCODING_REF: Encoding = <NSObject as ::objc2::RefEncode>::ENCODING_REF

The Objective-C type-encoding for a reference of this type.

impl DowncastTarget for AVPlayer

impl Eq for AVPlayer