Added method:
public virtual void WilllDownloadToUrl (Foundation.NSUrlSession session, AVAssetDownloadTask assetDownloadTask, Foundation.NSUrl location);Added method:
public static void WilllDownloadToUrl (this IAVAssetDownloadDelegate This, Foundation.NSUrlSession session, AVAssetDownloadTask assetDownloadTask, Foundation.NSUrl location);Added properties:
public static Foundation.NSString AVAssetExportPresetMvHevc1440x1440 { get; }
public static Foundation.NSString AVAssetExportPresetMvHevc960x960 { get; }
public virtual bool AllowsParallelizedExport { get; set; }
public virtual AVAssetTrackGroupOutputHandling AudioTrackGroupHandling { get; set; }Added properties:
public virtual AVAssetImageGeneratorDynamicRangePolicy DynamicRangePolicy { get; set; }
public Foundation.NSString WeakDynamicRangePolicy { get; set; }Added property:
public virtual bool SendsCommonMediaClientDataAsHttpHeaders { get; set; }Added property:
public virtual bool EntireLengthAvailableOnDemand { get; set; }Added properties:
public virtual bool Binaural { get; }
public virtual bool Downmix { get; }
public virtual bool Immersive { get; }Added methods:
public static Foundation.NSPredicate GetPredicateForAudioSampleRate (double sampleRate, AVMediaSelectionOption mediaSelectionOption, Foundation.NSPredicateOperatorType operatorType);
public static Foundation.NSPredicate GetPredicateForBinauralAudio (bool isBinauralAudio, AVMediaSelectionOption mediaSelectionOption);
public static Foundation.NSPredicate GetPredicateForDownmixAudio (bool isDownmixAudio, AVMediaSelectionOption mediaSelectionOption);
public static Foundation.NSPredicate GetPredicateForImmersiveAudio (bool isImmersiveAudio, AVMediaSelectionOption mediaSelectionOption);Added property:
public virtual AVAssetVariantVideoLayoutAttributes[] VideoLayoutAttributes { get; }Added property:
public virtual CoreMedia.CMTime InitialMovieFragmentInterval { get; set; }Added properties:
public static Foundation.NSString InputMuteStateChangeNotification { get; }
public static Foundation.NSString MuteStateKey { get; }Added property:
public virtual AVAudioVoiceProcessingOtherAudioDuckingConfiguration VoiceProcessingOtherAudioDuckingConfiguration { get; set; }Added method:
public virtual bool SetMutedSpeechActivityEventListener (AVAudioInputNodeMutedSpeechEventListener listenerAction);Obsoleted constructors:
[Obsolete ("Use the 'FromUrl' method instead, because a constructor can't fail.")]
public AVAudioPlayer (Foundation.NSData data, string fileTypeHint, out Foundation.NSError outError);
[Obsolete ("Use the 'FromUrl' method instead, because a constructor can't fail.")]
public AVAudioPlayer (Foundation.NSUrl url, string fileTypeHint, out Foundation.NSError outError);Added methods:
public static AVAudioPlayer FromData (Foundation.NSData data, AVFileTypes fileTypeHint, out Foundation.NSError error);
public static AVAudioPlayer FromData (Foundation.NSData data, Foundation.NSString fileTypeHint, out Foundation.NSError error);
public static AVAudioPlayer FromUrl (Foundation.NSUrl url, AVFileTypes fileTypeHint, out Foundation.NSError error);
public static AVAudioPlayer FromUrl (Foundation.NSUrl url, Foundation.NSString fileTypeHint, out Foundation.NSError error);Added methods:
public virtual AVMusicTrack CreateAndAppendTrack ();
public virtual bool RemoveTrack (AVMusicTrack track);
public virtual void ReverseEvents ();
public virtual void SetUserCallback (AVAudioSequencerUserCallback userCallback);Added value:
LongFormAudio = 1,Added value:
AppleLog = 3,Modified properties:
-public virtual System.Runtime.InteropServices.NFloat VideoRotationAngle { get; set; }
+public virtual System.Runtime.InteropServices.NFloat VideoRotationAngle { get; }Added properties:
public virtual bool AutoVideoFrameRateEnabled { get; set; }
public virtual Foundation.NSSet<Foundation.NSString> AvailableReactionTypes { get; }
public virtual bool BackgroundReplacementActive { get; }
public static bool BackgroundReplacementEnabled { get; }
public virtual bool CanPerformReactionEffects { get; }
public virtual CoreGraphics.CGRect CenterStageRectOfInterest { get; set; }
public virtual AVCaptureDevice CompanionDeskViewCamera { get; }
public virtual bool ContinuityCamera { get; }
public virtual System.Runtime.InteropServices.NFloat DisplayVideoZoomFactorMultiplier { get; }
public static bool ReactionEffectGesturesEnabled { get; }
public static bool ReactionEffectsEnabled { get; }
public virtual AVCaptureReactionEffectState[] ReactionEffectsInProgress { get; }
public virtual Foundation.NSSet<Foundation.NSString> SpatialCaptureDiscomfortReasons { get; }
public virtual bool StudioLightActive { get; }
public static bool StudioLightEnabled { get; }
public static AVCaptureDevice SystemPreferredCamera { get; }
public static AVCaptureDevice UserPreferredCamera { get; set; }Added method:
public virtual void PerformEffect (string reactionType);Added properties:
public virtual bool AutoVideoFrameRateSupported { get; }
public virtual bool BackgroundReplacementSupported { get; }
public virtual bool ReactionEffectsSupported { get; }
public virtual bool SpatialVideoCaptureSupported { get; }
public virtual bool StudioLightSupported { get; }
public virtual AVZoomRange[] SupportedVideoZoomRangesForDepthDataDelivery { get; }
public virtual AVExposureBiasRange SystemRecommendedExposureBiasRange { get; }
public virtual AVZoomRange SystemRecommendedVideoZoomRange { get; }
public virtual AVFrameRateRange VideoFrameRateRangeForBackgroundReplacement { get; }
public virtual AVFrameRateRange VideoFrameRateRangeForReactionEffectsInProgress { get; }
public virtual AVFrameRateRange VideoFrameRateRangeForStudioLight { get; }
public virtual bool ZoomFactorsOutsideOfVideoZoomRangesForDepthDeliverySupported { get; }Added properties:
public virtual AVCaptureMultichannelAudioMode MultichannelAudioMode { get; set; }
public virtual bool WindNoiseRemovalEnabled { get; set; }
public virtual bool WindNoiseRemovalSupported { get; }Added method:
public virtual bool IsMultichannelAudioModeSupported (AVCaptureMultichannelAudioMode multichannelAudioMode);Added values:
ContinuityCamera = 13,
DeskViewCamera = 14,
Microphone = 12,Added properties:
public virtual bool SpatialVideoCaptureEnabled { get; set; }
public virtual bool SpatialVideoCaptureSupported { get; }Added properties:
public virtual float ConstantColorCenterWeightedMeanConfidenceLevel { get; }
public virtual CoreVideo.CVPixelBuffer ConstantColorConfidenceMap { get; }
public virtual bool ConstantColorFallbackPhoto { get; }Added properties:
public virtual AVCapturePhotoOutputCaptureReadiness CaptureReadiness { get; }
public virtual bool ConstantColorEnabled { get; set; }
public virtual bool ConstantColorSupported { get; }
public virtual bool FastCapturePrioritizationEnabled { get; set; }
public virtual bool FastCapturePrioritizationSupported { get; set; }
public virtual AVCapturePhotoQualityPrioritization MaxPhotoQualityPrioritization { get; set; }
public virtual bool ResponsiveCaptureEnabled { get; set; }
public virtual bool ResponsiveCaptureSupported { get; }
public virtual bool ShutterSoundSuppressionSupported { get; }
public virtual AVCaptureFlashMode[] SupportedFlashModes { get; }
public virtual bool ZeroShutterLagEnabled { get; set; }
public virtual bool ZeroShutterLagSupported { get; }Added properties:
public virtual bool ConstantColorEnabled { get; set; }
public virtual bool ConstantColorFallbackPhotoDeliveryEnabled { get; set; }
public virtual AVCapturePhotoQualityPrioritization PhotoQualityPrioritization { get; set; }
public virtual bool ShutterSoundSuppressionEnabled { get; set; }Added property:
public virtual bool FastCapturePrioritizationEnabled { get; }Added properties:
public virtual AVCaptureControl[] Controls { get; }
public IAVCaptureSessionControlsDelegate ControlsDelegate { get; }
public virtual CoreFoundation.DispatchQueue ControlsDelegateCallbackQueue { get; }
public virtual IntPtr MaxControlsCount { get; }
public virtual bool SupportsControls { get; }
public virtual Foundation.NSObject WeakControlsDelegate { get; }Added methods:
public virtual void AddControl (AVCaptureControl control);
public virtual bool CanAddControl (AVCaptureControl control);
public virtual void RemoveControl (AVCaptureControl control);
public virtual void SetControlsDelegate (IAVCaptureSessionControlsDelegate controlsDelegate, CoreFoundation.DispatchQueue controlsDelegateCallbackQueue);Added methods:
public AVPlayerItemVideoOutputSettings GetRecommendedVideoSettings (AVVideoCodecType videoCodecType, AVFileTypes outputFileType, Foundation.NSUrl outputFileUrl);
public virtual Foundation.NSDictionary GetRecommendedVideoSettings (string videoCodecType, string outputFileType, Foundation.NSUrl outputFileUrl);Added methods:
public virtual AVTimedMetadataGroup[] GetChapterMetadataGroups (string[] bestMatchingPreferredLanguages);
public virtual AVTimedMetadataGroup[] GetChapterMetadataGroups (Foundation.NSLocale titleLocale, string[] commonKeys);
public virtual AVMediaSelectionGroup GetMediaSelectionGroup (string mediaCharacteristic);
public virtual AVMetadataItem[] GetMetadata (string format);
public virtual int GetUnusedTrackId ();Added methods:
public virtual AVAssetTrack[] GetAssociatedTracks (string trackAssociationType);
public virtual AVMetadataItem[] GetMetadata (string format);
public virtual CoreMedia.CMTime GetSamplePresentationTime (CoreMedia.CMTime trackTime);
public virtual bool HasMediaCharacteristic (string mediaCharacteristic);Added property:
public virtual AVExternalContentProtectionStatus ExternalContentProtectionStatus { get; }Added method:
public virtual void Revoke ();Added methods:
public virtual void DidProvideContentKeyRequests (AVContentKeySession session, AVContentKeyRequest[] keyRequests, Foundation.NSData initializationData);
public virtual void ExternalProtectionStatusDidChange (AVContentKeySession session, AVContentKey contentKey);Added methods:
public static void DidProvideContentKeyRequests (this IAVContentKeySessionDelegate This, AVContentKeySession session, AVContentKeyRequest[] keyRequests, Foundation.NSData initializationData);
public static void ExternalProtectionStatusDidChange (this IAVContentKeySessionDelegate This, AVContentKeySession session, AVContentKey contentKey);Added values:
AirPlayReceiverTemporarilyUnavailable = -11882,
EncodeFailed = -11883,
FailedToLoadSampleData = -11881,
InvalidSampleCursor = -11880,
MediaExtensionConflict = -11887,
MediaExtensionDisabled = -11886,
SandboxExtensionDenied = -11884,
ToneMappingFailed = -11885,Added value:
Ahap = 23,Added values:
CarriesVideoStereoMetadata = 18,
ContainsStereoMultiviewVideo = 19,
EnhancesSpeechIntelligibility = 20,
IndicatesHorizontalFieldOfView = 21,
TactileMinimal = 22,Added values:
AuxiliaryPicture = 11,
Haptic = 12,Added properties:
public static Foundation.NSString QuickTimeMetadataFullFrameRatePlaybackIntent { get; }
public static Foundation.NSString QuickTimeMetadataKeyFullFrameRatePlaybackIntent { get; }Added value:
HumanFullBody = 16777216,Added property:
public virtual bool UsesAutomatedParameters { get; set; }Added methods:
public virtual void AddEvent (AVMusicEvent event, double beat);
public virtual void ClearEvents (AVBeatRange range);
public virtual void CopyAndMergeEvents (AVBeatRange range, AVMusicTrack sourceTrack, double mergeStartBeat);
public virtual void CopyEvents (AVBeatRange range, AVMusicTrack sourceTrack, double insertStartBeat);
public virtual void CutEvents (AVBeatRange range);
public virtual void EnumerateEvents (AVBeatRange range, AVMusicEventEnumerationBlock block);
public virtual void MoveEvents (AVBeatRange range, double beatAmount);Added methods:
public virtual void Insert (CoreMedia.CMTimeRange timeRange, AVAsset asset, CoreMedia.CMTime startTime, AVMutableCompositionInsertHandler completionHandler);
public virtual System.Threading.Tasks.Task InsertAsync (CoreMedia.CMTimeRange timeRange, AVAsset asset, CoreMedia.CMTime startTime);Added methods:
public virtual AVTimedMetadataGroup[] GetChapterMetadataGroups (string[] bestMatchingPreferredLanguages);
public virtual AVTimedMetadataGroup[] GetChapterMetadataGroups (Foundation.NSLocale titleLocale, string[] commonKeys);
public virtual AVMediaSelectionGroup GetMediaSelectionGroup (string mediaCharacteristic);
public virtual AVMetadataItem[] GetMetadata (string format);
public virtual int GetUnusedTrackId ();Added methods:
public virtual AVAssetTrack[] GetAssociatedTracks (string trackAssociationType);
public virtual AVMetadataItem[] GetMetadata (string format);
public virtual CoreMedia.CMTime GetSamplePresentationTime (CoreMedia.CMTime trackTime);
public virtual AVAssetTrackSegment GetSegment (CoreMedia.CMTime trackTime);
public virtual bool HasMediaCharacteristic (string mediaCharacteristic);Added property:
public virtual string PerFrameHdrDisplayMetadataPolicy { get; set; }Added methods:
public static void Create (AVAsset asset, AVMutableVideoCompositionCreateCallback completionHandler);
public static void Create (AVAsset asset, AVMutableVideoCompositionCreateApplier applier, AVMutableVideoCompositionCreateCallback completionHandler);
public static void Create (AVAsset asset, AVVideoCompositionInstruction prototypeInstruction, AVMutableVideoCompositionCreateCallback completionHandler);
public static System.Threading.Tasks.Task<AVMutableVideoComposition> CreateAsync (AVAsset asset);
public static System.Threading.Tasks.Task<AVMutableVideoComposition> CreateAsync (AVAsset asset, AVMutableVideoCompositionCreateApplier applier);
public static System.Threading.Tasks.Task<AVMutableVideoComposition> CreateAsync (AVAsset asset, AVVideoCompositionInstruction prototypeInstruction);Added values:
PresetMvHevc1440x1440 = 17,
PresetMvHevc960x960 = 16,Added properties:
public virtual float DefaultRate { get; set; }
public virtual AVPlayerVideoOutput VideoOutput { get; set; }Added method:
protected override void Dispose (bool disposing);Added interfaces:
Foundation.INSCopying
ObjCRuntime.INativeObject
System.IDisposableModified properties:
-public virtual Foundation.NSDate Date { get; set; }
+public virtual Foundation.NSDate Date { get; }
-public virtual string Identifier { get; set; }
+public virtual string Identifier { get; }
-public virtual CoreMedia.CMTime PlayoutLimit { get; set; }
+public virtual CoreMedia.CMTime PlayoutLimit { get; }
-public virtual AVPlayerItem PrimaryItem { get; set; }
+public virtual AVPlayerItem PrimaryItem { get; }
-public virtual AVPlayerInterstitialEventRestrictions Restrictions { get; set; }
+public virtual AVPlayerInterstitialEventRestrictions Restrictions { get; }
-public virtual CoreMedia.CMTime ResumptionOffset { get; set; }
+public virtual CoreMedia.CMTime ResumptionOffset { get; }
-public virtual AVPlayerItem[] TemplateItems { get; set; }
+public virtual AVPlayerItem[] TemplateItems { get; }
-public virtual CoreMedia.CMTime Time { get; set; }
+public virtual CoreMedia.CMTime Time { get; }
-public virtual Foundation.NSDictionary UserDefinedAttributes { get; set; }
+public virtual Foundation.NSDictionary UserDefinedAttributes { get; }Added properties:
public virtual bool AlignsResumptionWithPrimarySegmentBoundary { get; set; }
public virtual bool AlignsStartWithPrimarySegmentBoundary { get; set; }
public virtual Foundation.NSDictionary AssetListResponse { get; }
public virtual bool ContentMayVary { get; set; }
public virtual string Cue { get; set; }
public virtual CoreMedia.CMTime PlannedDuration { get; set; }
public virtual bool SupplementsPrimaryContent { get; set; }
public virtual AVPlayerInterstitialEventTimelineOccupancy TimelineOccupancy { get; set; }
public virtual bool WillPlayOnce { get; set; }Added methods:
public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
public static AVPlayerInterstitialEvent Create (AVPlayerItem primaryItem, CoreMedia.CMTime time);
public static AVPlayerInterstitialEvent Create (AVPlayerItem primaryItem, Foundation.NSDate date);Added properties:
public static Foundation.NSString AssetListResponseStatusDidChangeErrorKey { get; }
public static Foundation.NSString AssetListResponseStatusDidChangeEventKey { get; }
public static Foundation.NSString AssetListResponseStatusDidChangeNotification { get; }
public static Foundation.NSString AssetListResponseStatusDidChangeStatusKey { get; }Added methods:
public static Foundation.NSObject ObserveAssetListResponseStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveAssetListResponseStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);Added interface:
IAVMetricEventStreamPublisherAdded property:
public virtual AVPlayerItemIntegratedTimeline IntegratedTimeline { get; }Added method:
public virtual CoreVideo.CVPixelBuffer CopyDisplayedPixelBuffer ();Added constructor:
public AVPlayerLooper (AVQueuePlayer player, AVPlayerItem itemToLoop, CoreMedia.CMTimeRange loopRange, AVPlayerLooperItemOrdering itemOrdering);Added properties:
public static Foundation.NSString DisplayLayerReadyForDisplayDidChangeNotification { get; }
public virtual bool ReadyForDisplay { get; }
public virtual AVSampleBufferVideoRenderer SampleBufferRenderer { get; }Added methods:
public static Foundation.NSObject ObserveDisplayLayerReadyForDisplayDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveDisplayLayerReadyForDisplayDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);Added methods:
public virtual CoreMedia.CMSampleBuffer CreateSampleBuffer (AVSampleBufferRequest request, out Foundation.NSError outError);
public virtual CoreMedia.CMSampleBuffer CreateSampleBuffer (AVSampleBufferRequest request, AVSampleBufferGeneratorBatch batch, out Foundation.NSError outError);
public virtual AVSampleBufferGeneratorBatch MakeBatch ();Added properties:
public static Foundation.NSString AvailableVoicesDidChangeNotification { get; }
public virtual AVSpeechSynthesisVoiceTraits VoiceTraits { get; }Added value:
Premium = 3,Added property:
public static AVSpeechSynthesisPersonalVoiceAuthorizationStatus PersonalVoiceAuthorizationStatus { get; }Added event:
public event System.EventHandler<AVSpeechSynthesizerWillSpeakMarkerEventArgs> WillSpeakMarker;Added methods:
public static void RequestPersonalVoiceAuthorization (AVSpeechSynthesizerRequestPersonalVoiceAuthorizationCallback handler);
public static System.Threading.Tasks.Task<AVSpeechSynthesisPersonalVoiceAuthorizationStatus> RequestPersonalVoiceAuthorizationAsync ();
public virtual void WriteUtterance (AVSpeechUtterance utterance, AVSpeechSynthesizerBufferCallback bufferCallback, AVSpeechSynthesizerMarkerCallback markerCallback);Added method:
public virtual void WillSpeakMarker (AVSpeechSynthesizer synthesizer, AVSpeechSynthesisMarker marker, AVSpeechUtterance utterance);Added method:
public static void WillSpeakMarker (this IAVSpeechSynthesizerDelegate This, AVSpeechSynthesizer synthesizer, AVSpeechSynthesisMarker marker, AVSpeechUtterance utterance);Added constructor:
public AVSpeechUtterance (string string, AVSpeechUtteranceInitializationOption option);Added method:
public static AVSpeechUtterance FromSsmlRepresentation (string string);Added properties:
public virtual Foundation.NSUuid HttpSessionIdentifier { get; }
public static Foundation.NSString HttpUserAgentKey { get; }
public virtual AVMediaExtensionProperties MediaExtensionProperties { get; }
public static Foundation.NSString OverrideMimeTypeKey { get; }
public static Foundation.NSString PrimarySessionIdentifierKey { get; }Added property:
public static Foundation.NSString DecompressionPropertiesKey { get; }Added values:
AppleProRes4444XQ = 10,
JpegXl = 11,Added property:
public virtual string PerFrameHdrDisplayMetadataPolicy { get; }Added methods:
public static void Create (AVAsset asset, AVVideoCompositionCreateCallback completionHandler);
public static void Create (AVAsset asset, AVVideoCompositionCreateApplier applier, AVVideoCompositionCreateCallback completionHandler);
public static System.Threading.Tasks.Task<AVVideoComposition> CreateAsync (AVAsset asset);
public static System.Threading.Tasks.Task<AVVideoComposition> CreateAsync (AVAsset asset, AVVideoCompositionCreateApplier applier);
public virtual void DetermineValidity (AVAsset asset, CoreMedia.CMTimeRange timeRange, IAVVideoCompositionValidationHandling validationDelegate, AVVideoCompositionDetermineValidityCallback completionHandler);
public virtual System.Threading.Tasks.Task<System.Tuple<System.Boolean,Foundation.NSError>> DetermineValidityAsync (AVAsset asset, CoreMedia.CMTimeRange timeRange, IAVVideoCompositionValidationHandling validationDelegate);
public virtual bool IsValid (AVAssetTrack[] tracks, CoreMedia.CMTime duration, CoreMedia.CMTimeRange timeRange, IAVVideoCompositionValidationHandling validationDelegate);Obsoleted properties:
[Obsolete ("Use 'Itu_R_709_2' instead.")]
public static Foundation.NSString AVVideoTransferFunction_Itu_R_709_2 { get; }
[Obsolete ("Use 'Smpte_240M_1995' instead.")]
public static Foundation.NSString AVVideoTransferFunction_Smpte_240M_1995 { get; }Added properties:
public static Foundation.NSString Iec_sRgb { get; }
public static Foundation.NSString Itu_R_2100_Hlg { get; }
public static Foundation.NSString Itu_R_709_2 { get; }
public static Foundation.NSString Linear { get; }
public static Foundation.NSString Smpte_240M_1995 { get; }
public static Foundation.NSString Smpte_St_2084_Pq { get; }Added method:
public virtual void WilllDownloadToUrl (Foundation.NSUrlSession session, AVAssetDownloadTask assetDownloadTask, Foundation.NSUrl location);Added methods:
public virtual void DidProvideContentKeyRequests (AVContentKeySession session, AVContentKeyRequest[] keyRequests, Foundation.NSData initializationData);
public virtual void ExternalProtectionStatusDidChange (AVContentKeySession session, AVContentKey contentKey);Added method:
public virtual void WillSpeakMarker (AVSpeechSynthesizer synthesizer, AVSpeechSynthesisMarker marker, AVSpeechUtterance utterance);public class AVAUPresetEvent : AVFoundation.AVMusicEvent {
// constructors
public AVAUPresetEvent ();
protected AVAUPresetEvent (Foundation.NSObjectFlag t);
protected AVAUPresetEvent (ObjCRuntime.NativeHandle handle);
public AVAUPresetEvent (uint scope, uint element, Foundation.NSDictionary presetDictionary);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual uint Element { get; set; }
public virtual Foundation.NSDictionary PresetDictionary { get; }
public virtual uint Scope { get; set; }
}[Serializable]
public enum AVAssetImageGeneratorDynamicRangePolicy {
DynamicRangePolicyForceSdr = 0,
DynamicRangePolicyMatchSource = 1,
}public static class AVAssetImageGeneratorDynamicRangePolicyExtensions {
// methods
public static Foundation.NSString GetConstant (this AVAssetImageGeneratorDynamicRangePolicy self);
public static AVAssetImageGeneratorDynamicRangePolicy GetValue (Foundation.NSString constant);
}public class AVAssetPlaybackAssistant : Foundation.NSObject {
// constructors
protected AVAssetPlaybackAssistant (Foundation.NSObjectFlag t);
protected AVAssetPlaybackAssistant (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
// methods
public static AVAssetPlaybackAssistant Create (AVAsset asset);
public virtual void LoadPlaybackConfigurationOptions (AVAssetPlaybackAssistantLoadPlaybackConfigurationOptionsHandler completionHandler);
public virtual System.Threading.Tasks.Task<System.String[]> LoadPlaybackConfigurationOptionsAsync ();
}public sealed delegate AVAssetPlaybackAssistantLoadPlaybackConfigurationOptionsHandler : System.MulticastDelegate {
// constructors
public AVAssetPlaybackAssistantLoadPlaybackConfigurationOptionsHandler (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (string[] playbackConfigurationOptions, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (string[] playbackConfigurationOptions);
}[Serializable]
public enum AVAssetPlaybackConfigurationOption {
SpatialVideo = 2,
StereoMultiviewVideo = 1,
StereoVideo = 0,
}public static class AVAssetPlaybackConfigurationOptionExtensions {
// methods
public static Foundation.NSString GetConstant (this AVAssetPlaybackConfigurationOption self);
public static AVAssetPlaybackConfigurationOption GetValue (Foundation.NSString constant);
}[Serializable]
[Flags]
public enum AVAssetTrackGroupOutputHandling {
DefaultPolicy = 0,
None = 0,
PreserveAlternateTracks = 1,
}public class AVAssetVariantVideoLayoutAttributes : Foundation.NSObject {
// constructors
protected AVAssetVariantVideoLayoutAttributes (Foundation.NSObjectFlag t);
protected AVAssetVariantVideoLayoutAttributes (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual CoreMedia.CMStereoViewComponents StereoViewComponents { get; }
}public class AVAssetWriterInputTaggedPixelBufferGroupAdaptor : Foundation.NSObject {
// constructors
protected AVAssetWriterInputTaggedPixelBufferGroupAdaptor (Foundation.NSObjectFlag t);
protected AVAssetWriterInputTaggedPixelBufferGroupAdaptor (ObjCRuntime.NativeHandle handle);
public AVAssetWriterInputTaggedPixelBufferGroupAdaptor (AVAssetWriterInput input, Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> sourcePixelBufferAttributes);
// properties
public virtual AVAssetWriterInput AssetWriterInput { get; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual CoreVideo.CVPixelBufferPool PixelBufferPool { get; }
public virtual Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> SourcePixelBufferAttributes { get; }
// methods
public virtual bool Append (CoreMedia.CMTaggedBufferGroup taggedPixelBufferGroup, CoreMedia.CMTime presentationTime);
public static AVAssetWriterInputTaggedPixelBufferGroupAdaptor Create (AVAssetWriterInput input, Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> sourcePixelBufferAttributes);
}[Serializable]
public enum AVAudioApplicationMicrophoneInjectionPermission {
Denied = 1684369017,
Granted = 1735552628,
ServiceDisabled = 1936876659,
Undetermined = 1970168948,
}public sealed delegate AVAudioInputNodeMutedSpeechEventListener : System.MulticastDelegate {
// constructors
public AVAudioInputNodeMutedSpeechEventListener (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVAudioVoiceProcessingSpeechActivityEvent event, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (AVAudioVoiceProcessingSpeechActivityEvent event);
}public class AVAudioSequencerInfoDictionary : Foundation.DictionaryContainer {
// constructors
public AVAudioSequencerInfoDictionary ();
public AVAudioSequencerInfoDictionary (Foundation.NSDictionary dictionary);
// properties
public string Album { get; set; }
public double? ApproximateDurationInSeconds { get; set; }
public string Artist { get; set; }
public Foundation.NSObject ChannelLayout { get; set; }
public string Comments { get; set; }
public string Composer { get; set; }
public string Copyright { get; set; }
public string EncodingApplication { get; set; }
public string Genre { get; set; }
public Foundation.NSObject Isrc { get; set; }
public string KeySignature { get; set; }
public string Lyricist { get; set; }
public double? NominalBitRate { get; set; }
public Foundation.NSObject RecordedDate { get; set; }
public double? SourceBitDepth { get; set; }
public string SourceEncoder { get; set; }
public string SubTitle { get; set; }
public double? Tempo { get; set; }
public string TimeSignature { get; set; }
public string Title { get; set; }
public int? TrackNumber { get; set; }
public string Year { get; set; }
}public sealed delegate AVAudioSequencerUserCallback : System.MulticastDelegate {
// constructors
public AVAudioSequencerUserCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVMusicTrack track, Foundation.NSData userData, double timeStamp, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (AVMusicTrack track, Foundation.NSData userData, double timeStamp);
}[Serializable]
public enum AVAudioSessionMicrophoneInjectionMode {
None = 0,
SpokenAudio = 1,
}[Serializable]
public enum AVAudioSessionRenderingMode {
DolbyAtmos = 5,
DolbyAudio = 4,
MonoStereo = 1,
NotApplicable = 0,
SpatialAudio = 3,
Surround = 2,
}public struct AVAudioVoiceProcessingOtherAudioDuckingConfiguration {
// properties
public AVAudioVoiceProcessingOtherAudioDuckingLevel DuckingLevel { get; set; }
public bool EnableAdvancedDucking { get; set; }
}[Serializable]
public enum AVAudioVoiceProcessingOtherAudioDuckingLevel {
Default = 0,
Max = 30,
Mid = 20,
Min = 10,
}[Serializable]
public enum AVAudioVoiceProcessingSpeechActivityEvent {
Ended = 1,
Started = 0,
}public class AVCaptureControl : Foundation.NSObject {
// constructors
protected AVCaptureControl (Foundation.NSObjectFlag t);
protected AVCaptureControl (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual bool Enabled { get; set; }
}public class AVCaptureDeskViewApplication : Foundation.NSObject {
// constructors
public AVCaptureDeskViewApplication ();
protected AVCaptureDeskViewApplication (Foundation.NSObjectFlag t);
protected AVCaptureDeskViewApplication (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
// methods
public virtual void Present (AVCaptureDeskViewApplicationPresentHandler completionHandler);
public virtual void Present (AVCaptureDeskViewApplicationLaunchConfiguration launchConfiguration, AVCaptureDeskViewApplicationPresentHandler completionHandler);
public virtual System.Threading.Tasks.Task PresentAsync ();
public virtual System.Threading.Tasks.Task PresentAsync (AVCaptureDeskViewApplicationLaunchConfiguration launchConfiguration);
}public class AVCaptureDeskViewApplicationLaunchConfiguration : Foundation.NSObject {
// constructors
public AVCaptureDeskViewApplicationLaunchConfiguration ();
protected AVCaptureDeskViewApplicationLaunchConfiguration (Foundation.NSObjectFlag t);
protected AVCaptureDeskViewApplicationLaunchConfiguration (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual CoreGraphics.CGRect MainWindowFrame { get; set; }
public virtual bool RequiresSetUpModeCompletion { get; set; }
}public sealed delegate AVCaptureDeskViewApplicationPresentHandler : System.MulticastDelegate {
// constructors
public AVCaptureDeskViewApplicationPresentHandler (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (Foundation.NSError error, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (Foundation.NSError error);
}public class AVCaptureDeviceRotationCoordinator : Foundation.NSObject {
// constructors
protected AVCaptureDeviceRotationCoordinator (Foundation.NSObjectFlag t);
protected AVCaptureDeviceRotationCoordinator (ObjCRuntime.NativeHandle handle);
public AVCaptureDeviceRotationCoordinator (AVCaptureDevice device, CoreAnimation.CALayer previewLayer);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVCaptureDevice Device { get; }
public virtual CoreAnimation.CALayer PreviewLayer { get; }
public virtual System.Runtime.InteropServices.NFloat VideoRotationAngleForHorizonLevelCapture { get; }
public virtual System.Runtime.InteropServices.NFloat VideoRotationAngleForHorizonLevelPreview { get; }
// methods
protected override void Dispose (bool disposing);
}public class AVCaptureIndexPicker : AVFoundation.AVCaptureControl {
// constructors
public AVCaptureIndexPicker ();
protected AVCaptureIndexPicker (Foundation.NSObjectFlag t);
protected AVCaptureIndexPicker (ObjCRuntime.NativeHandle handle);
public AVCaptureIndexPicker (string localizedTitle, string symbolName, IntPtr numberOfIndexes);
public AVCaptureIndexPicker (string localizedTitle, string symbolName, string[] localizedIndexTitles);
public AVCaptureIndexPicker (string localizedTitle, string symbolName, IntPtr numberOfIndexes, AVCaptureIndexPickerTitleTransform localizedTitleTransform);
// properties
public virtual string AccessibilityIdentifier { get; set; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual string[] LocalizedIndexTitles { get; }
public virtual string LocalizedTitle { get; }
public virtual IntPtr NumberOfIndexes { get; }
public virtual IntPtr SelectedIndex { get; set; }
public virtual string SymbolName { get; }
// methods
public virtual void SetActionQueue (CoreFoundation.DispatchQueue actionQueue, AVCaptureIndexPickerCallback action);
}public sealed delegate AVCaptureIndexPickerCallback : System.MulticastDelegate {
// constructors
public AVCaptureIndexPickerCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (IntPtr newValue, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (IntPtr newValue);
}public sealed delegate AVCaptureIndexPickerTitleTransform : System.MulticastDelegate {
// constructors
public AVCaptureIndexPickerTitleTransform (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (IntPtr index, System.AsyncCallback callback, object object);
public virtual string EndInvoke (System.IAsyncResult result);
public virtual string Invoke (IntPtr index);
}public class AVCaptureMetadataOutput : AVFoundation.AVCaptureOutput {
// constructors
public AVCaptureMetadataOutput ();
protected AVCaptureMetadataOutput (Foundation.NSObjectFlag t);
protected AVCaptureMetadataOutput (ObjCRuntime.NativeHandle handle);
// properties
public virtual CoreFoundation.DispatchQueue CallbackQueue { get; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual IAVCaptureMetadataOutputObjectsDelegate Delegate { get; }
public virtual CoreGraphics.CGRect RectOfInterest { get; set; }
public virtual Foundation.NSString[] WeakAvailableMetadataObjectTypes { get; }
public virtual Foundation.NSString[] WeakMetadataObjectTypes { get; set; }
// methods
public virtual void SetDelegate (IAVCaptureMetadataOutputObjectsDelegate objectsDelegate, CoreFoundation.DispatchQueue objectsCallbackQueue);
}public class AVCaptureMetadataOutputObjectsDelegate : Foundation.NSObject, IAVCaptureMetadataOutputObjectsDelegate, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
public AVCaptureMetadataOutputObjectsDelegate ();
protected AVCaptureMetadataOutputObjectsDelegate (Foundation.NSObjectFlag t);
protected AVCaptureMetadataOutputObjectsDelegate (ObjCRuntime.NativeHandle handle);
// methods
public virtual void DidOutputMetadataObjects (AVCaptureMetadataOutput captureOutput, AVMetadataObject[] metadataObjects, AVCaptureConnection connection);
}public static class AVCaptureMetadataOutputObjectsDelegate_Extensions {
// methods
public static void DidOutputMetadataObjects (this IAVCaptureMetadataOutputObjectsDelegate This, AVCaptureMetadataOutput captureOutput, AVMetadataObject[] metadataObjects, AVCaptureConnection connection);
}[Serializable]
public enum AVCaptureMultichannelAudioMode {
FirstOrderAmbisonics = 2,
None = 0,
Stereo = 1,
}[Serializable]
public enum AVCapturePhotoOutputCaptureReadiness {
NotReadyMomentarily = 2,
NotReadyWaitingForCapture = 3,
NotReadyWaitingForProcessing = 4,
Ready = 1,
SessionNotRunning = 0,
}public class AVCapturePhotoOutputReadinessCoordinator : Foundation.NSObject {
// constructors
public AVCapturePhotoOutputReadinessCoordinator (AVCapturePhotoOutput photoOutput);
protected AVCapturePhotoOutputReadinessCoordinator (Foundation.NSObjectFlag t);
protected AVCapturePhotoOutputReadinessCoordinator (ObjCRuntime.NativeHandle handle);
// properties
public virtual AVCapturePhotoOutputCaptureReadiness CaptureReadiness { get; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public IAVCapturePhotoOutputReadinessCoordinatorDelegate Delegate { get; set; }
public virtual Foundation.NSObject WeakDelegate { get; set; }
// methods
protected override void Dispose (bool disposing);
public virtual void StartTrackingCaptureRequest (AVCapturePhotoSettings settings);
public virtual void StopTrackingCaptureRequest (long settingsUniqueId);
}public class AVCapturePhotoOutputReadinessCoordinatorDelegate : Foundation.NSObject, IAVCapturePhotoOutputReadinessCoordinatorDelegate, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
public AVCapturePhotoOutputReadinessCoordinatorDelegate ();
protected AVCapturePhotoOutputReadinessCoordinatorDelegate (Foundation.NSObjectFlag t);
protected AVCapturePhotoOutputReadinessCoordinatorDelegate (ObjCRuntime.NativeHandle handle);
// methods
public virtual void CaptureReadinessDidChange (AVCapturePhotoOutputReadinessCoordinator coordinator, AVCapturePhotoOutputCaptureReadiness captureReadiness);
}[Serializable]
public enum AVCapturePhotoQualityPrioritization {
Balanced = 2,
Quality = 3,
Speed = 1,
}public class AVCaptureReactionEffectState : Foundation.NSObject {
// constructors
public AVCaptureReactionEffectState ();
protected AVCaptureReactionEffectState (Foundation.NSObjectFlag t);
protected AVCaptureReactionEffectState (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual CoreMedia.CMTime EndTime { get; }
public virtual string ReactionType { get; }
public virtual CoreMedia.CMTime StartTime { get; }
}public static class AVCaptureReactionType_Extensions {
// methods
public static string GetSystemImage (this AVCaptureReactionType reactionType);
}public abstract class AVCaptureSessionControlsDelegate : Foundation.NSObject, IAVCaptureSessionControlsDelegate, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
protected AVCaptureSessionControlsDelegate ();
protected AVCaptureSessionControlsDelegate (Foundation.NSObjectFlag t);
protected AVCaptureSessionControlsDelegate (ObjCRuntime.NativeHandle handle);
// methods
public virtual void DidBecomeActive (AVCaptureSession session);
public virtual void DidBecomeInactive (AVCaptureSession session);
public virtual void WillEnterFullscreenAppearance (AVCaptureSession session);
public virtual void WillExitFullscreenAppearance (AVCaptureSession session);
}public class AVCaptureSlider : AVFoundation.AVCaptureControl {
// constructors
protected AVCaptureSlider (Foundation.NSObjectFlag t);
protected AVCaptureSlider (ObjCRuntime.NativeHandle handle);
public AVCaptureSlider (string localizedTitle, string symbolName, float[] values);
public AVCaptureSlider (string localizedTitle, string symbolName, float minValue, float maxValue);
public AVCaptureSlider (string localizedTitle, string symbolName, float minValue, float maxValue, float step);
// properties
public virtual string AccessibilityIdentifier { get; set; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual string LocalizedTitle { get; }
public virtual string LocalizedValueFormat { get; set; }
public virtual float[] ProminentValues { get; set; }
public virtual string SymbolName { get; }
public virtual float Value { get; set; }
// methods
public virtual void SetActionQueue (CoreFoundation.DispatchQueue actionQueue, AVCaptureSliderCallback action);
}public sealed delegate AVCaptureSliderCallback : System.MulticastDelegate {
// constructors
public AVCaptureSliderCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (float newValue, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (float newValue);
}public class AVCaptureSystemExposureBiasSlider : AVFoundation.AVCaptureControl {
// constructors
public AVCaptureSystemExposureBiasSlider (AVCaptureDevice device);
protected AVCaptureSystemExposureBiasSlider (Foundation.NSObjectFlag t);
protected AVCaptureSystemExposureBiasSlider (ObjCRuntime.NativeHandle handle);
public AVCaptureSystemExposureBiasSlider (AVCaptureDevice device, AVCaptureSystemExposureBiasSliderCallback action);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
}public sealed delegate AVCaptureSystemExposureBiasSliderCallback : System.MulticastDelegate {
// constructors
public AVCaptureSystemExposureBiasSliderCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (System.Runtime.InteropServices.NFloat exposureTargetBias, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (System.Runtime.InteropServices.NFloat exposureTargetBias);
}public class AVCaptureSystemZoomSlider : AVFoundation.AVCaptureControl {
// constructors
public AVCaptureSystemZoomSlider (AVCaptureDevice device);
protected AVCaptureSystemZoomSlider (Foundation.NSObjectFlag t);
protected AVCaptureSystemZoomSlider (ObjCRuntime.NativeHandle handle);
public AVCaptureSystemZoomSlider (AVCaptureDevice device, AVCaptureSystemZoomSliderCallback action);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
}public sealed delegate AVCaptureSystemZoomSliderCallback : System.MulticastDelegate {
// constructors
public AVCaptureSystemZoomSliderCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (System.Runtime.InteropServices.NFloat videoZoomFactor, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (System.Runtime.InteropServices.NFloat videoZoomFactor);
}public class AVExposureBiasRange : Foundation.NSObject {
// constructors
protected AVExposureBiasRange (Foundation.NSObjectFlag t);
protected AVExposureBiasRange (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual float MaxExposureBias { get; }
public virtual float MinExposureBias { get; }
// methods
public virtual bool ContainsExposureBias (float exposureBias);
}public class AVExtendedNoteOnEvent : AVFoundation.AVMusicEvent {
// constructors
public AVExtendedNoteOnEvent ();
protected AVExtendedNoteOnEvent (Foundation.NSObjectFlag t);
protected AVExtendedNoteOnEvent (ObjCRuntime.NativeHandle handle);
public AVExtendedNoteOnEvent (float midiNote, float velocity, uint groupId, double duration);
public AVExtendedNoteOnEvent (float midiNote, float velocity, uint instrumentId, uint groupId, double duration);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public static uint DefaultInstrument { get; }
public virtual double Duration { get; set; }
public virtual uint GroupId { get; set; }
public virtual uint InstrumentId { get; set; }
public virtual float MidiNote { get; set; }
public virtual float Velocity { get; set; }
}public class AVExtendedTempoEvent : AVFoundation.AVMusicEvent {
// constructors
public AVExtendedTempoEvent ();
protected AVExtendedTempoEvent (Foundation.NSObjectFlag t);
protected AVExtendedTempoEvent (ObjCRuntime.NativeHandle handle);
public AVExtendedTempoEvent (double tempo);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual double Tempo { get; set; }
}[Serializable]
public enum AVExternalContentProtectionStatus {
Insufficient = 2,
Pending = 0,
Sufficient = 1,
}public class AVExternalStorageDevice : Foundation.NSObject {
// constructors
protected AVExternalStorageDevice (Foundation.NSObjectFlag t);
protected AVExternalStorageDevice (ObjCRuntime.NativeHandle handle);
// properties
public static AVAuthorizationStatus AuthorizationStatus { get; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual bool Connected { get; }
public virtual string DisplayName { get; }
public virtual IntPtr FreeSize { get; }
public virtual bool NotRecommendedForCaptureUse { get; }
public virtual IntPtr TotalSize { get; }
public virtual Foundation.NSUuid Uuid { get; }
// methods
public virtual Foundation.NSUrl[] GetNextAvailableUrls (string[] extensionArray, out Foundation.NSError outError);
public static void RequestAccess (AVExternalStorageDeviceRequestAccessCallback handler);
public static System.Threading.Tasks.Task<bool> RequestAccessAsync ();
}public class AVExternalStorageDeviceDiscoverySession : Foundation.NSObject {
// constructors
protected AVExternalStorageDeviceDiscoverySession (Foundation.NSObjectFlag t);
protected AVExternalStorageDeviceDiscoverySession (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVExternalStorageDevice[] ExternalStorageDevices { get; }
public static AVExternalStorageDeviceDiscoverySession SharedSession { get; }
public static bool Supported { get; }
}public sealed delegate AVExternalStorageDeviceRequestAccessCallback : System.MulticastDelegate {
// constructors
public AVExternalStorageDeviceRequestAccessCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (bool granted, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (bool granted);
}public class AVMediaExtensionProperties : Foundation.NSObject, Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
protected AVMediaExtensionProperties (Foundation.NSObjectFlag t);
protected AVMediaExtensionProperties (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual string ContainingBundleName { get; }
public virtual Foundation.NSUrl ContainingBundleUrl { get; }
public virtual string ExtensionIdentifier { get; }
public virtual string ExtensionName { get; }
public virtual Foundation.NSUrl ExtensionUrl { get; }
// methods
public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
}public class AVMetadataHumanFullBodyObject : AVFoundation.AVMetadataBodyObject, Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
public AVMetadataHumanFullBodyObject ();
protected AVMetadataHumanFullBodyObject (Foundation.NSObjectFlag t);
protected AVMetadataHumanFullBodyObject (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
// methods
public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
}public class AVMetricContentKeyRequestEvent : AVFoundation.AVMetricEvent {
// constructors
public AVMetricContentKeyRequestEvent (Foundation.NSCoder coder);
protected AVMetricContentKeyRequestEvent (Foundation.NSObjectFlag t);
protected AVMetricContentKeyRequestEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVContentKeySpecifier ContentKeySpecifier { get; }
public virtual bool IsClientInitiated { get; }
public virtual AVMetricMediaResourceRequestEvent MediaResourceRequestEvent { get; }
public virtual string MediaType { get; }
}public class AVMetricErrorEvent : AVFoundation.AVMetricEvent {
// constructors
public AVMetricErrorEvent (Foundation.NSCoder coder);
protected AVMetricErrorEvent (Foundation.NSObjectFlag t);
protected AVMetricErrorEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual bool DidRecover { get; }
public virtual Foundation.NSError Error { get; }
}public class AVMetricEvent : Foundation.NSObject, Foundation.INSCoding, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
public AVMetricEvent (Foundation.NSCoder coder);
protected AVMetricEvent (Foundation.NSObjectFlag t);
protected AVMetricEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual Foundation.NSDate Date { get; }
public virtual CoreMedia.CMTime MediaTime { get; }
public virtual string SessionId { get; }
// methods
public virtual void EncodeTo (Foundation.NSCoder encoder);
}public class AVMetricEventStream : Foundation.NSObject {
// constructors
protected AVMetricEventStream (Foundation.NSObjectFlag t);
protected AVMetricEventStream (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
// methods
public virtual bool AddPublisher (IAVMetricEventStreamPublisher publisher);
public static AVMetricEventStream Create ();
public virtual bool SetSubscriber (IAVMetricEventStreamSubscriber subscriber, CoreFoundation.DispatchQueue queue);
public virtual void SubscribeTo (ObjCRuntime.Class metricEventClass);
public virtual void SubscribeTo (ObjCRuntime.Class[] metricEventsClasses);
public void SubscribeTo (System.Type metricEventType);
public void SubscribeTo (System.Type[] metricEventsTypes);
public virtual void SubscribeToAll ();
}public class AVMetricHlsMediaSegmentRequestEvent : AVFoundation.AVMetricEvent {
// constructors
public AVMetricHlsMediaSegmentRequestEvent (Foundation.NSCoder coder);
protected AVMetricHlsMediaSegmentRequestEvent (Foundation.NSObjectFlag t);
protected AVMetricHlsMediaSegmentRequestEvent (ObjCRuntime.NativeHandle handle);
// properties
public virtual Foundation.NSRange ByteRange { get; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual Foundation.NSUrl IndexFileUrl { get; }
public virtual bool IsMapSegment { get; }
public virtual AVMetricMediaResourceRequestEvent MediaResourceRequestEvent { get; }
public virtual string MediaType { get; }
public virtual Foundation.NSUrl Url { get; }
}public class AVMetricHlsPlaylistRequestEvent : AVFoundation.AVMetricEvent {
// constructors
public AVMetricHlsPlaylistRequestEvent (Foundation.NSCoder coder);
protected AVMetricHlsPlaylistRequestEvent (Foundation.NSObjectFlag t);
protected AVMetricHlsPlaylistRequestEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual bool IsMultivariantPlaylist { get; }
public virtual AVMetricMediaResourceRequestEvent MediaResourceRequestEvent { get; }
public virtual string MediaType { get; }
public virtual Foundation.NSUrl Url { get; }
}public class AVMetricMediaResourceRequestEvent : AVFoundation.AVMetricEvent {
// constructors
public AVMetricMediaResourceRequestEvent (Foundation.NSCoder coder);
protected AVMetricMediaResourceRequestEvent (Foundation.NSObjectFlag t);
protected AVMetricMediaResourceRequestEvent (ObjCRuntime.NativeHandle handle);
// properties
public virtual Foundation.NSRange ByteRange { get; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVMetricErrorEvent ErrorEvent { get; }
public virtual Foundation.NSUrlSessionTaskMetrics NetworkTransactionMetrics { get; }
public virtual bool ReadFromCache { get; }
public virtual Foundation.NSDate RequestEndTime { get; }
public virtual Foundation.NSDate RequestStartTime { get; }
public virtual Foundation.NSDate ResponseEndTime { get; }
public virtual Foundation.NSDate ResponseStartTime { get; }
public virtual string ServerAddress { get; }
public virtual Foundation.NSUrl Url { get; }
}public class AVMetricPlayerItemInitialLikelyToKeepUpEvent : AVFoundation.AVMetricPlayerItemLikelyToKeepUpEvent {
// constructors
public AVMetricPlayerItemInitialLikelyToKeepUpEvent (Foundation.NSCoder coder);
protected AVMetricPlayerItemInitialLikelyToKeepUpEvent (Foundation.NSObjectFlag t);
protected AVMetricPlayerItemInitialLikelyToKeepUpEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVMetricContentKeyRequestEvent[] ContentKeyRequestEvents { get; }
public virtual AVMetricHlsMediaSegmentRequestEvent[] MediaSegmentRequestEvents { get; }
public virtual AVMetricHlsPlaylistRequestEvent[] PlaylistRequestEvents { get; }
}public class AVMetricPlayerItemLikelyToKeepUpEvent : AVFoundation.AVMetricEvent {
// constructors
public AVMetricPlayerItemLikelyToKeepUpEvent (Foundation.NSCoder coder);
protected AVMetricPlayerItemLikelyToKeepUpEvent (Foundation.NSObjectFlag t);
protected AVMetricPlayerItemLikelyToKeepUpEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual CoreMedia.CMTimeRange[] LoadedTimeRanges { get; }
public virtual double TimeTaken { get; }
public virtual AVAssetVariant Variant { get; }
}public class AVMetricPlayerItemPlaybackSummaryEvent : AVFoundation.AVMetricEvent {
// constructors
public AVMetricPlayerItemPlaybackSummaryEvent (Foundation.NSCoder coder);
protected AVMetricPlayerItemPlaybackSummaryEvent (Foundation.NSObjectFlag t);
protected AVMetricPlayerItemPlaybackSummaryEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVMetricErrorEvent ErrorEvent { get; }
public virtual IntPtr MediaResourceRequestCount { get; }
public virtual IntPtr PlaybackDuration { get; }
public virtual IntPtr RecoverableErrorCount { get; }
public virtual IntPtr StallCount { get; }
public virtual double TimeSpentInInitialStartup { get; }
public virtual double TimeSpentRecoveringFromStall { get; }
public virtual IntPtr TimeWeightedAverageBitrate { get; }
public virtual IntPtr TimeWeightedPeakBitrate { get; }
public virtual IntPtr VariantSwitchCount { get; }
}public class AVMetricPlayerItemRateChangeEvent : AVFoundation.AVMetricEvent {
// constructors
public AVMetricPlayerItemRateChangeEvent (Foundation.NSCoder coder);
protected AVMetricPlayerItemRateChangeEvent (Foundation.NSObjectFlag t);
protected AVMetricPlayerItemRateChangeEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual double PreviousRate { get; }
public virtual double Rate { get; }
public virtual AVAssetVariant Variant { get; }
}public class AVMetricPlayerItemSeekDidCompleteEvent : AVFoundation.AVMetricPlayerItemRateChangeEvent {
// constructors
public AVMetricPlayerItemSeekDidCompleteEvent (Foundation.NSCoder coder);
protected AVMetricPlayerItemSeekDidCompleteEvent (Foundation.NSObjectFlag t);
protected AVMetricPlayerItemSeekDidCompleteEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual bool DidSeekInBuffer { get; }
}public class AVMetricPlayerItemSeekEvent : AVFoundation.AVMetricPlayerItemRateChangeEvent {
// constructors
public AVMetricPlayerItemSeekEvent (Foundation.NSCoder coder);
protected AVMetricPlayerItemSeekEvent (Foundation.NSObjectFlag t);
protected AVMetricPlayerItemSeekEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
}public class AVMetricPlayerItemStallEvent : AVFoundation.AVMetricPlayerItemRateChangeEvent {
// constructors
public AVMetricPlayerItemStallEvent (Foundation.NSCoder coder);
protected AVMetricPlayerItemStallEvent (Foundation.NSObjectFlag t);
protected AVMetricPlayerItemStallEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
}public class AVMetricPlayerItemVariantSwitchEvent : AVFoundation.AVMetricEvent {
// constructors
public AVMetricPlayerItemVariantSwitchEvent (Foundation.NSCoder coder);
protected AVMetricPlayerItemVariantSwitchEvent (Foundation.NSObjectFlag t);
protected AVMetricPlayerItemVariantSwitchEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual bool DidSucceed { get; }
public virtual AVAssetVariant FromVariant { get; }
public virtual CoreMedia.CMTimeRange[] LoadedTimeRanges { get; }
public virtual AVAssetVariant ToVariant { get; }
}public class AVMetricPlayerItemVariantSwitchStartEvent : AVFoundation.AVMetricEvent {
// constructors
public AVMetricPlayerItemVariantSwitchStartEvent (Foundation.NSCoder coder);
protected AVMetricPlayerItemVariantSwitchStartEvent (Foundation.NSObjectFlag t);
protected AVMetricPlayerItemVariantSwitchStartEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVAssetVariant FromVariant { get; }
public virtual CoreMedia.CMTimeRange[] LoadedTimeRanges { get; }
public virtual AVAssetVariant ToVariant { get; }
}public class AVMidiChannelEvent : AVFoundation.AVMusicEvent {
// constructors
public AVMidiChannelEvent ();
protected AVMidiChannelEvent (Foundation.NSObjectFlag t);
protected AVMidiChannelEvent (ObjCRuntime.NativeHandle handle);
// properties
public virtual uint Channel { get; set; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
}public class AVMidiChannelPressureEvent : AVFoundation.AVMidiChannelEvent {
// constructors
public AVMidiChannelPressureEvent ();
protected AVMidiChannelPressureEvent (Foundation.NSObjectFlag t);
protected AVMidiChannelPressureEvent (ObjCRuntime.NativeHandle handle);
public AVMidiChannelPressureEvent (uint channel, uint pressure);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual uint Pressure { get; set; }
}public class AVMidiControlChangeEvent : AVFoundation.AVMidiChannelEvent {
// constructors
public AVMidiControlChangeEvent ();
protected AVMidiControlChangeEvent (Foundation.NSObjectFlag t);
protected AVMidiControlChangeEvent (ObjCRuntime.NativeHandle handle);
public AVMidiControlChangeEvent (uint channel, AVMidiControlChangeMessageType messageType, uint value);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVMidiControlChangeMessageType MessageType { get; }
public virtual uint Value { get; }
}[Serializable]
public enum AVMidiControlChangeMessageType {
AllNotesOff = 123,
AllSoundOff = 120,
AttackTime = 73,
Balance = 8,
BankSelect = 0,
Breath = 2,
Brightness = 74,
ChorusLevel = 93,
DataEntry = 6,
DecayTime = 75,
Expression = 11,
FilterResonance = 71,
Foot = 4,
Hold2Pedal = 69,
LegatoPedal = 68,
ModWheel = 1,
MonoModeOff = 127,
MonoModeOn = 126,
OmniModeOff = 124,
OmniModeOn = 125,
Pan = 10,
Portamento = 65,
PortamentoTime = 5,
ReleaseTime = 72,
ResetAllControllers = 121,
ReverbLevel = 91,
RpnLsb = 100,
RpnMsb = 101,
Soft = 67,
Sostenuto = 66,
Sustain = 64,
VibratoDelay = 78,
VibratoDepth = 77,
VibratoRate = 76,
Volume = 7,
}public class AVMidiMetaEvent : AVFoundation.AVMusicEvent {
// constructors
public AVMidiMetaEvent ();
protected AVMidiMetaEvent (Foundation.NSObjectFlag t);
protected AVMidiMetaEvent (ObjCRuntime.NativeHandle handle);
public AVMidiMetaEvent (AVMidiMetaEventType type, Foundation.NSData data);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVMidiMetaEventType Type { get; }
}[Serializable]
public enum AVMidiMetaEventType {
Copyright = 2,
CuePoint = 7,
EndOfTrack = 47,
Instrument = 4,
KeySignature = 89,
Lyric = 5,
Marker = 6,
MidiChannel = 32,
MidiPort = 33,
ProprietaryEvent = 127,
SequenceNumber = 0,
SmpteOffset = 84,
Tempo = 81,
Text = 1,
TimeSignature = 88,
TrackName = 3,
}public class AVMidiNoteEvent : AVFoundation.AVMusicEvent {
// constructors
public AVMidiNoteEvent ();
protected AVMidiNoteEvent (Foundation.NSObjectFlag t);
protected AVMidiNoteEvent (ObjCRuntime.NativeHandle handle);
public AVMidiNoteEvent (uint channel, uint keyNum, uint velocity, double duration);
// properties
public virtual uint Channel { get; set; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual double Duration { get; set; }
public virtual uint Key { get; set; }
public virtual uint Velocity { get; set; }
}public class AVMidiPitchBendEvent : AVFoundation.AVMidiChannelEvent {
// constructors
public AVMidiPitchBendEvent ();
protected AVMidiPitchBendEvent (Foundation.NSObjectFlag t);
protected AVMidiPitchBendEvent (ObjCRuntime.NativeHandle handle);
public AVMidiPitchBendEvent (uint channel, uint value);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual uint Value { get; set; }
}public class AVMidiPolyPressureEvent : AVFoundation.AVMidiChannelEvent {
// constructors
public AVMidiPolyPressureEvent ();
protected AVMidiPolyPressureEvent (Foundation.NSObjectFlag t);
protected AVMidiPolyPressureEvent (ObjCRuntime.NativeHandle handle);
public AVMidiPolyPressureEvent (uint channel, uint key, uint pressure);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual uint Key { get; set; }
public virtual uint Pressure { get; set; }
}public class AVMidiProgramChangeEvent : AVFoundation.AVMidiChannelEvent {
// constructors
public AVMidiProgramChangeEvent ();
protected AVMidiProgramChangeEvent (Foundation.NSObjectFlag t);
protected AVMidiProgramChangeEvent (ObjCRuntime.NativeHandle handle);
public AVMidiProgramChangeEvent (uint channel, uint programNumber);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual uint ProgramNumber { get; set; }
}public class AVMidiSysexEvent : AVFoundation.AVMusicEvent {
// constructors
public AVMidiSysexEvent ();
public AVMidiSysexEvent (Foundation.NSData data);
protected AVMidiSysexEvent (Foundation.NSObjectFlag t);
protected AVMidiSysexEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual uint SizeInBytes { get; }
}public class AVMusicEvent : Foundation.NSObject {
// constructors
public AVMusicEvent ();
protected AVMusicEvent (Foundation.NSObjectFlag t);
protected AVMusicEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
}public sealed delegate AVMusicEventEnumerationBlock : System.MulticastDelegate {
// constructors
public AVMusicEventEnumerationBlock (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVMusicEvent event, out double timeStamp, out bool removeEvent, System.AsyncCallback callback, object object);
public virtual void EndInvoke (out double timeStamp, out bool removeEvent, System.IAsyncResult result);
public virtual void Invoke (AVMusicEvent event, out double timeStamp, out bool removeEvent);
}public class AVMusicUserEvent : AVFoundation.AVMusicEvent {
// constructors
public AVMusicUserEvent ();
public AVMusicUserEvent (Foundation.NSData data);
protected AVMusicUserEvent (Foundation.NSObjectFlag t);
protected AVMusicUserEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual uint SizeInBytes { get; }
}public sealed delegate AVMutableCompositionInsertHandler : System.MulticastDelegate {
// constructors
public AVMutableCompositionInsertHandler (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (Foundation.NSError error, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (Foundation.NSError error);
}public sealed delegate AVMutableVideoCompositionCreateApplier : System.MulticastDelegate {
// constructors
public AVMutableVideoCompositionCreateApplier (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVAsynchronousCIImageFilteringRequest request, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (AVAsynchronousCIImageFilteringRequest request);
}public sealed delegate AVMutableVideoCompositionCreateCallback : System.MulticastDelegate {
// constructors
public AVMutableVideoCompositionCreateCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVMutableVideoComposition videoComposition, Foundation.NSError error, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (AVMutableVideoComposition videoComposition, Foundation.NSError error);
}public class AVParameterEvent : AVFoundation.AVMusicEvent {
// constructors
public AVParameterEvent ();
protected AVParameterEvent (Foundation.NSObjectFlag t);
protected AVParameterEvent (ObjCRuntime.NativeHandle handle);
public AVParameterEvent (uint parameterId, uint scope, uint element, float value);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual uint Element { get; set; }
public virtual uint ParameterId { get; set; }
public virtual uint Scope { get; set; }
public virtual float Value { get; set; }
}[Serializable]
public enum AVPlayerIntegratedTimelineSnapshotsOutOfSyncReason {
CurrentSegmentChanged = 1,
LoadedTimeRangesChanged = 2,
SegmentsChanged = 0,
}public static class AVPlayerIntegratedTimelineSnapshotsOutOfSyncReasonExtensions {
// methods
public static Foundation.NSString GetConstant (this AVPlayerIntegratedTimelineSnapshotsOutOfSyncReason self);
public static AVPlayerIntegratedTimelineSnapshotsOutOfSyncReason GetValue (Foundation.NSString constant);
}[Serializable]
public enum AVPlayerInterstitialEventAssetListResponseStatus {
Available = 0,
Cleared = 1,
Unavailable = 2,
}[Serializable]
public enum AVPlayerInterstitialEventCue {
JoinCue = 1,
LeaveCue = 2,
NoCue = 0,
}public static class AVPlayerInterstitialEventCueExtensions {
// methods
public static Foundation.NSString GetConstant (this AVPlayerInterstitialEventCue self);
public static AVPlayerInterstitialEventCue GetValue (Foundation.NSString constant);
}[Serializable]
public enum AVPlayerInterstitialEventTimelineOccupancy {
Fill = 1,
SinglePoint = 0,
}public class AVPlayerItemIntegratedTimeline : Foundation.NSObject {
// constructors
protected AVPlayerItemIntegratedTimeline (Foundation.NSObjectFlag t);
protected AVPlayerItemIntegratedTimeline (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual Foundation.NSDate CurrentDate { get; }
public virtual AVPlayerItemIntegratedTimelineSnapshot CurrentSnapshot { get; }
public virtual CoreMedia.CMTime CurrentTime { get; }
// methods
public virtual IAVPlayerItemIntegratedTimelineObserver AddBoundaryTimeObserver (AVPlayerItemSegment segment, CoreMedia.CMTime[] offsetsIntoSegment, CoreFoundation.DispatchQueue queue, AVPlayerItemIntegratedTimelineAddBoundaryTimeObserverCallback callback);
public virtual IAVPlayerItemIntegratedTimelineObserver AddPeriodicTimeObserver (CoreMedia.CMTime interval, CoreFoundation.DispatchQueue queue, AVPlayerItemIntegratedTimelineAddPeriodicTimeObserverCallback callback);
public virtual void RemoveTimeObserver (IAVPlayerItemIntegratedTimelineObserver observer);
public virtual void SeekToDate (Foundation.NSDate date, AVPlayerItemIntegratedTimelineSeekCallback completionHandler);
public virtual System.Threading.Tasks.Task<bool> SeekToDateAsync (Foundation.NSDate date);
public virtual void SeekToTime (CoreMedia.CMTime time, CoreMedia.CMTime toleranceBefore, CoreMedia.CMTime toleranceAfter, AVPlayerItemIntegratedTimelineSeekCallback completionHandler);
public virtual System.Threading.Tasks.Task<bool> SeekToTimeAsync (CoreMedia.CMTime time, CoreMedia.CMTime toleranceBefore, CoreMedia.CMTime toleranceAfter);
}public sealed delegate AVPlayerItemIntegratedTimelineAddBoundaryTimeObserverCallback : System.MulticastDelegate {
// constructors
public AVPlayerItemIntegratedTimelineAddBoundaryTimeObserverCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (bool success, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (bool success);
}public sealed delegate AVPlayerItemIntegratedTimelineAddPeriodicTimeObserverCallback : System.MulticastDelegate {
// constructors
public AVPlayerItemIntegratedTimelineAddPeriodicTimeObserverCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (CoreMedia.CMTime time, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (CoreMedia.CMTime time);
}public sealed delegate AVPlayerItemIntegratedTimelineSeekCallback : System.MulticastDelegate {
// constructors
public AVPlayerItemIntegratedTimelineSeekCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (bool success, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (bool success);
}public class AVPlayerItemIntegratedTimelineSnapshot : Foundation.NSObject {
// constructors
protected AVPlayerItemIntegratedTimelineSnapshot (Foundation.NSObjectFlag t);
protected AVPlayerItemIntegratedTimelineSnapshot (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual Foundation.NSDate CurrentDate { get; }
public virtual AVPlayerItemSegment CurrentSegment { get; }
public virtual CoreMedia.CMTime CurrentTime { get; }
public virtual CoreMedia.CMTime Duration { get; }
public virtual AVPlayerItemSegment[] Segments { get; }
public static Foundation.NSString SnapshotsOutOfSyncNotification { get; }
public static Foundation.NSString SnapshotsOutOfSyncReasonKey { get; }
// methods
public virtual void Map (CoreMedia.CMTime time, out AVPlayerItemSegment timeSegment, out CoreMedia.CMTime segmentOffset);
// inner types
public static class Notifications {
// methods
public static Foundation.NSObject ObserveSnapshotsOutOfSync (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveSnapshotsOutOfSync (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
}
}public class AVPlayerItemRenderedLegibleOutput : AVFoundation.AVPlayerItemOutput {
// constructors
public AVPlayerItemRenderedLegibleOutput (CoreGraphics.CGSize videoDisplaySize);
protected AVPlayerItemRenderedLegibleOutput (Foundation.NSObjectFlag t);
protected AVPlayerItemRenderedLegibleOutput (ObjCRuntime.NativeHandle handle);
// properties
public virtual double AdvanceIntervalForDelegateInvocation { get; set; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public IAVPlayerItemRenderedLegibleOutputPushDelegate Delegate { get; }
public virtual CoreFoundation.DispatchQueue DelegateQueue { get; }
public virtual CoreGraphics.CGSize VideoDisplaySize { get; set; }
public virtual Foundation.NSObject WeakDelegate { get; }
// methods
protected override void Dispose (bool disposing);
public virtual void SetDelegate (IAVPlayerItemRenderedLegibleOutputPushDelegate delegate, CoreFoundation.DispatchQueue delegateQueue);
}public class AVPlayerItemRenderedLegibleOutputPushDelegate : Foundation.NSObject, IAVPlayerItemOutputPushDelegate, IAVPlayerItemRenderedLegibleOutputPushDelegate, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
public AVPlayerItemRenderedLegibleOutputPushDelegate ();
protected AVPlayerItemRenderedLegibleOutputPushDelegate (Foundation.NSObjectFlag t);
protected AVPlayerItemRenderedLegibleOutputPushDelegate (ObjCRuntime.NativeHandle handle);
// methods
public virtual void DidOutputRenderedCaptionImages (AVPlayerItemRenderedLegibleOutput output, AVRenderedCaptionImage[] captionImages, CoreMedia.CMTime itemTime);
public virtual void OutputSequenceWasFlushed (AVPlayerItemOutput output);
}public class AVPlayerItemSegment : Foundation.NSObject {
// constructors
protected AVPlayerItemSegment (Foundation.NSObjectFlag t);
protected AVPlayerItemSegment (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVPlayerInterstitialEvent InterstitialEvent { get; }
public virtual CoreMedia.CMTimeRange[] LoadedTimeRanges { get; }
public virtual AVPlayerItemSegmentType SegmentType { get; }
public virtual Foundation.NSDate StartDate { get; }
public virtual CoreMedia.CMTimeMapping TimeMapping { get; }
}[Serializable]
public enum AVPlayerItemSegmentType {
Interstitial = 1,
Primary = 0,
}[Serializable]
public enum AVPlayerLooperItemOrdering {
FollowExistingItems = 1,
PrecedeExistingItems = 0,
}public class AVPlayerVideoOutput : Foundation.NSObject {
// constructors
public AVPlayerVideoOutput (AVVideoOutputSpecification specification);
protected AVPlayerVideoOutput (Foundation.NSObjectFlag t);
protected AVPlayerVideoOutput (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
// methods
public virtual CoreMedia.CMTaggedBufferGroup CopyTaggedBufferGroup (CoreMedia.CMTime hostTime, out CoreMedia.CMTime presentationTimeStamp, out AVPlayerVideoOutputConfiguration activeConfiguration);
}public class AVPlayerVideoOutputConfiguration : Foundation.NSObject {
// constructors
protected AVPlayerVideoOutputConfiguration (Foundation.NSObjectFlag t);
protected AVPlayerVideoOutputConfiguration (ObjCRuntime.NativeHandle handle);
// properties
public virtual CoreMedia.CMTime ActivationTime { get; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual Foundation.NSObject[] DataChannelDescriptions { get; }
public virtual CoreGraphics.CGAffineTransform PreferredTransform { get; }
public virtual AVPlayerItem SourcePlayerItem { get; }
// methods
protected override void Dispose (bool disposing);
}public class AVRenderedCaptionImage : Foundation.NSObject {
// constructors
protected AVRenderedCaptionImage (Foundation.NSObjectFlag t);
protected AVRenderedCaptionImage (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual CoreVideo.CVPixelBuffer PixelBuffer { get; }
public virtual CoreGraphics.CGPoint Position { get; }
}public class AVSampleBufferGeneratorBatch : Foundation.NSObject {
// constructors
protected AVSampleBufferGeneratorBatch (Foundation.NSObjectFlag t);
protected AVSampleBufferGeneratorBatch (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
// methods
public virtual void Cancel ();
public virtual void MakeDataReady (AVSampleBufferGeneratorBatchMakeReadyCallback completionHandler);
public virtual System.Threading.Tasks.Task MakeDataReadyAsync ();
}public sealed delegate AVSampleBufferGeneratorBatchMakeReadyCallback : System.MulticastDelegate {
// constructors
public AVSampleBufferGeneratorBatchMakeReadyCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (Foundation.NSError error, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (Foundation.NSError error);
}public class AVSampleBufferVideoRenderer : Foundation.NSObject, IAVQueuedSampleBufferRendering, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
public AVSampleBufferVideoRenderer ();
protected AVSampleBufferVideoRenderer (Foundation.NSObjectFlag t);
protected AVSampleBufferVideoRenderer (ObjCRuntime.NativeHandle handle);
// properties
public static Foundation.NSString AVSampleBufferVideoRendererDidFailToDecodeNotification { get; }
public static Foundation.NSString AVSampleBufferVideoRendererDidFailToDecodeNotificationErrorKey { get; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual Foundation.NSError Error { get; }
public virtual bool HasSufficientMediaDataForReliablePlaybackStart { get; }
public virtual bool ReadyForMoreMediaData { get; }
public virtual bool RequiresFlushToResumeDecoding { get; }
public static Foundation.NSString RequiresFlushToResumeDecodingDidChangeNotification { get; }
public virtual AVQueuedSampleBufferRenderingStatus Status { get; }
public virtual CoreMedia.CMTimebase Timebase { get; }
// methods
public virtual CoreVideo.CVPixelBuffer CopyDisplayedPixelBuffer ();
public virtual void Enqueue (CoreMedia.CMSampleBuffer sampleBuffer);
public virtual void ExpectMinimumUpcomingSampleBufferPresentationTime (CoreMedia.CMTime minimumUpcomingPresentationTime);
public virtual void ExpectMonotonicallyIncreasingUpcomingSampleBufferPresentationTimes ();
public virtual void Flush ();
public virtual void FlushWithRemovalOfDisplayedImage (bool removeDisplayedImage, System.Action handler);
public virtual void LoadVideoPerformanceMetrics (AVSampleBufferVideoRendererLoadVideoPerformanceMetricsCallback completionHandler);
public virtual System.Threading.Tasks.Task<AVVideoPerformanceMetrics> LoadVideoPerformanceMetricsAsync ();
public virtual void RequestMediaData (CoreFoundation.DispatchQueue queue, System.Action handler);
public virtual void ResetUpcomingSampleBufferPresentationTimeExpectations ();
public virtual void StopRequestingMediaData ();
// inner types
public static class Notifications {
// methods
public static Foundation.NSObject ObserveAVSampleBufferVideoRendererDidFailToDecode (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveAVSampleBufferVideoRendererDidFailToDecode (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveRequiresFlushToResumeDecodingDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveRequiresFlushToResumeDecodingDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
}
}public sealed delegate AVSampleBufferVideoRendererLoadVideoPerformanceMetricsCallback : System.MulticastDelegate {
// constructors
public AVSampleBufferVideoRendererLoadVideoPerformanceMetricsCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVVideoPerformanceMetrics videoPerformanceMetrics, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (AVVideoPerformanceMetrics videoPerformanceMetrics);
}[Serializable]
public enum AVSpatialCaptureDiscomfortReason {
NotEnoughLight = 0,
SubjectTooClose = 1,
}public static class AVSpatialCaptureDiscomfortReasonExtensions {
// methods
public static Foundation.NSString GetConstant (this AVSpatialCaptureDiscomfortReason self);
public static AVSpatialCaptureDiscomfortReason GetValue (Foundation.NSString constant);
}public class AVSpeechSynthesisMarker : Foundation.NSObject, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
public AVSpeechSynthesisMarker ();
public AVSpeechSynthesisMarker (Foundation.NSCoder coder);
protected AVSpeechSynthesisMarker (Foundation.NSObjectFlag t);
protected AVSpeechSynthesisMarker (ObjCRuntime.NativeHandle handle);
public AVSpeechSynthesisMarker (AVSpeechSynthesisMarkerMark type, Foundation.NSRange range, UIntPtr byteSampleOffset);
public AVSpeechSynthesisMarker (Foundation.NSRange range, IntPtr byteSampleOffset, AVSpeechSynthesisMarkerRangeOption option);
public AVSpeechSynthesisMarker (string value, IntPtr byteSampleOffset, AVSpeechSynthesisMarkerStringOption option);
// properties
public virtual string BookmarkName { get; set; }
public virtual UIntPtr ByteSampleOffset { get; set; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVSpeechSynthesisMarkerMark Mark { get; set; }
public virtual string Phoneme { get; set; }
public virtual Foundation.NSRange TextRange { get; set; }
// methods
public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
public virtual void EncodeTo (Foundation.NSCoder encoder);
}[Serializable]
public enum AVSpeechSynthesisMarkerMark {
Bookmark = 4,
Paragraph = 3,
Phoneme = 0,
Sentence = 2,
Word = 1,
}[Serializable]
public enum AVSpeechSynthesisMarkerRangeOption {
Paragraph = 2,
Sentence = 1,
Word = 0,
}[Serializable]
public enum AVSpeechSynthesisMarkerStringOption {
Bookmark = 1,
Phoneme = 0,
}[Serializable]
public enum AVSpeechSynthesisPersonalVoiceAuthorizationStatus {
Authorized = 3,
Denied = 1,
NotDetermined = 0,
Unsupported = 2,
}public class AVSpeechSynthesisProviderAudioUnit : AudioUnit.AUAudioUnit {
// constructors
protected AVSpeechSynthesisProviderAudioUnit (Foundation.NSObjectFlag t);
protected AVSpeechSynthesisProviderAudioUnit (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVSpeechSynthesisProviderOutputBlock SpeechSynthesisOutputMetadataBlock { get; set; }
public virtual AVSpeechSynthesisProviderVoice[] SpeechVoices { get; set; }
// methods
public virtual void CancelSpeechRequest ();
public static AVSpeechSynthesisProviderAudioUnit Create (AudioUnit.AudioComponentDescription componentDescription, AudioUnit.AudioComponentInstantiationOptions options, out Foundation.NSError error);
public virtual void SynthesizeSpeechRequest (AVSpeechSynthesisProviderRequest speechRequest);
}public sealed delegate AVSpeechSynthesisProviderOutputBlock : System.MulticastDelegate {
// constructors
public AVSpeechSynthesisProviderOutputBlock (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVSpeechSynthesisMarker[] markers, AVSpeechSynthesisProviderRequest request, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (AVSpeechSynthesisMarker[] markers, AVSpeechSynthesisProviderRequest request);
}public class AVSpeechSynthesisProviderRequest : Foundation.NSObject, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
public AVSpeechSynthesisProviderRequest (Foundation.NSCoder coder);
protected AVSpeechSynthesisProviderRequest (Foundation.NSObjectFlag t);
protected AVSpeechSynthesisProviderRequest (ObjCRuntime.NativeHandle handle);
public AVSpeechSynthesisProviderRequest (string ssmlRepresentation, AVSpeechSynthesisProviderVoice voice);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual string SsmlRepresentation { get; }
public virtual AVSpeechSynthesisProviderVoice Voice { get; }
// methods
public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
public virtual void EncodeTo (Foundation.NSCoder encoder);
}public class AVSpeechSynthesisProviderVoice : Foundation.NSObject, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
public AVSpeechSynthesisProviderVoice (Foundation.NSCoder coder);
protected AVSpeechSynthesisProviderVoice (Foundation.NSObjectFlag t);
protected AVSpeechSynthesisProviderVoice (ObjCRuntime.NativeHandle handle);
public AVSpeechSynthesisProviderVoice (string name, string identifier, string[] primaryLanguages, string[] supportedLanguages);
// properties
public virtual IntPtr Age { get; set; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVSpeechSynthesisVoiceGender Gender { get; set; }
public virtual string Identifier { get; }
public virtual string Name { get; }
public virtual string[] PrimaryLanguages { get; }
public virtual string[] SupportedLanguages { get; }
public virtual string Version { get; set; }
public virtual long VoiceSize { get; set; }
// methods
public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
public virtual void EncodeTo (Foundation.NSCoder encoder);
public static void UpdateSpeechVoices ();
}[Serializable]
public enum AVSpeechSynthesisVoiceTraits {
IsNoveltyVoice = 1,
IsPersonalVoice = 2,
None = 0,
}public sealed delegate AVSpeechSynthesizerBufferCallback : System.MulticastDelegate {
// constructors
public AVSpeechSynthesizerBufferCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVAudioBuffer buffer, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (AVAudioBuffer buffer);
}public sealed delegate AVSpeechSynthesizerMarkerCallback : System.MulticastDelegate {
// constructors
public AVSpeechSynthesizerMarkerCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVSpeechSynthesisMarker[] markers, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (AVSpeechSynthesisMarker[] markers);
}public sealed delegate AVSpeechSynthesizerRequestPersonalVoiceAuthorizationCallback : System.MulticastDelegate {
// constructors
public AVSpeechSynthesizerRequestPersonalVoiceAuthorizationCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVSpeechSynthesisPersonalVoiceAuthorizationStatus status, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (AVSpeechSynthesisPersonalVoiceAuthorizationStatus status);
}public class AVSpeechSynthesizerWillSpeakMarkerEventArgs : System.EventArgs {
// constructors
public AVSpeechSynthesizerWillSpeakMarkerEventArgs (AVSpeechSynthesisMarker marker, AVSpeechUtterance utterance);
// properties
public AVSpeechSynthesisMarker Marker { get; set; }
public AVSpeechUtterance Utterance { get; set; }
}[Serializable]
public enum AVSpeechUtteranceInitializationOption {
PlainText = 0,
SsmlRepresentation = 1,
}public sealed delegate AVVideoCompositionCreateApplier : System.MulticastDelegate {
// constructors
public AVVideoCompositionCreateApplier (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVAsynchronousCIImageFilteringRequest applier, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (AVAsynchronousCIImageFilteringRequest applier);
}public sealed delegate AVVideoCompositionCreateCallback : System.MulticastDelegate {
// constructors
public AVVideoCompositionCreateCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVVideoComposition videoComposition, Foundation.NSError error, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (AVVideoComposition videoComposition, Foundation.NSError error);
}public sealed delegate AVVideoCompositionDetermineValidityCallback : System.MulticastDelegate {
// constructors
public AVVideoCompositionDetermineValidityCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (bool isValid, Foundation.NSError error, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (bool isValid, Foundation.NSError error);
}[Serializable]
public enum AVVideoCompositionPerFrameHdrDisplayMetadataPolicy {
Generate = 1,
Propagate = 0,
}public static class AVVideoCompositionPerFrameHdrDisplayMetadataPolicyExtensions {
// methods
public static Foundation.NSString GetConstant (this AVVideoCompositionPerFrameHdrDisplayMetadataPolicy self);
public static AVVideoCompositionPerFrameHdrDisplayMetadataPolicy GetValue (Foundation.NSString constant);
}public class AVVideoOutputSpecification : Foundation.NSObject, Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
protected AVVideoOutputSpecification (Foundation.NSObjectFlag t);
public AVVideoOutputSpecification (Foundation.NSObject[] tagCollections);
protected AVVideoOutputSpecification (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> DefaultOutputSettings { get; set; }
public virtual Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> DefaultPixelBufferAttributes { get; set; }
public virtual Foundation.NSObject[] PreferredTagCollections { get; }
// methods
public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
public virtual void SetOutputSettings (Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> outputSettings, CoreMedia.CMTagCollection tagCollection);
}public class AVVideoPerformanceMetrics : Foundation.NSObject {
// constructors
protected AVVideoPerformanceMetrics (Foundation.NSObjectFlag t);
protected AVVideoPerformanceMetrics (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual IntPtr NumberOfCorruptedFrames { get; }
public virtual IntPtr NumberOfDroppedFrames { get; }
public virtual IntPtr NumberOfFramesDisplayedUsingOptimizedCompositing { get; }
public virtual double TotalAccumulatedFrameDelay { get; }
public virtual IntPtr TotalNumberOfFrames { get; }
}public class AVZoomRange : Foundation.NSObject {
// constructors
protected AVZoomRange (Foundation.NSObjectFlag t);
protected AVZoomRange (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual System.Runtime.InteropServices.NFloat MaxZoomFactor { get; }
public virtual System.Runtime.InteropServices.NFloat MinZoomFactor { get; }
// methods
public virtual bool ContainsZoomFactor (System.Runtime.InteropServices.NFloat zoomFactor);
}[Serializable]
public enum CMTagCollectionVideoOutputPreset {
Monoscopic = 0,
Stereoscopic = 1,
}public static class CMTagCollectionVideoOutputPreset_Extensions {
// methods
public static CoreMedia.CMTagCollection Create (this CMTagCollectionVideoOutputPreset value, out CoreMedia.CMTagCollectionError status);
}public interface IAVCaptureMetadataOutputObjectsDelegate : ObjCRuntime.INativeObject, System.IDisposable {
// methods
public virtual void DidOutputMetadataObjects (AVCaptureMetadataOutput captureOutput, AVMetadataObject[] metadataObjects, AVCaptureConnection connection);
}public interface IAVCapturePhotoOutputReadinessCoordinatorDelegate : ObjCRuntime.INativeObject, System.IDisposable {
// methods
public virtual void CaptureReadinessDidChange (AVCapturePhotoOutputReadinessCoordinator coordinator, AVCapturePhotoOutputCaptureReadiness captureReadiness);
}public interface IAVCaptureSessionControlsDelegate : ObjCRuntime.INativeObject, System.IDisposable {
// methods
public virtual void DidBecomeActive (AVCaptureSession session);
public virtual void DidBecomeInactive (AVCaptureSession session);
public virtual void WillEnterFullscreenAppearance (AVCaptureSession session);
public virtual void WillExitFullscreenAppearance (AVCaptureSession session);
}public interface IAVMetricEventStreamPublisher : ObjCRuntime.INativeObject, System.IDisposable {
}public interface IAVMetricEventStreamSubscriber : ObjCRuntime.INativeObject, System.IDisposable {
// methods
public virtual void DidReceiveEvent (IAVMetricEventStreamPublisher publisher, AVMetricEvent event);
}public interface IAVPlayerItemIntegratedTimelineObserver : ObjCRuntime.INativeObject, System.IDisposable {
}public interface IAVPlayerItemRenderedLegibleOutputPushDelegate : IAVPlayerItemOutputPushDelegate, ObjCRuntime.INativeObject, System.IDisposable {
// methods
public virtual void DidOutputRenderedCaptionImages (AVPlayerItemRenderedLegibleOutput output, AVRenderedCaptionImage[] captionImages, CoreMedia.CMTime itemTime);
}Added property:
public virtual AVVideoFrameAnalysisType VideoFrameAnalysisTypes { get; set; }[Serializable]
public enum CFComparisonResult {
EqualTo = 0,
GreaterThan = 1,
LessThan = -1,
}Added property:
public CMTaggedBufferGroupFormatType TaggedBufferGroupFormatType { get; }Added value:
TaggedBufferGroup = 1952606066,Added property:
public CMTaggedBufferGroup TaggedBufferGroup { get; }Added methods:
public static CMSampleBuffer CreateWithNewTiming (CMSampleBuffer original, CMSampleTimingInfo[] timing, out int status);
public CMSampleTimingInfo[] GetSampleTimingInfo (out int status);[Serializable]
public enum CMPackingType {
None = 1852796517,
OverUnder = 1870030194,
SideBySide = 1936286821,
}[Serializable]
public enum CMProjectionType {
Equirectangular = 1701934441,
Fisheye = 1718186856,
HalfEquirectangular = 1751478645,
Rectangular = 1919247220,
}[Serializable]
[Flags]
public enum CMStereoViewComponents {
LeftEye = 1,
None = 0,
RightEye = 2,
}[Serializable]
[Flags]
public enum CMStereoViewInterpretationOptions {
AdditionalViews = 2,
Default = 0,
StereoOrderReversed = 1,
}public struct CMTag {
// properties
public CMTagCategory Category { get; }
public CMTagDataType DataType { get; }
public ulong FlagsValue { get; }
public double Float64Value { get; }
public bool HasFlagsValue { get; }
public bool HasFloat64Value { get; }
public bool HasInt64Value { get; }
public bool HasOSTypeValue { get; }
public long Int64Value { get; }
public static CMTag Invalid { get; }
public bool IsValid { get; }
public static CMTag MediaSubTypeMebx { get; }
public static CMTag MediaTypeAudio { get; }
public static CMTag MediaTypeMetadata { get; }
public static CMTag MediaTypeVideo { get; }
public uint OSTypeValue { get; }
public static CMTag PackingTypeNone { get; }
public static CMTag PackingTypeOverUnder { get; }
public static CMTag PackingTypeSideBySide { get; }
public static CMTag ProjectionTypeEquirectangular { get; }
public static CMTag ProjectionTypeFisheye { get; }
public static CMTag ProjectionTypeHalfEquirectangular { get; }
public static CMTag ProjectionTypeRectangular { get; }
public static CMTag StereoInterpretationOrderReversed { get; }
public static CMTag StereoLeftAndRightEye { get; }
public static CMTag StereoLeftEye { get; }
public static CMTag StereoNone { get; }
public static CMTag StereoRightEye { get; }
public ulong Value { get; }
// methods
public static CoreFoundation.CFComparisonResult Compare (CMTag tag1, CMTag tag2);
public static CMTag? Create (Foundation.NSDictionary dictionary);
public static CMTag CreateWithFlagsValue (CMTagCategory category, ulong flags);
public static CMTag CreateWithFloat64Value (CMTagCategory category, double value);
public static CMTag CreateWithOSTypeValue (CMTagCategory category, uint osTypeValue);
public static CMTag CreateWithSInt64Value (CMTagCategory category, long value);
public override bool Equals (object obj);
public static bool Equals (CMTag tag1, CMTag tag2);
public override int GetHashCode ();
public Foundation.NSDictionary ToDictionary ();
public override string ToString ();
}[Serializable]
public enum CMTagCategory {
ChannelId = 1986226286,
MediaSubType = 1836283234,
MediaType = 1835297121,
PackingType = 1885430635,
PixelFormat = 1885960294,
ProjectionType = 1886547818,
StereoView = 1702454643,
StereoViewInterpretation = 1702455664,
TrackId = 1953653099,
Undefined = 0,
VideoLayerId = 1986814329,
}public class CMTagCollection : CoreFoundation.NativeObject {
// properties
public IntPtr Count { get; }
public bool IsEmpty { get; }
public CMTag[] Tags { get; }
// methods
public CMTagCollectionError Add (CMTag tag);
public CMTagCollectionError Add (CMTagCollection collection);
public CMTagCollectionError Add (CMTag[] tags);
public void Apply (CMTagCollectionApplyFunction callback);
public CMTag ApplyUntil (CMTagCollectionTagFilterFunction callback);
public bool ContainsCategory (CMTagCategory category);
public bool ContainsTag (CMTag tag);
public bool ContainsTagCollection (CMTagCollection tagCollection);
public bool ContainsTags (CMTag[] tags);
public CMTagCollection Copy (out CMTagCollectionError status);
public static CMTagCollection Create (CMTag[] tags);
public static CMTagCollection Create (Foundation.NSData data, out CMTagCollectionError status);
public static CMTagCollection Create (Foundation.NSDictionary dictionary, out CMTagCollectionError status);
public static CMTagCollection Create (out CMTagCollectionError status, CMTag[] tags);
public static CMTagCollection CreateMutable ();
public static CMTagCollection CreateMutable (out CMTagCollectionError status);
public static CMTagCollection CreateMutable (IntPtr capacity, out CMTagCollectionError status);
public CMTagCollection CreateMutableCopy (out CMTagCollectionError status);
public CMTagCollection CreateWithCopyOfTags (out CMTagCollectionError status, CMTagCategory[] categories);
public CMTagCollection ExclusiveOr (CMTagCollection collection, out CMTagCollectionError status);
public static CMTagCollection ExclusiveOr (CMTagCollection collection1, CMTagCollection collection2, out CMTagCollectionError status);
public IntPtr GetCount (CMTagCategory category);
public IntPtr GetCount (CMTagCollectionTagFilterFunction filter);
public CMTag[] GetTags (CMTagCollectionTagFilterFunction filter);
public CMTag[] GetTags (out CMTagCollectionError status);
public CMTag[] GetTags (CMTagCategory category, out CMTagCollectionError status);
public CMTagCollectionError GetTags (CMTag[] tags, IntPtr tagCount, out IntPtr tagsCopied);
public CMTagCollectionError GetTags (CMTagCategory category, CMTag[] tags, IntPtr tagCount, out IntPtr tagsCopied);
public CMTagCollectionError GetTags (CMTagCollectionTagFilterFunction filter, CMTag[] tags, IntPtr tagCount, out IntPtr tagsCopied);
public static IntPtr GetTypeId ();
public CMTagCollection Intersect (CMTagCollection collection, out CMTagCollectionError status);
public static CMTagCollection Intersect (CMTagCollection collection1, CMTagCollection collection2, out CMTagCollectionError status);
public CMTagCollectionError Remove (CMTag tag);
public CMTagCollectionError RemoveAllTags ();
public CMTagCollectionError RemoveAllTags (CMTagCategory category);
public CMTagCollection Subtract (CMTagCollection collection, out CMTagCollectionError status);
public static CMTagCollection Subtract (CMTagCollection collection1, CMTagCollection collection2, out CMTagCollectionError status);
public Foundation.NSData ToData ();
public Foundation.NSDictionary ToDictionary ();
public override string ToString ();
public CMTagCollection Union (CMTagCollection collection, out CMTagCollectionError status);
public static CMTagCollection Union (CMTagCollection collection1, CMTagCollection collection2, out CMTagCollectionError status);
}public sealed delegate CMTagCollectionApplyFunction : System.MulticastDelegate {
// constructors
public CMTagCollectionApplyFunction (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (CMTag tag, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (CMTag tag);
}[Serializable]
public enum CMTagCollectionError {
AllocationFailed = -15741,
ExhaustedBufferSize = -15748,
InternalError = -15742,
InvalidTag = -15743,
InvalidTagCollectionData = -15745,
InvalidTagCollectionDataVersion = -15747,
InvalidTagCollectionDictionary = -15744,
NotYetImplemented = -15749,
ParamErr = -15740,
Success = 0,
TagNotFound = -15746,
}public sealed delegate CMTagCollectionTagFilterFunction : System.MulticastDelegate {
// constructors
public CMTagCollectionTagFilterFunction (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (CMTag tag, System.AsyncCallback callback, object object);
public virtual bool EndInvoke (System.IAsyncResult result);
public virtual bool Invoke (CMTag tag);
}[Serializable]
public enum CMTagDataType {
Flags = 7,
Float64 = 3,
Invalid = 0,
OSType = 5,
SInt64 = 2,
}[Serializable]
public enum CMTagError {
AllocationFailed = -15731,
ParamErr = -15730,
Success = 0,
}public class CMTaggedBufferGroup : CoreFoundation.NativeObject {
// properties
public IntPtr Count { get; }
// methods
public static CMTaggedBufferGroup Combine (CMTaggedBufferGroup[] groups);
public static CMTaggedBufferGroup Combine (out CMTaggedBufferGroupError status, CMTaggedBufferGroup[] groups);
public static CMTaggedBufferGroup Create (CMTagCollection[] tagCollections, CoreFoundation.NativeObject[] buffers, out CMTaggedBufferGroupError status);
public static CMTaggedBufferGroup Create (CMTagCollection[] tagCollections, CMSampleBuffer[] buffers, out CMTaggedBufferGroupError status);
public static CMTaggedBufferGroup Create (CMTagCollection[] tagCollections, CoreVideo.CVPixelBuffer[] buffers, out CMTaggedBufferGroupError status);
public CMFormatDescription CreateFormatDescription (out CMTaggedBufferGroupError status);
public CMSampleBuffer CreateSampleBuffer (CMTime sampleBufferPts, CMTime sampleBufferDuration, CMFormatDescription formatDescription, out CMTaggedBufferGroupError status);
public IntPtr GetNumberOfMatches (CMTagCollection tagCollection);
public CoreVideo.CVPixelBuffer GetPixelBuffer (IntPtr index);
public CoreVideo.CVPixelBuffer GetPixelBuffer (CMTag tag, out IntPtr index);
public CoreVideo.CVPixelBuffer GetPixelBuffer (CMTagCollection tagCollection, out IntPtr index);
public CMSampleBuffer GetSampleBuffer (IntPtr index);
public CMSampleBuffer GetSampleBuffer (CMTag tag, out IntPtr index);
public CMSampleBuffer GetSampleBuffer (CMTagCollection tagCollection, out IntPtr index);
public CMTagCollection GetTagCollection (IntPtr index);
public static CMTaggedBufferGroup GetTaggedBufferGroup (CMSampleBuffer sampleBuffer);
public static IntPtr GetTypeId ();
public bool Matches (CMFormatDescription formatDescription);
}[Serializable]
public enum CMTaggedBufferGroupError {
AllocationFailed = -15781,
InternalError = -15782,
ParamErr = -15780,
Success = 0,
}[Serializable]
public enum CMTaggedBufferGroupFormatType {
TaggedBufferGroup = 1952606066,
}Obsoleted constructors:
[Obsolete ("Use the 'Create' method instead, because there's no way to return an error from a constructor.")]
public NSAttributedString (NSData data, out NSError error);
[Obsolete ("Use the 'Create' method instead, because there's no way to return an error from a constructor.")]
public NSAttributedString (NSUrl url, out NSError error);
[Obsolete ("Use the 'Create' method instead, because there's no way to return an error from a constructor.")]
public NSAttributedString (NSData data, NSAttributedStringDocumentAttributes documentAttributes, out NSError error);
[Obsolete ("Use the 'Create' method instead, because there's no way to return an error from a constructor.")]
public NSAttributedString (NSUrl url, NSAttributedStringDocumentAttributes documentAttributes, out NSError error);
[Obsolete ("Use the 'Create' method instead, because there's no way to return an error from a constructor.")]
public NSAttributedString (NSData markdown, NSAttributedStringMarkdownParsingOptions options, NSUrl baseUrl, out NSError error);
[Obsolete ("Use the 'Create' method instead, because there's no way to return an error from a constructor.")]
public NSAttributedString (NSUrl markdownFile, NSAttributedStringMarkdownParsingOptions options, NSUrl baseUrl, out NSError error);
[Obsolete ("Use the 'Create' method instead, because there's no way to return an error from a constructor.")]
public NSAttributedString (string markdownString, NSAttributedStringMarkdownParsingOptions options, NSUrl baseUrl, out NSError error);Added methods:
public static NSAttributedString Create (NSData data, out NSError error);
public static NSAttributedString Create (NSUrl url, out NSError error);
public static NSAttributedString Create (NSData data, NSAttributedStringDocumentAttributes options, out NSError error);
public static NSAttributedString Create (NSUrl url, NSAttributedStringDocumentAttributes options, out NSError error);
public static NSAttributedString Create (NSData markdown, NSAttributedStringMarkdownParsingOptions options, NSUrl baseUrl, out NSError error);
public static NSAttributedString Create (NSUrl markdownFile, NSAttributedStringMarkdownParsingOptions options, NSUrl baseUrl, out NSError error);
public static NSAttributedString Create (string markdownString, NSAttributedStringMarkdownParsingOptions options, NSUrl baseUrl, out NSError error);Added property:
public bool IsStubClass { get; set; }Added value:
IsThreadSafe = 8,Removed value:
None = 0,Added value:
Default = 0,Added properties:
public string Library { get; set; }
public string NativePrefix { get; set; }
public string NativeSuffix { get; set; }Added values:
CustomMarshalDirective = 32,
IsThreadSafe = 64,Added values:
CustomMarshalDirective = 32,
DisableZeroCopy = 64,
IsThreadSafe = 128,
MarshalNativeExceptions = 16,
Transient = 256,public class BindFromAttribute : System.Attribute {
// constructors
public BindFromAttribute (System.Type type);
// properties
public System.Type OriginalType { get; set; }
public System.Type Type { get; set; }
}public class BindingTypeAttribute`1 : System.Attribute {
// constructors
public BindingTypeAttribute`1 ();
// properties
public T Flags { get; set; }
public string Name { get; set; }
}[Serializable]
[Flags]
public enum Category {
Default = 0,
IsThreadSafe = 4,
}[Serializable]
[Flags]
public enum Class {
Default = 0,
DisableDefaultCtor = 4,
IsThreadSafe = 8,
}[Serializable]
[Flags]
public enum Protocol {
Default = 0,
IsThreadSafe = 4,
}[Serializable]
[Flags]
public enum StrongDictionary {
Default = 0,
}Modified fields:
-public const string Version = "15.2.9170";
+public const string Version = "15.2.9368";Added field:
public static const string CoreHapticsLibrary = "/System/Library/Frameworks/CoreHaptics.framework/CoreHaptics";Added method:
public static T GetStruct<T> (IntPtr handle, string symbol);Added constructor:
public MarshalManagedExceptionEventArgs (System.Exception exception, MarshalManagedExceptionMode mode);Added constructor:
public MarshalObjectiveCExceptionEventArgs (Foundation.NSException exception, MarshalObjectiveCExceptionMode mode);Added method:
public virtual void UpdateBroadcastUrl (Foundation.NSUrl broadcastUrl);public class CHHapticAudioResourceDefinition : Foundation.DictionaryContainer {
// constructors
public CHHapticAudioResourceDefinition ();
public CHHapticAudioResourceDefinition (Foundation.NSDictionary dictionary);
// properties
public bool? LoopEnabled { get; set; }
public bool? UseVolumeEnvelope { get; set; }
}public class CHHapticDynamicParameter : Foundation.NSObject {
// constructors
protected CHHapticDynamicParameter (Foundation.NSObjectFlag t);
protected CHHapticDynamicParameter (ObjCRuntime.NativeHandle handle);
public CHHapticDynamicParameter (CHHapticDynamicParameterId parameterId, float value, double time);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual CHHapticDynamicParameterId ParameterId { get; }
public virtual double RelativeTime { get; set; }
public virtual float Value { get; set; }
}[Serializable]
public enum CHHapticDynamicParameterId {
AudioAttackTimeControl = 9,
AudioBrightnessControl = 7,
AudioDecayTimeControl = 10,
AudioPanControl = 6,
AudioPitchControl = 8,
AudioReleaseTimeControl = 11,
AudioVolumeControl = 5,
HapticAttackTimeControl = 2,
HapticDecayTimeControl = 3,
HapticIntensityControl = 0,
HapticReleaseTimeControl = 4,
HapticSharpnessControl = 1,
}public static class CHHapticDynamicParameterIdExtensions {
// methods
public static Foundation.NSString GetConstant (this CHHapticDynamicParameterId self);
public static CHHapticDynamicParameterId GetValue (Foundation.NSString constant);
}public class CHHapticEngine : Foundation.NSObject {
// constructors
protected CHHapticEngine (Foundation.NSObjectFlag t);
protected CHHapticEngine (ObjCRuntime.NativeHandle handle);
public CHHapticEngine (out Foundation.NSError error);
// properties
public virtual bool AutoShutdownEnabled { get; set; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual double CurrentTime { get; }
public virtual bool IsMutedForAudio { get; set; }
public virtual bool IsMutedForHaptics { get; set; }
public virtual bool PlaysAudioOnly { get; set; }
public virtual bool PlaysHapticsOnly { get; set; }
public virtual System.Action ResetHandler { get; set; }
public virtual System.Action<CHHapticEngineStoppedReason> StoppedHandler { get; set; }
// methods
public virtual ICHHapticAdvancedPatternPlayer CreateAdvancedPlayer (CHHapticPattern pattern, out Foundation.NSError outError);
public virtual ICHHapticPatternPlayer CreatePlayer (CHHapticPattern pattern, out Foundation.NSError outError);
public static ICHHapticDeviceCapability GetHardwareCapabilities ();
public virtual void NotifyWhenPlayersFinished (System.Action<Foundation.NSError> finishedHandler);
public virtual System.Threading.Tasks.Task NotifyWhenPlayersFinishedAsync ();
public virtual bool PlayPattern (Foundation.NSData data, out Foundation.NSError outError);
public virtual bool PlayPattern (Foundation.NSUrl fileUrl, out Foundation.NSError outError);
public virtual UIntPtr RegisterAudioResource (Foundation.NSUrl resourceUrl, Foundation.NSDictionary options, out Foundation.NSError outError);
public virtual void Start (System.Action<Foundation.NSError> completionHandler);
public virtual bool Start (out Foundation.NSError outError);
public virtual System.Threading.Tasks.Task StartAsync ();
public virtual void Stop (System.Action<Foundation.NSError> completionHandler);
public virtual System.Threading.Tasks.Task StopAsync ();
public virtual bool UnregisterAudioResource (UIntPtr resourceId, out Foundation.NSError outError);
}[Serializable]
public enum CHHapticEngineFinishedAction {
LeaveEngineRunning = 2,
StopEngine = 1,
}[Serializable]
public enum CHHapticEngineStoppedReason {
ApplicationSuspended = 2,
AudioSessionInterrupt = 1,
EngineDestroyed = 5,
GameControllerDisconnect = 6,
IdleTimeout = 3,
NotifyWhenFinished = 4,
SystemError = -1,
}[Serializable]
public enum CHHapticErrorCode {
BadEventEntry = -4830,
BadParameterEntry = -4831,
EngineNotRunning = -4805,
EngineStartTimeout = -4808,
FileNotFound = -4851,
InsufficientPower = -4897,
InvalidAudioResource = -4824,
InvalidAudioSession = -4815,
InvalidEngineParameter = -4816,
InvalidEventDuration = -4823,
InvalidEventTime = -4822,
InvalidEventType = -4821,
InvalidParameterType = -4820,
InvalidPatternData = -4813,
InvalidPatternDictionary = -4814,
InvalidPatternPlayer = -4812,
InvalidTime = -4840,
MemoryError = -4899,
NotSupported = -4809,
OperationNotPermitted = -4806,
ResourceNotAvailable = -4825,
ServerInitFailed = -4810,
ServerInterrupted = -4811,
UnknownError = -4898,
}public class CHHapticEvent : Foundation.NSObject {
// constructors
protected CHHapticEvent (Foundation.NSObjectFlag t);
protected CHHapticEvent (ObjCRuntime.NativeHandle handle);
public CHHapticEvent (CHHapticEventType type, CHHapticEventParameter[] eventParams, double time);
public CHHapticEvent (UIntPtr resourceId, CHHapticEventParameter[] eventParams, double time);
public CHHapticEvent (CHHapticEventType type, CHHapticEventParameter[] eventParams, double time, double duration);
public CHHapticEvent (UIntPtr resourceId, CHHapticEventParameter[] eventParams, double time, double duration);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual double Duration { get; set; }
public virtual CHHapticEventParameter[] EventParameters { get; }
public virtual double RelativeTime { get; set; }
public virtual CHHapticEventType Type { get; }
}public class CHHapticEventParameter : Foundation.NSObject {
// constructors
protected CHHapticEventParameter (Foundation.NSObjectFlag t);
protected CHHapticEventParameter (ObjCRuntime.NativeHandle handle);
public CHHapticEventParameter (CHHapticEventParameterId parameterId, float value);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual CHHapticEventParameterId ParameterId { get; }
public virtual float Value { get; set; }
}[Serializable]
public enum CHHapticEventParameterId {
AttackTime = 2,
AudioBrightness = 9,
AudioPan = 8,
AudioPitch = 7,
AudioVolume = 6,
DecayTime = 3,
HapticIntensity = 0,
HapticSharpness = 1,
ReleaseTime = 4,
Sustained = 5,
}public static class CHHapticEventParameterIdExtensions {
// methods
public static Foundation.NSString GetConstant (this CHHapticEventParameterId self);
public static CHHapticEventParameterId GetValue (Foundation.NSString constant);
}[Serializable]
public enum CHHapticEventType {
AudioContinuous = 2,
AudioCustom = 3,
HapticContinuous = 1,
HapticTransient = 0,
}public static class CHHapticEventTypeExtensions {
// methods
public static Foundation.NSString GetConstant (this CHHapticEventType self);
public static CHHapticEventType GetValue (Foundation.NSString constant);
}public class CHHapticParameterCurve : Foundation.NSObject {
// constructors
protected CHHapticParameterCurve (Foundation.NSObjectFlag t);
protected CHHapticParameterCurve (ObjCRuntime.NativeHandle handle);
public CHHapticParameterCurve (CHHapticDynamicParameterId parameterId, CHHapticParameterCurveControlPoint[] controlPoints, double relativeTime);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual CHHapticParameterCurveControlPoint[] ControlPoints { get; }
public virtual CHHapticDynamicParameterId ParameterId { get; }
public virtual double RelativeTime { get; set; }
}public class CHHapticParameterCurveControlPoint : Foundation.NSObject {
// constructors
protected CHHapticParameterCurveControlPoint (Foundation.NSObjectFlag t);
protected CHHapticParameterCurveControlPoint (ObjCRuntime.NativeHandle handle);
public CHHapticParameterCurveControlPoint (double time, float value);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual double RelativeTime { get; set; }
public virtual float Value { get; set; }
}public class CHHapticPattern : Foundation.NSObject {
// constructors
protected CHHapticPattern (Foundation.NSObjectFlag t);
protected CHHapticPattern (ObjCRuntime.NativeHandle handle);
public CHHapticPattern (CHHapticPatternDefinition patternDefinition, out Foundation.NSError outError);
public CHHapticPattern (Foundation.NSDictionary patternDict, out Foundation.NSError outError);
public CHHapticPattern (Foundation.NSUrl url, out Foundation.NSError error);
public CHHapticPattern (CHHapticEvent[] events, CHHapticDynamicParameter[] parameters, out Foundation.NSError outError);
public CHHapticPattern (CHHapticEvent[] events, CHHapticParameterCurve[] parameterCurves, out Foundation.NSError outError);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual double Duration { get; }
// methods
public CHHapticPatternDefinition Export (out Foundation.NSError outError);
}public class CHHapticPatternDefinition : Foundation.DictionaryContainer {
// constructors
public CHHapticPatternDefinition ();
public CHHapticPatternDefinition (Foundation.NSDictionary dictionary);
// properties
public Foundation.NSDictionary Event { get; set; }
public double? EventDuration { get; set; }
public Foundation.NSArray EventParameters { get; set; }
public CHHapticEventType? EventType { get; set; }
public Foundation.NSString EventWaveformPath { get; set; }
public bool? EventWaveformUseVolumeEnvelope { get; set; }
public Foundation.NSDictionary Parameter { get; set; }
public Foundation.NSString ParameterId { get; set; }
public double? ParameterValue { get; set; }
public Foundation.NSArray Pattern { get; set; }
public double? Time { get; set; }
public double? Version { get; set; }
public Foundation.NSObject WeakParameterCurve { get; set; }
public Foundation.NSObject WeakParameterCurveControlPoints { get; set; }
}public interface ICHHapticAdvancedPatternPlayer : ICHHapticPatternPlayer, ObjCRuntime.INativeObject, System.IDisposable {
// properties
public virtual System.Action<Foundation.NSError> CompletionHandler { get; set; }
public virtual bool IsMuted { get; set; }
public virtual bool LoopEnabled { get; set; }
public virtual double LoopEnd { get; set; }
public virtual float PlaybackRate { get; set; }
// methods
public virtual bool Pause (double time, out Foundation.NSError outError);
public virtual bool Resume (double time, out Foundation.NSError outError);
public virtual bool Seek (double offsetTime, out Foundation.NSError outError);
}public interface ICHHapticDeviceCapability : ObjCRuntime.INativeObject, System.IDisposable {
// properties
public virtual bool SupportsAudio { get; }
public virtual bool SupportsHaptics { get; }
// methods
public virtual ICHHapticParameterAttributes GetAttributes (Foundation.NSString eventParameter, out Foundation.NSError outError);
public virtual ICHHapticParameterAttributes GetAttributes (Foundation.NSString eventParameter, string type, out Foundation.NSError outError);
}public interface ICHHapticParameterAttributes : ObjCRuntime.INativeObject, System.IDisposable {
// properties
public virtual float DefaultValue { get; }
public virtual float MaxValue { get; }
public virtual float MinValue { get; }
}public interface ICHHapticPatternPlayer : ObjCRuntime.INativeObject, System.IDisposable {
// properties
public virtual bool IsMuted { get; set; }
// methods
public virtual bool Cancel (out Foundation.NSError outError);
public virtual bool Schedule (CHHapticParameterCurve parameterCurve, double time, out Foundation.NSError outError);
public virtual bool Send (CHHapticDynamicParameter[] parameters, double time, out Foundation.NSError outError);
public virtual bool Start (double time, out Foundation.NSError outError);
public virtual bool Stop (double time, out Foundation.NSError outError);
}