ApsaraVideo VOD:Advanced features

Professional Competency Verification

Set the listener when your application starts or before you call any player API operations.

void premiumVeryfyCallback(AVPPremiumBizType biztype, bool isValid, NSString* errorMsg) {
    NSLog(@"onPremiumLicenseVerifyCallback: %d, isValid: %d, errorMsg: %@", biztype, isValid, errorMsg);
}

[AliPrivateService setOnPremiumLicenseVerifyCallback:premiumVeryfyCallback];

Here, AVPPremiumBizType is an enumeration of advanced features. When you use a related feature, the player verifies the license and returns the result through this callback. If isValid is false, errorMsg contains the reason for the failure.

Playback

/**
 @brief Alpha rendering mode. Supports alpha at the right, left, top, or bottom. The default value is none.
 @see AVPAlphaRenderMode
 */
/****
 @brief Set a rendering mode. Support alpha at right, left, top and bottom. Default value is none.
 @see AVPAlphaRenderMode
 */
@property(nonatomic) AVPAlphaRenderMode alphaRenderMode;

//--------------View usage-------------
// For the player's view, set a clear background color.
@property (weak, nonatomic) IBOutlet UIView *mediaPlayerView;
[self.aliplayerview setBackgroundColor:UIColor.clearColor];

//-----------AliPlayer usage-----------
// Set the alpha mode.
[self.player setAlphaRenderMode:AVP_RENDERMODE_ALPHA_AT_LEFT];
// Set the material corresponding to the alpha mode.
AVPUrlSource *source = [[AVPUrlSource alloc] urlWithString:@"https://alivc-player.oss-cn-shanghai.aliyuncs.com/video/%E4%B8%9A%E5%8A%A1%E9%9C%80%E6%B1%82%E6%A0%B7%E6%9C%AC/alpha%E9%80%9A%E9%81%93/alpha_left.mp4"];
[self.player setUrlSource:source];

// Optional: Clear the screen after playback completion to prevent visual artifacts.
#pragma mark -- AVPDelegate
- (void)onPlayerEvent:(AliPlayer *)player eventType:(AVPEventType)eventType {
    switch (eventType) {
        case AVPEventCompletion:
        {
            [player clearScreen];
        }
            break;
        //...
    }
}

[self.player setAutoPlay: YES];
[self.player prepare];

/**
 @brief Video render type, 0 means default render; 1 means mixed render. Default is 0.
 */
/****
 @brief video renderType, 0 means default render; 1 means mixed render.
 */
@property(nonatomic, assign) int videoRenderType;

AVPConfig *config = [self.player getConfig];
// Enable Metal rendering.
config.videoRenderType = 1;
[self.player setConfig:config];
[self.player prepare];

AVPConfig *config = [self.player getConfig];
config.disableVideo = YES;
[self.player setConfig:config];

// Enable hardware decoding. It is enabled by default.
self.player.enableHardwareDecoder = YES;

-(void)onPlayerEvent:(AliPlayer*)player eventWithString:(AVPEventWithString)eventWithString description:(NSString *)description {
    if (eventWithString == EVENT_SWITCH_TO_SOFTWARE_DECODER) {
        // Switched to software decoding.
    }
}

H.265 adaptive playback

// The application layer maintains a map of original URLs to backup URLs.
NSString* getBackupUrlCallback(AVPBizScene scene, AVPCodecType codecType, NSString* oriurl){
    NSMutableDictionary *globalMap = [AliPlayerViewController getGlobalBackupUrlMap];
    NSString *backupUrl = globalMap[oriurl];
    return backupUrl; 
}

[AliPlayerGlobalSettings setAdaptiveDecoderGetBackupURLCallback:getBackupUrlCallback];

AVPMediaInfo *info = [self.player getMediaInfo];
NSArray<AVPTrackInfo*>* tracks = info.tracks;

// Switch to a specific bitrate.
[self.player selectTrack:track.trackIndex];
// Enable adaptive bitrate switching.
[self.player selectTrack:SELECT_AVPTRACK_TYPE_VIDEO_AUTO];

- (void)onTrackChanged:(AliPlayer*)player info:(AVPTrackInfo*)info {
    if (info.trackType == AVPTRACK_TYPE_VIDEO) {
        // Rendition changed.
    }
    // etc
}

AVPConfig *config = [self.player getConfig];
config.maxAllowedAbrVideoPixelNumber = 921600;// Set the maximum allowed pixel count for ABR to 1280x720. The player will only switch to definitions with a pixel count less than or equal to this value.
[self.player setConfig:config];

Take a snapshot

// Snapshot callback.
- (void)onCaptureScreen:(AliPlayer *)player image:(UIImage *)image {
    // Process the snapshot.
}
// Take a snapshot of the current frame.
[self.player snapShot];

Preview

In combination with ApsaraVideo VOD configurations, you can implement a preview feature. This is supported for both VidSts and VidAuth (recommended) playback. For configuration instructions, see Preview videos.

AVPVidStsSource *source = [[AVPVidStsSource alloc] init];
....
VidPlayerConfigGenerator* vp = [[VidPlayerConfigGenerator alloc] init];
[vp setPreviewTime:20];// 20-second preview
source.playConfig = [vp generatePlayerConfig];// Set for the playback source
...

Set the Referer

// Get the configuration first.
AVPConfig *config = [self.player getConfig];
// Set the Referer.
config.referer = referer;
....// Other settings
// Set the configuration for the player.
[self.player setConfig:config];

Set the User-Agent

// Get the configuration first.
AVPConfig *config = [self.player getConfig];
// Set the User-Agent.
config.userAgent = userAgent;
....// Other settings
// Set the configuration for the player.
[self.player setConfig:config];

Configure network retry count and timeout

// Get the current configuration.
AVPConfig *config = [self.player getConfig];
// Specify the network timeout period. Unit: milliseconds.
config.networkTimeout = 5000;
// Specify the maximum number of retries upon a network timeout. The retry interval is the value of the networkTimeout parameter. A value of 0 indicates that no retry is performed. The application determines the retry policy. The default value is 2.
config.networkRetryCount = 2;
....// Configure other settings.
// Configure the settings for the player.
[self.player setConfig:config];

Configure cache and latency control

// Retrieve the configuration.
AVPConfig *config = [self.player getConfig];
// Specify the maximum latency. Note: This parameter is valid for only live streaming. If the latency is high, Player SDK synchronizes frames to ensure that the latency is within the specified limit.
config.maxDelayTime = 5000;
// Specify the maximum buffer duration. Unit: milliseconds. This parameter specifies the maximum duration of data that the player can buffer at a time.
config.maxBufferDuration = 50000;
// Specify the peak buffer duration. Unit: milliseconds. When the player loads data due to poor network conditions, the player stops loading after the duration of the buffered data reaches this value.
config.highBufferDuration = 3000;
// Specify the startup buffer duration. Unit: milliseconds. A smaller value indicates a shorter startup loading duration. However, the player may enter the loading status soon after the playback starts.
config.startBufferDuration = 500;
// Configure other settings.
// Apply the configuration to the player.
[self.player setConfig:config];

Set HTTP headers

// Retrieve the configuration.
AVPConfig *config = [self.player getConfig];
// Define the headers.
NSMutableArray *httpHeaders = [[NSMutableArray alloc] init];
// For example, configure a host when you use HTTPDNS.
[httpHeaders addObject:@"Host:example.com"];
// Configure the headers.
config.httpHeaders = httpHeaders;
....// Configure other settings.
// Configure the settings for the player.
[self.player setConfig:config];

Picture-in-Picture

Enable PiP

- (void)onPlayerEvent:(AliPlayer *)player eventType:(AVPEventType)eventType {
    switch (eventType) {
        case AVPEventPrepareDone:
        {
            [self.player setPictureInPictureEnable:YES];
        }
            break;
        default:
            break;
    }
}

Set the PiP delegate

The following code examples demonstrate common interactions between Picture-in-Picture (PiP) windows and player windows, including logic to display PiP pause, play, fast forward, fast backward, and replay buttons. For more information on delegate methods, see the Player SDK Demo — specifically, the AliPlayerPictureInPictureDelegate.h header file within the AliyunPlayer.framework folder.

1. Set the PiP delegate.

   /**
   * @brief Set the PiP delegate.
   */
   -(void) setPictureinPictureDelegate:(id<AliPlayerPictureInPictureDelegate>)delegate;
   
   
   // Set the PiP delegate.
   [self.player setPictureinPictureDelegate:self];

2. Add variables and implement the delegate interface.

   1. You can add a (global variable) to control the player’s state changes.

      #import "YourUIViewController.h"
      #import <AliyunPlayer/AliyunPlayer.h>
      
      @interface YourUIViewController () <AVPDelegate, AliPlayerPictureInPictureDelegate>
      // Player instance.
      @property (nonatomic, strong) AliPlayer *player;
      // Player view container.
      @property (nonatomic, strong) UIView *playerView;
      // Listen for whether PiP is currently paused.
      @property (nonatomic, assign) BOOL isPipPaused;
      // Listen for the current playback status of the player. Set it through the newStatus callback of the playback event status change listener.
      @property (nonatomic, assign) AVPStatus currentPlayerStatus;
      // Set the PiP controller. Set it in the callback method for when PiP is about to start. You need to actively set it to nil when the page is about to be destroyed. We recommend setting it.
      @property (nonatomic, weak) AVPictureInPictureController *pipController;
      // Listen for the current playback progress of the player. Set currentPosition to the value of the position parameter in the callback for the current video playback position.
      @property (nonatomic, assign) int64_t currentPosition;
      
      @end

      Note

      You must use the weak or assign modifier for pipController. If you use the assign modifier, make sure that you set the correct variables to null.

   2. Update the status of the PiP controller when you listen for the onPlayerStatusChanged event.

      - (void)onPlayerStatusChanged:(AliPlayer*)player oldStatus:(AVPStatus)oldStatus newStatus:(AVPStatus)newStatus {
          self.currentPlayerStatus = newStatus;
      
        if (_pipController) {
           [self.pipController invalidatePlaybackState];
         }
      }

   3. Update the status of the PiP controller when you listen for the onPlayerEvent event.

      - (void)onPlayerEvent:(AliPlayer*)player eventType:(AVPEventType)eventType {
          if (eventType == AVPEventCompletion) {
            if (_pipController) {
             self.isPipPaused = YES; // After playback ends, change the PiP status to paused.
             [self.pipController invalidatePlaybackState];
          }
        } else if (eventType == AVPEventSeekEnd) {
          // Seeking is complete.
            if (_pipController) {
             [self.pipController invalidatePlaybackState];
          }
        }
      }

   4. Set listeners.

      • Listen for the callback when PiP is about to start.

        /**
         @brief Picture-in-Picture is about to start.
         @param pictureInPictureController The Picture-in-Picture controller.
         */
        - (void)pictureInPictureControllerWillStartPictureInPicture:(AVPictureInPictureController *)pictureInPictureController {
            if (!_pipController) {
             self.pipController = pictureInPictureController;
          }
            self.isPipPaused = !(self.currentPlayerStatus == AVPStatusStarted);
          [pictureInPictureController invalidatePlaybackState];
        }

      • Listen for the callback when PiP is preparing to stop.

        /**
         @brief Picture-in-Picture is preparing to stop.
         @param pictureInPictureController The Picture-in-Picture controller.
         */
        - (void)pictureInPictureControllerWillStopPictureInPicture:(AVPictureInPictureController *)pictureInPictureController {
            self.isPipPaused = NO;
          [pictureInPictureController invalidatePlaybackState];
        }

      • Listen for the callback that instructs the delegate to restore the user interface before PiP stops.

        /**
         @brief Tells the delegate to restore the user interface before Picture-in-Picture stops.
         @param pictureInPictureController The Picture-in-Picture controller.
         @param completionHandler Call and pass YES to allow the system to finish restoring the player user interface.
         */
        - (void)pictureInPictureController:(AVPictureInPictureController *)pictureInPictureController restoreUserInterfaceForPictureInPictureStopWithCompletionHandler:(void (^)(BOOL restored))completionHandler {
            if (_pipController) {
              _pipController = nil;
          }
          completionHandler(YES);
        }

      • Listen for the callback that sets the current playable time range for PiP.

        /**
         @brief Notifies the Picture-in-Picture controller of the current playable time range.
         @param pictureInPictureController The Picture-in-Picture controller.
         @return The current playable time range.
         */
         - (CMTimeRange)pictureInPictureControllerTimeRangeForPlayback:(nonnull AVPictureInPictureController *)pictureInPictureController layerTime:(CMTime)layerTime{
            Float64 current64 = CMTimeGetSeconds(layerTime);
        
            Float64 start;
            Float64 end;
        
            if (currentPosition <= self.player.duration) {
                double curPostion = self.currentPosition / 1000.0;
                double duration = self.player.duration / 1000.0;
                double interval = duration - curPostion;
                start = current64 - curPostion;
                end = current64 + interval;
                CMTime t1 = CMTimeMakeWithSeconds(start, layerTime.timescale);
                CMTime t2 = CMTimeMakeWithSeconds(end, layerTime.timescale);
                return CMTimeRangeFromTimeToTime(t1, t2);
            } else {
                return CMTimeRangeMake(kCMTimeNegativeInfinity, kCMTimePositiveInfinity);
            }
        }

      • Listen for the callback that sets whether PiP is paused or playing.

        /**
         @brief Reflects the paused or playing state on the UI.
         @param pictureInPictureController The Picture-in-Picture controller.
         @return Paused or playing.
         */
        - (BOOL)pictureInPictureControllerIsPlaybackPaused:(nonnull AVPictureInPictureController *)pictureInPictureController{
            return self.isPipPaused;
        }

        Note

        This callback is triggered before PiP starts. Make sure that the return value of this callback is false at this time. Otherwise, PiP cannot be activated.

      • Listen for the callback when the user skips forward or backward to synchronize the playback progress to the player.

        /**
         @brief The fast forward or fast backward button is clicked.
         @param pictureInPictureController The Picture-in-Picture controller.
         @param skipInterval The time interval for fast forwarding or fast backwarding.
         @param completionHandler A closure that must be called to indicate that the seek operation is complete.
         */
         - (void)pictureInPictureController:(nonnull AVPictureInPictureController *)pictureInPictureController skipByInterval:(CMTime)skipInterval completionHandler:(nonnull void (^)(void))completionHandler {
            int64_t skipTime = skipInterval.value / skipInterval.timescale;
            int64_t skipPosition = self.currentPosition + skipTime * 1000;
            if (skipPosition < 0) {
                skipPosition = 0;
            } else if (skipPosition > self.player.duration) {
                skipPosition = self.player.duration;
            }
            [self.player seekToTime:skipPosition seekMode:AVP_SEEKMODE_INACCURATE];
            [pictureInPictureController invalidatePlaybackState];
        }

      • Listen for the callback when the pause or play button is clicked in PiP, and perform the required operations.

        /**
         @brief The pause button in Picture-in-Picture is clicked.
         @param pictureInPictureController The Picture-in-Picture controller.
         @param playing Whether it is playing.
         */
        - (void)pictureInPictureController:(nonnull AVPictureInPictureController *)pictureInPictureController setPlaying:(BOOL)playing {
            if (!playing){
              [self.player pause];
              self.isPipPaused = YES;
            } else {
              // Recommendation: If PiP playback is complete and needs to be replayed, you can additionally execute the code in the following if statement.
              if (self.currentPlayerStatus == AVPStatusCompletion) {
                 [self.player seekToTime:0 seekMode:AVP_SEEKMODE_ACCURATE];
              }
        
              [self.player start];
              self.isPipPaused = NO;
          }
          [pictureInPictureController invalidatePlaybackState];
        }

In-app Picture-in-Picture

By default, the Picture-in-Picture (PiP) feature operates outside the app. To implement in-app PiP, you can first use the following interface to determine whether PiP is enabled:

/**
 @brief Whether PiP is started.
 @param pictureInPictureController The PiP controller.
 @param isEnable Whether PiP is started.
 */
/****
 @brief pictureInPicture is enable or not
 @param pictureInPictureController picture in picture controller
 @param isEnable is enable or not
 */
- (void)pictureInPictureControllerIsPictureInPictureEnable:(nullable AVPictureInPictureController *)pictureInPictureController isEnable:(BOOL)isEnable;

When PiP is enabled, disable automatic activation and control it manually.

- (void) pictureInPictureControllerIsPictureInPictureEnable:(nullable AVPictureInPictureController *) pictureInPictureController isEnable:(BOOL) isEnable
{
    if (isEnable && pictureInPictureController) {
        _pipController = pictureInPictureController;
        // close pip auto start
        if (@available(iOS 15.0, *)) {
            _pipController.canStartPictureInPictureAutomaticallyFromInline = false;
        }
    } else {
        _pipController = NULL;
    }
}

- (void) switchPip:(bool) enable {
    if (_pipController == nil) {
        return;
    }
    if (enable) {
        // start pip
        [_pipController startPictureInPicture];
    } else {
        // close pip
        [_pipController stopPictureInPicture];
    }
}

// Set the AVPOutputAudioChannel enumeration value to switch channels.
// AVP_AUDIO_CHANNEL_NONE: Do not specify a channel. Play with the input source's audio channel. This is the default value.
// AVP_AUDIO_CHANNEL_LEFT: Switch to the left audio channel for playback.
// AVP_AUDIO_CHANNEL_RIGHT: Switch to the right audio channel for playback.
self.player.outputAudioChannel = AVP_AUDIO_CHANNEL_NONE;

/**
 @brief Set the background color of the video.
 @param color  the color
 */
/****
 @brief Set video background color
 @param color  the color
 */
-(void) setVideoBackgroundColor:(UIColor *)color;

// The parameter is an 8-digit hexadecimal value. The 8 digits are grouped into pairs, representing A (alpha/transparency), R (red), G (green), and B (blue) in order.
// For example, 0x0000ff00 represents green.
[self.player setVideoBackgroundColor:0x0000ff00]

/**
 @brief Play using the vid+playauth method. See https://www.alibabacloud.com/help/zh/vod/user-guide/use-playback-credentials-to-play-videos
 @param source The input type of AVPVidAuthSource.
 @see AVPVidAuthSource
 */
- (void)setAuthSource:(AVPVidAuthSource*)source;

VidPlayerConfigGenerator* gen = [[VidPlayerConfigGenerator alloc]init];
// Add the playDomain field. For the fields that can be added, see
// https://www.alibabacloud.com/help/zh/vod/developer-reference/api-vod-2017-03-21-getplayinfo
[gen addVidPlayerConfigByStringValue:@"playDomain" value: @"com.xxx.xxx"];
[source setPlayConfig:[gen generatePlayerConfig]];
[self.player setAuthSource:source]:

// A value of 1 enables background decoding. A value of 0 disables background decoding. The default value is 0.
[self.player setOption:ALLOW_DECODE_BACKGROUND valueInt:1];

// x.x.x must be the same as the version number of ApsaraVideo Player SDK.
pod 'AliPlayerSDK_iOS_VVC_CODEC_PLUGIN', 'x.x.x'

// x.x.x must be the same as the version number of the integrated SDK you are using.
pod 'AliVCSDK_Standard/AliPlayerSDK_iOS_VVC_CODEC', 'x.x.x'

[AliPlayerGlobalSettings enableCodecPlugin:@"vvc" valid:true];

/**
 @brief Set the callback for VidAuth source expiration notification.

 When the player detects that the current VidAuth source has expired, this method triggers a callback.
 VidAuth source expiration includes PlayAuth expiration and playback URL expiration.
 You can refresh the VidAuth source in the callback and submit the new VidAuth source object via `callback` to ensure stable and smooth playback.

 @param callback The callback block triggered when the VidAuth source expires.
 You can use this callback to return a valid `VidAuth` object to update the player.
 */
/****
 @brief Set the callback for VidAuth source expiration notification.

 This method is triggered when the player detects that the current VidAuth source has expired.
 You can refresh the VidAuth source within the callback and use the `callback` to return the updated VidAuth source,
 ensuring uninterrupted and smooth video playback.

 @param callback The callback block triggered when the VidAuth source expires.
 Use this callback to provide a valid `VidAuth` object to update the player.
 */
-(void)setOnVidAuthExpiredCallback:(void (^)(id expiredSource, id<AVPSourceRefreshCallback> callback))callback;

/**
 @protocol AVPSourceRefreshCallback
 @brief A protocol for handling playback source refresh results, which developers need to implement.

 This protocol notifies developers when the player requests playback source refresh, such as when a resource
 has expired or needs updating. The methods in this protocol are called to provide the refresh results to the developer,
 including success or failure.

 @note This protocol applies to URL source, VidAuth source, and similar scenarios requiring refresh logic.
 */
 /****
 @brief A protocol for handling playback source refresh results, which developers need to implement.

 This protocol notifies developers when the player requests playback source refresh, such as when a resource
 has expired or needs updating. The methods in this protocol are called to provide the refresh results to the developer,
 including success or failure.

 @note This protocol applies to URL source, VidAuth source, and similar scenarios requiring refresh logic.
 */
@protocol AVPSourceRefreshCallback <NSObject>

/**
 @brief Called by the player when the refresh operation succeeds.
 @param newSource The new playback source object containing the updated information.
 
 This method indicates that the refresh operation has been successfully completed. Developers need to pass
 the updated `newSource` back to the player so that it can load the latest resource.
 */
 /****
 @brief Called by the player when the refresh operation succeeds.
 
 @param newSource The new playback source object containing the updated information.

 This method indicates that the refresh operation has been successfully completed. Developers need to pass
 the updated `newSource` back to the player so that it can load the latest resource.
 */
- (void)onSuccess:(id)newSource;

/**
 @brief Called by the player when the refresh operation fails.
 @param errorMsg A string describing the reason for the failure.
 
 This method indicates that the refresh operation has failed. Developers can use `errorMsg` to capture failure
 details and handle subsequent processing accordingly.
 */
 /****
 @brief Called by the player when the refresh operation fails.
 
 @param errorMsg A string describing the reason for the failure.

 This method indicates that the refresh operation has failed. Developers can use `errorMsg` to capture failure
 details and handle subsequent processing accordingly.
 */
- (void)onError:(NSString *)errorMsg;

@end

[self.player setOnVidAuthExpiredCallback:^(id expiredSource, id<AVPSourceRefreshCallback> callback) {
    // Get AVPVidAuthSource
    if ([expiredSource isKindOfClass:[AVPVidAuthSource class]]) {

        // ------------------- User implementation begins -------------------
        // Call your own function to get a new PlayAuth from your app server.
        // clinetGetPlayAuthFunction is a sample function name. Replace it with your own implementation.
        [self clinetGetPlayAuthFunction:vid success:^(NSString* newPlayAuth){
            // 1. Callback for successful retrieval of new credentials
            [vidAuth setPlayAuth:newPlayAuth];
            // 2. Return the updated object to the player via the SDK callback
            [callback onSuccess:vidAuth];
        } failure:^(NSString* errorMsg) {
            // Callback for failed credential retrieval.
            // errorMsg contains detailed error information.
            [callback onError:errorMsg];
        }];
        // ------------------- User implementation ends -------------------
    }
}];

/**
 @brief Set the callback for URL source expiration notification.

 When the player detects that the current URL source has expired, this method triggers a callback.
 You can refresh the URL source in the callback and use `callback` to return the new URL source to ensure uninterrupted playback.

 @note For URL signing configuration, see the Alibaba Cloud documentation:
 https://www.alibabacloud.com/help/zh/vod/user-guide/configure-url-signing?spm=a2c4g.11186623.0.0.560c4140fGh8MW
 
 @param callback The callback block triggered when the URL source expires.
 You can use this callback to provide a valid `URLSource` object to update the player.
 */
 /****
 @brief Set the callback for URL source expiration notification.

 This method is triggered when the player detects that the current URL source has expired.
 You can refresh the URL source within the callback and use the `callback` to return the updated URL source,
 ensuring uninterrupted video playback.

 @param callback The callback block triggered when the URL source expires.
 Use this callback to provide a valid `URLSource` object to update the player.
 */
-(void)setOnURLSourceExpiredCallback:(void (^)(id expiredSource, id<AVPSourceRefreshCallback> callback))callback;

/**
 @protocol AVPSourceRefreshCallback
 @brief A protocol for handling playback source refresh results, which developers need to implement.

 This protocol notifies developers when the player requests playback source refresh, such as when a resource
 has expired or needs updating. The methods in this protocol are called to provide the refresh results to the developer,
 including success or failure.

 @note This protocol applies to URL source, VidAuth source, and similar scenarios requiring refresh logic.
 */
 /****
 @brief A protocol for handling playback source refresh results, which developers need to implement.

 This protocol notifies developers when the player requests playback source refresh, such as when a resource
 has expired or needs updating. The methods in this protocol are called to provide the refresh results to the developer,
 including success or failure.

 @note This protocol applies to URL source, VidAuth source, and similar scenarios requiring refresh logic.
 */
@protocol AVPSourceRefreshCallback <NSObject>

/**
 @brief Called by the player when the refresh operation succeeds.
 @param newSource The new playback source object containing the updated information.
 
 This method indicates that the refresh operation has been successfully completed. Developers need to pass
 the updated `newSource` back to the player so that it can load the latest resource.
 */
 /****
 @brief Called by the player when the refresh operation succeeds.
 
 @param newSource The new playback source object containing the updated information.

 This method indicates that the refresh operation has been successfully completed. Developers need to pass
 the updated `newSource` back to the player so that it can load the latest resource.
 */
- (void)onSuccess:(id)newSource;

/**
 @brief Called by the player when the refresh operation fails.
 @param errorMsg A string describing the reason for the failure.
 
 This method indicates that the refresh operation has failed. Developers can use `errorMsg` to capture failure
 details and handle subsequent processing accordingly.
 */
 /****
 @brief Called by the player when the refresh operation fails.
 
 @param errorMsg A string describing the reason for the failure.

 This method indicates that the refresh operation has failed. Developers can use `errorMsg` to capture failure
 details and handle subsequent processing accordingly.
 */
- (void)onError:(NSString *)errorMsg;

@end

[self.player setOnURLSourceExpiredCallback:^(id expiredSource, id<AVPSourceRefreshCallback> callback) {
    // Get AVPUrlSource
    if ([expiredSource isKindOfClass:[AVPUrlSource class]]) {
        AVPUrlSource *expiredUrlSource = (AVPUrlSource *)expiredSource;
        NSString *expiredUrl = [expiredUrlSource.playerUrl absoluteString];

        // Check if auth_key is included
        if (![expiredUrl containsString:@"auth_key="]) {
            return;
        }

        // 1. Extract the original URL from the expired URL
        NSRange authKeyQuestionRange = [expiredUrl rangeOfString:@"?auth_key="];
        NSRange authKeyAmpersandRange = [expiredUrl rangeOfString:@"&auth_key="];

        NSInteger authKeyIndex = NSNotFound;
        if (authKeyQuestionRange.location != NSNotFound) {
            authKeyIndex = authKeyQuestionRange.location;
        } else if (authKeyAmpersandRange.location != NSNotFound) {
            authKeyIndex = authKeyAmpersandRange.location;
        }

        NSString *originalUrl = nil;
        if (authKeyIndex != NSNotFound) {
            originalUrl = [expiredUrl substringToIndex:authKeyIndex];
        } else {
            // If auth_key is not found, treat the entire URL as the original URL
            originalUrl = expiredUrl;
        }

        // 2. Prepare new authentication parameters: authKey and expiration time
        // If the class member authKey is valid, use it
        NSString *key = (self.authKey.length > 0) ? self.authKey : @"";
        if (!NOT_EMPTY(key)) {
            [callback onError:@"REFRESH_ERROR:key fail"];
            return;
        }       
        
        // If the class member validTime is valid, use it; otherwise, use the default value
        NSTimeInterval validTime = (self.validTime > 0) ? self.validTime : 3600; // Default 3600 seconds
        NSTimeInterval newExpireTime = [[NSDate date] timeIntervalSince1970] + validTime;

         // 3. Generate a new authenticated URL using CdnAuthUtil (Method A)
        NSString *newAuthUrl = [CdnAuthUtil aAuthWithUri:originalUrl key:key exp:newExpireTime];
        AVPUrlSource *resultSource = [[AVPUrlSource alloc] urlWithString:newAuthUrl];

        // 4. Callback handling
        if (newAuthUrl) {
            [callback onSuccess:resultSource];
        } else {
            [callback onError:@"REFRESH_ERROR:refresh fail"];
        }
    }
}];

#import "CdnAuthUtil.h"
#import <CommonCrypto/CommonDigest.h>

@implementation CdnAuthUtil

#pragma mark - Auth Method A
+ (NSString *)aAuthWithUri:(NSString *)uri key:(NSString *)key exp:(NSTimeInterval)exp {
    NSDictionary *components = [self matchUri:uri];
    if (!components) return nil;

    NSString *scheme = components[@"scheme"];
    NSString *host = components[@"host"];
    NSString *path = components[@"path"];
    NSString *args = components[@"args"];

    NSString *rand = @"0";
    NSString *uid = @"0";

    NSString *sstring = [NSString stringWithFormat:@"%@-%lld-%@-%@-%@", path, (long long)exp, rand, uid, key];
    NSString *hashvalue = [self md5sum:sstring];
    NSString *authKey = [NSString stringWithFormat:@"%lld-%@-%@-%@", (long long)exp, rand, uid, hashvalue];

    if (args.length > 0) {
        return [NSString stringWithFormat:@"%@%@%@%@&auth_key=%@", scheme, host, path, args, authKey];
    } else {
        return [NSString stringWithFormat:@"%@%@%@%@?auth_key=%@", scheme, host, path, args, authKey];
    }
}

#pragma mark - Private Helper: MD5
+ (NSString *)md5sum:(NSString *)src {
    const char *cStr = [src UTF8String];
    unsigned char result[CC_MD5_DIGEST_LENGTH];
    CC_MD5(cStr, (unsigned int)strlen(cStr), result);

    NSMutableString *hexString = [NSMutableString string];
    for (int i = 0; i < CC_MD5_DIGEST_LENGTH; i++) {
        [hexString appendFormat:@"%02x", result[i]];
    }
    return hexString.copy;
}

#pragma mark - Private Helper: Regex Match
+ (NSDictionary *)matchUri:(NSString *)uri {
    NSError *error = nil;
    NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:@"^(https?://)?([^/?]+)(/[^?]*)?(\\?.*)?$"
                                  options:0
                                  error:&error];
    if (error) {
        NSLog(@"Regex error: %@", error.localizedDescription);
        return nil;
    }

    NSTextCheckingResult *match = [regex firstMatchInString:uri
                                   options:0
                                   range:NSMakeRange(0, uri.length)];
    if (!match) return nil;

    __block NSString *scheme = nil, *host = nil, *path = nil, *args = nil;

    void (^setStringFromRange)(NSInteger, NSString**) = ^(NSInteger idx, NSString **outStr) {
        NSRange range = [match rangeAtIndex:idx];
        if (range.location != NSNotFound && range.length > 0) {
            *outStr = [uri substringWithRange:range];
        } else {
            *outStr = nil;
        }
    };

    setStringFromRange(1, &scheme);
    setStringFromRange(2, &host);
    setStringFromRange(3, &path);
    setStringFromRange(4, &args);

    // Default value handling
    if (!scheme) scheme = @"http://";
    if (!path) path = @"/";

    return @{
        @"scheme": scheme,
        @"host": host,
        @"path": path,
        @"args": args ?: @""
        };
}
@end

Performance

Set the playback scenario

Setting the playback scenario automatically configures optimal parameters (including buffer settings and feature toggles) while preserving custom parameters set via the setConfig interface (custom settings take precedence).

API examples

/**
 @brief Set player scenario.
 @param scene Player scenario.
 @see AVPScenario
 */
/****
 @brief Set player scene.
 @param scene Player scene.
 @see AVPScene
 */
-(void) setPlayerScene:(AVPScene)scene;

Playback scenarios

typedef enum _AVPScene {
    /**
     * Scenario: None
     */
    /****
     * scene none
     */
    SceneNone,
    /**
     * Long-video scenario: Applies to videos longer than 30 minutes
     */
    /****
     * long scene: apply to more than 30min
     */
    SceneLong,
    /**
     * Medium-video scenario: Applies to videos 5–30 minutes long
     */
    /****
     * middle scene: apply to 5min-30min
     */
    SceneMedium,
    /**
     * Short-video scenario: Applies to videos up to 5 minutes long
     */
    /****
     * short scene: apply to 0s-5min
     */
    SceneShort,
    /**
     * Live-streaming scenario
     */
    /****
     * live scene
     */
    SceneLive,
    /**
     * Ultra-low-latency live-streaming scenario
     */
    /****
     * RTS live scene
     */
    SceneRTSLive
} AVPScene;

Usage

// Set short-video scenario
[self.player setPlayerScene:SceneShort];

// Set medium-video scenario
[self.player setPlayerScene:SceneMedium]; 

// Set long-video scenario
[self.player setPlayerScene:SceneLong];  

// Set live-streaming scenario
[self.player setPlayerScene:SceneLive];   

Pre-rendering

[self.player setOption:ALLOW_PRE_RENDER valueInt:1];

Local cache

The iOS Player SDK provides local caching to improve startup speed, seek speed, and reduce stuttering for repeated video playback, while saving bandwidth.

Enable local cache

/**
 * Enable local cache. After enabling, it caches to local files.
 * @param enable: Local cache toggle. true: enable, false: disable. Default is disable.
 * @param maxBufferMemoryKB: Deprecated since V5.4.7.1. No effect.
 * @param localCacheDir: Required. Absolute path to the local cache directory.
 */
[AliPlayerGlobalSettings enableLocalCache:true maxBufferMemoryKB:1024 localCacheDir:@""];

/**
 @brief Settings for automatic clearing of local cache files.
 @param expireMin: Deprecated since V5.4.7.1. No effect.
 @param maxCapacityMB: Maximum cache capacity in megabytes. Default is 20 GB. During cleanup, if the total cache capacity exceeds this size, the oldest cache files will be deleted one by one, sorted by the last cache time of the cacheItem, until the capacity is less than or equal to the maximum cache capacity.
 @param freeStorageMB: Minimum free disk space in megabytes. Default is 0. During cleanup, similar to the maximum cache capacity, if the current disk space is less than this value, cache files will also be deleted one by one according to the rules until freeStorage is greater than or equal to this value or all caches are cleared.
 */
[AliPlayerGlobalSettings setCacheFileClearConfig:0 maxCapacityMB:0 freeStorageMB:0];

/**
 * Callback to get the hash value of the loaded URL. Used as a unique ID for the URL. You must ensure that each URL is different.
 */

// You need to implement this function yourself and pass the function pointer to setCacheUrlHashCallback.
static NSString *CaheUrlHashHandle(NSString *url) {
    return @"xxx";
}

[AliPlayerGlobalSettings setCacheUrlHashCallback:&CaheUrlHashHandle];

Enable or disable local cache for a single URL

// Get the configuration first.
AVPConfig *config = [self.player getConfig];
// Whether to enable local cache for the playback URL. Default is true. When local cache is enabled globally via AliPlayerGlobalSettings and also enabled here (set to true), the local cache for this URL takes effect. If set to false here, the local cache for this URL is disabled.
config.enableLocalCache = false;
....// Other settings

// Set the configuration for the player.
[self.player setConfig:config];

[AliPlayerGlobalSettings enableLocalCache:true];

Preloading

The iOS Player SDK provides preloading, an upgrade to local caching that downloads part of a video into the cache before playback starts, further improving startup speed.

[AliPlayerGlobalSettings enableNetworkBalance:false];

1. Enable the local cache feature as described in Local cache.

2. Set the source.

   VidAuth (recommended)

   AVPVidAuthSource* vidAuthSource = [[AVPVidAuthSource alloc] init];
   [vidAuthSource setVid:@"Vid information"]; // Required. The video ID (VideoId).
   [vidAuthSource setPlayAuth:@"<yourPlayAuth>"]; // Required. The playback credential. You need to call the GetVideoPlayAuth operation of ApsaraVideo VOD to generate it.
   [vidAuthSource setRegion:@"Access region"]; // For Player SDK V5.5.5.0 and later, this parameter is deprecated. You do not need to set the region. The player will automatically parse the region. For Player SDK versions earlier than 5.5.5.0, this parameter is required. The access region of ApsaraVideo VOD. The default is cn-shanghai.
   [vidAuthSource setQuality:@"Selected definition"]; // "AUTO" represents adaptive bitrate.

   VidSts

   AVPVidStsSource* vidStsSource = [[AVPVidStsSource alloc] init];
   [vidStsSource setVid: @"Vid information"]; // Required. The video ID (VideoId).
   [vidStsSource setRegion:@"Access region"]; // Required. The access region of ApsaraVideo VOD. The default is cn-shanghai.
   [vidStsSource setSecurityToken: @"<yourSecurityToken>"]; // Required. The STS security token. You need to call the AssumeRole operation of STS to generate it.
   [vidStsSource setAccessKeySecret: @"<yourAccessKeySecret>"]; // Required. The AccessKey secret of the temporary STS AccessKey pair. You need to call the AssumeRole operation of STS to generate it.
   [vidStsSource setAccessKeyId: @"<yourAccessKeyId>"]; // Required. The AccessKey ID of the temporary STS AccessKey pair. You need to call the AssumeRole operation of STS to generate it.
   [vidStsSource setQuality:@"Selected definition"]; // "AUTO" represents adaptive bitrate.

   UrlSource

   NSString* url = @"Playback URL"; // Required. The playback URL. It can be a third-party VOD URL or a playback URL from ApsaraVideo VOD.
   AVPUrlSource* urlSource = [[AVPUrlSource alloc]urlWithString:url];

3. Set task parameters.

   Note

   This applies only to multi-bitrate videos. You can choose any one of setDefaultBandWidth, setDefaultResolution, or setDefaultQuality.

   AVPPreloadConfig *config = [[AVPPreloadConfig alloc]init];
   // Set the preload bitrate for a multi-bitrate stream.
   [config setDefaultBandWidth:400000];
   // Set the preload resolution for a multi-bitrate stream.
   [config setDefaultResolution:640 * 480];
   // Set the preload quality for a multi-bitrate stream.
   [config setDefaultQuality:@"FD"];
   // Set the preload duration.
   [config setDuration:1000];

4. Add a task listener.

   Expand to view the code

   @interface YourViewController () <OnPreloadListener>
   
   @property(nonatomic,strong) AliMediaLoaderV2* vodMedialoader; // Preloader
   @property(nonatomic,strong) AVPVidAuthSource* vidSource; // vidAuth data source
   @property(nonatomic,strong) AVPUrlSource* urlSource; // url data source
   @property(nonatomic,strong) AVPVidStsSource* vidStsSource; // vidSts data source
   
   @end
   
   @implementation YourViewController
   
   - (void)onCompleted:(NSString *)taskId urlOrVid:(NSString *)urlOrVid {
       NSLog(@"Current task (%@) completed:%@", taskId,urlOrVid);
   }
   
   - (void)onError:(NSString *)taskId urlOrVid:(NSString *)urlOrVid errorModel:(AVPErrorModel *)errorModel {
       NSLog(@"An exception occurred:%@", urlOrVid);
   }
   
   - (void)onCanceled:(NSString *)taskId urlOrVid:(NSString *)urlOrVid {
       NSLog(@"Task canceled:%@", urlOrVid);
   }
   
   @end

5. Build the task, add it to the MediaLoaderV2 instance, and start preloading.

   VidAuth (recommended)

   // Build the preload task.
   AVPPreloadTask* mPreloadTask = [[AVPPreloadTask alloc]initWithVidAuthSource:vidAuthSource preloadConfig:config];
   // Get the MediaLoaderV2 instance.
   AliMediaLoaderV2* vodMedialoader = [AliMediaLoaderV2 shareInstance];
   // Add the task and start preloading.
   NSString* taskId = [vodMedialoader addTask:mPreloadTask listener:self];

   VidSts

   // Build the preload task.
   AVPPreloadTask* mPreloadTask = [[AVPPreloadTask alloc]initWithVidStsSource:vidStsSource preloadConfig:config];
   // Get the MediaLoaderV2 instance.
   AliMediaLoaderV2* vodMedialoader = [[AliMediaLoaderV2 alloc]init];
   // Add the task and start preloading.
   NSString* taskId = [vodMedialoader addTask:mPreloadTask listener:self];

   UrlSource

   // Build the preload task.
   AVPPreloadTask* mPreloadTask = [[AVPPreloadTask alloc]initWithUrlSource:urlSource preloadConfig:config];
   // Get the MediaLoaderV2 instance.
   AliMediaLoaderV2* vodMedialoader = [[AliMediaLoaderV2 alloc]init];
   // Add the task and start preloading.
   NSString* taskId = [vodMedialoader addTask:mPreloadTask listener:self];

6. Optional: Manage tasks.

   [vodMedialoader cancelTask:taskId];// Cancel the preload task with the specified task ID.
   [vodMedialoader pauseTask:taskId];// Pause the preload task with the specified task ID.
   [vodMedialoader resumeTask:taskId];// Resume the preload task with the specified task ID.

7. Optional: Delete loaded files.

   You can delete loaded files as needed to save space. The SDK does not provide a delete interface. You need to delete the files in the loading directory in the app.

Dynamic preloading

The dynamic preloading strategy lets you balance playback experience and cost by controlling the cache of the current video and the number of preloaded items.

// Enable recommended configuration and dynamic preload
[self.listPlayer setScene:AVP_SHORT_VIDEO];

// Configure base preload duration
// Set preload duration to 1000ms
AVPPreloadConfig *config = [[AVPPreloadConfig alloc] init];
config.preloadDuration = 1000;
[self.listPlayer updatePreloadConfig:config];

// Configure preload count, supports bidirectional
// 1 for previous preload count, 3 for next preload count
[self.listPlayer setPreloadCount:1 nextCount:3];

// Configure the decreasing offset for dynamic preload
[self.listPlayer enableStrategy:AVP_STRATEGY_DYNAMIC_PRELOAD enable:true];
[self.listPlayer setStrategyParam:AVP_STRATEGY_DYNAMIC_PRELOAD strategyParam:@"{\"algorithm\": \"sub\",\"offset\": \"200\"}"];

typedef enum AVPMultiBitratesMode : NSUInteger {
    /**
     * Default configuration. Play and preload the default bitrate.
     */
    /****
     * default mode, play and preload default bitrate of a stream
     */
    AVPMultiBitratesMode_Default = 0,
    /**
     * First frame priority configuration. The video starts playing at the bitrate that has finished preloading.
     */
    /****
     * First frame cost (FC) priority, decrease first frame cost. only play bitrate of the hls stream which has been preloaded.
     */
    AVPMultiBitratesMode_FCPrio = 1,
    /**
     * Balances first frame and smooth playback. The video bitrate is consistent before and after switching (moveToNext), and first frame performance is also considered.
     */
    /****
     * First frame and play smooth, play the same bitrate before and after moveToNext
     */
    AVPMultiBitratesMode_FC_AND_SMOOTH = 2,
    /**
     * Smooth playback priority configuration. The video starts playing at the bitrate of the previous video.
     */
    /****
     * Play Smooth priority, play the same bitrate before and after moveToNext.
     */
    AVPMultiBitratesMode_SmoothPrio = 3,
} AVPMultiBitratesMode;

// Select the multi-bitrate loading mode.
[self.listPlayer->SetMultiBitratesMode(preLoadMode)];

// (Optional) Select the startup bitrate.
[self.listPlayer setDefaultBandWidth:defaultBandWidth];

// (Optional) In the preparedone callback, select the ABR mode.
-(void)onPlayerEvent:(AliPlayer*)player eventType:(AVPEventType)eventType {
    switch (eventType) {
        case AVPEventPrepareDone: {
            [self.listPlayer selectTrack:-1];
        }
            break;
        case AVPEventFirstRenderedStart: {
        }
            break;
        default:
            break;
    }
}

Get the download speed

- (void)onCurrentDownloadSpeed:(AliPlayer *)player speed:(int64_t)speed{
  intspeed_=speed;
}

Network features

// Enable enhanced HTTPDNS.
[AliPlayerGlobalSettings enableEnhancedHttpDns:YES];
// Optional. Add a domain name for HTTPDNS pre-resolution.
[[AliDomainProcessor shareInstance] addPreResolveDomain:@"player.***alicdn.com"];

[AliPlayerGlobalSettings setUseHttp2:true];

// Domain format is host[:port]. Port is optional. Multiple domains are separated by semicolons (;).
// Global setting.
// Each time the full interface is set, the current string is used (add for more, delete for less). An empty string stops pre-connection.
[AliPlayerGlobalSettings setOption:SET_PRE_CONNECT_DOMAIN value: @"domain1;domain2"];

Video download

The iOS Player SDK provides a video download feature for ApsaraVideo VOD content, with standard and secure modes.

• Standard download: The downloaded video is not encrypted and can be played by third-party players.

• Secure download: The downloaded video is encrypted and can only be played by ApsaraVideo Player.

Usage notes

• The video download feature is supported only by the VidSts and VidAuth methods.

• Enable and configure the download mode in the ApsaraVideo VOD console. For more information, see Offline download.

• Video downloads support resumable transfers.

Procedure

1. Optional: Configure the encryption verification file for secure download. Configure this only for secure download. Standard download does not require configuration.

   Note

   Ensure the encryption verification file matches your app information. Otherwise, the video download fails.

   If you use secure download, configure the key file generated in the ApsaraVideo VOD console in the Player SDK. The key file is used to decrypt and verify the video for download and playback. For more information about how to generate the key file, see Enable secure download.

   We recommend configuring the key file once in the Application.

   NSString *encrptyFilePath = [[NSBundle mainBundle] pathForResource:@"encryptedApp" ofType:@"dat"];
   [AliPrivateService initKey:encrptyFilePath];

2. Create and set up the downloader.

   Example:

   AliMediaDownloader *downloader = [[AliMediaDownloader alloc] init];
   [downloader setSaveDirectory:self.downLoadPath];
   [downloader setDelegate:self];

3. Set event listeners.

   The downloader provides multiple listeners.

   -(void)onPrepared:(AliMediaDownloader *)downloader mediaInfo:(AVPMediaInfo *)info {
       // The download item is successfully prepared.
   }
   -(void)onError:(AliMediaDownloader *)downloader errorModel:(AVPErrorModel *)errorModel {
       // A download error occurred.
   }
   -(void)onDownloadingProgress:(AliMediaDownloader *)downloader percentage:(int)percent {
       // Download progress percentage.
   }
   -(void)onProcessingProgress:(AliMediaDownloader *)downloader percentage:(int)percent {
       // Processing progress percentage.
   }
   -(void)onCompletion:(AliMediaDownloader *)downloader {
       // The download is successful.
   }

4. Prepare the download source.

   You can call the prepare method to prepare a download source. Supported source types include VidStsSource and VidAuthSource.

   • VidSts

     // Create VidSts.
     AVPVidStsSource* stsSource = [[AVPVidStsSource alloc] init];
     stsSource.region = @"Access region"; // The access region of ApsaraVideo VOD. The default is cn-shanghai.
     stsSource.vid = @"Vid information"; // The video ID (VideoId).
     stsSource.securityToken = @"<yourSecurityToken>"; // The STS security token. You need to call the AssumeRole operation of STS to generate it.
     stsSource.accessKeySecret = @"<yourAccessKeySecret>"; // The AccessKey secret of the temporary STS AccessKey pair. You need to call the AssumeRole operation of STS to generate it.
     stsSource.accessKeyId = @"<yourAccessKeyId>"; // The AccessKey ID of the temporary STS AccessKey pair. You need to call the AssumeRole operation of STS to generate it.
     
     // If you have enabled HLS standard encryption parameter pass-through in the VOD console, and the default parameter name is MtsHlsUriToken, you need to set the config and pass it into the vid. See below.
     // If you have not enabled HLS standard encryption parameter pass-through in the VOD console, you do not need to integrate the following code.
     VidPlayerConfigGenerator* vp = [[VidPlayerConfigGenerator alloc] init];
     [vp setHlsUriToken:yourMtsHlsUriToken];
     stsSource.playConfig = [vp generatePlayerConfig];
     // Prepare the download source.
     [downloader prepareWithVid:stsSource];

   • VidAuth

     // Create VidAuth.
     AVPVidAuthSource *authSource = [[AVPVidAuthSource alloc] init];
     authSource.vid = @"Vid information"; // The video ID (VideoId).
     authSource.playAuth = @"<yourPlayAuth>"; // The playback credential. You need to call the GetVideoPlayAuth operation of ApsaraVideo VOD to generate it.
     authSource.region = @"Access region"; // For Player SDK V5.5.5.0 and later, this parameter is deprecated. You do not need to set the region. The player will automatically parse the region. For Player SDK versions earlier than 5.5.5.0, this parameter is required. The access region of ApsaraVideo VOD. The default is cn-shanghai.
     // If you have enabled HLS standard encryption parameter pass-through in the VOD console, and the default parameter name is MtsHlsUriToken, you need to set the config and pass it into the vid. See below.
     // If you have not enabled HLS standard encryption parameter pass-through in the VOD console, you do not need to integrate the following code.
     VidPlayerConfigGenerator* vp = [[VidPlayerConfigGenerator alloc] init];
     [vp setHlsUriToken:yourMtsHlsUriToken];
     authSource.playConfig = [vp generatePlayerConfig];
     // Prepare the download source.
     [downloader prepareWithVid:authSource];

   Note

   If you enable parameter pass-through for HLS encryption in the ApsaraVideo VOD console, the default parameter is MtsHIsUriToken. For more information, see Parameter pass-through for HLS encryption. Then, set the MtsHIsUriToken value to the ApsaraVideo VOD source by following the preceding code.

5. Select a download item after preparation succeeds.

   After the download source is prepared, the onPrepared method is called. The returned TrackInfo contains information about each video track, such as its definition. You can then select a track to download. The following sample code provides an example:

   -(void)onPrepared:(AliMediaDownloader *)downloader mediaInfo:(AVPMediaInfo *)info {
       NSArray<AVPTrackInfo*>* tracks = info.tracks;
       // For example, download the first TrackInfo.
       [downloader selectTrack:[tracks objectAtIndex:0].trackIndex];
   }

6. Update the download source and start the download.

   VidSts or VidAuth may expire before the download. Therefore, we recommend updating the download source before you start the download.

   // Update the download source.
   [downloader updateWithVid:vidSource]
   // Start the download.
   [downloader start];

7. Release the downloader after the download succeeds or fails.

   After the download is successful, call destroy to release the downloader.

   [self.downloader destroy];
   self.downloader = nil;

Encrypted playback

ApsaraVideo VOD supports HLS standard encryption, Alibaba Cloud proprietary encryption, and DRM encryption. For instructions, see Play an encrypted video.

Native RTS playback

The SDK integrates the Native RTS SDK to implement low-latency live streaming. For more information, see Implement RTS-based stream pulling on iOS.

References

• API reference

• Error codes

• iOS player FAQ