ApsaraVideo VOD:Recursos avançados

Verificação de recursos avançados

Defina o listener na inicialização do aplicativo ou antes de chamar qualquer API do player:

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

[AliPrivateService setOnPremiumLicenseVerifyCallback:premiumVeryfyCallback];

Neste exemplo, AVPPremiumBizType é uma enumeração de recurso avançado. Ao utilizar um recurso avançado, o player verifica a licença e retorna o resultado por meio deste callback. Se isValid for falso, errorMsg conterá o motivo da falha.

Reprodução

/**
 @brief Alpha rendering mode. Supports alpha at the right, left, top, or bottom. The 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 asset that matches the alpha mode.
AVPUrlSource *source = [[AVPUrlSource alloc] urlWithString:@"https://alivc-player.oss-cn-shanghai.aliyuncs.com/video/business_needs_sample/alpha_channel/alpha_left.mp4"];
[self.player setUrlSource:source];

// Optional: If you encounter visual artifacts after playback completes, you can clear the screen.
#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 Specifies the video render type. Valid values: 0 (default renderer) and 1 (mixed renderer). Default: 0.
 */
@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 (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.
    }
}

Reprodução adaptativa H.265

// The application layer should maintain a dictionary to map original URLs to their 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 stream.
[self.player selectTrack:track.trackIndex];
// Enable adaptive bitrate streaming.
[self.player selectTrack:SELECT_AVPTRACK_TYPE_VIDEO_AUTO];

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

AVPConfig *config = [self.player getConfig];
config.maxAllowedAbrVideoPixelNumber = 921600; // Set the maximum pixel count for ABR to 921600 (1280 * 720). This ensures that the player only switches to definitions with a pixel count less than or equal to this value.
[self.player setConfig:config];

Snapshot

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

Prévia

O ApsaraVideo Player SDK para iOS suporta um recurso de prévia quando configurado com o ApsaraVideo VOD. O SDK suporta reprodução tanto com VidSts quanto com VidAuth. VidAuth é o método recomendado. Para mais informações, consulte Prévia de vídeos.

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

Definir Referer

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

User-Agent

// Get the current configuration.
AVPConfig *config = [self.player getConfig];
// Set the User-Agent.
config.userAgent = userAgent;
//... other settings
// Apply the configuration to the player.
[self.player setConfig:config];

Configurar contagem de tentativas de rede e timeout

// Get the configuration.
AVPConfig *config = [self.player getConfig];
// Set the network timeout in milliseconds.
config.networkTimeout = 5000;
// Set the maximum number of retries. The retry interval is determined by networkTimeout. A value of 0 disables retries, allowing the application to implement its own retry policy. The default is 2.
config.networkRetryCount = 2;
//... Other settings
// Apply the configuration to the player.
[self.player setConfig:config];

Controle de cache e latência

// Retrieve the configuration.
AVPConfig *config = [self.player getConfig];
// The maximum latency in milliseconds. Note: This parameter is for live streaming only. If latency becomes high, the Player SDK synchronizes frames to keep it within this limit.
config.maxDelayTime = 5000;
// The maximum duration (in milliseconds) of data that the player can buffer.
config.maxBufferDuration = 50000;
// The high buffer duration in milliseconds. When network conditions are poor, the player stops loading data once the buffer reaches this duration.
config.highBufferDuration = 3000;
// The startup buffer duration in milliseconds. A smaller value results in a faster startup speed but may cause stuttering shortly after playback starts.
config.startBufferDuration = 500;
// Other settings.
// Apply the configuration to the player.
[self.player setConfig:config];

Definir cabeçalho HTTP

// Get the configuration.
AVPConfig *config = [self.player getConfig];
// Define the headers.
NSMutableArray *httpHeaders = [[NSMutableArray alloc] init];
// For example, set the Host header when you use HTTPDNS.
[httpHeaders addObject:@"Host:example.com"];
// Set the headers.
config.httpHeaders = httpHeaders;
....// Other settings.
// Apply the configuration to the player.
[self.player setConfig:config];

Picture-in-picture

Ativar PiP

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

Definir o delegate PiP

Os exemplos de código a seguir demonstram interações comuns entre as janelas Picture-in-Picture (PiP) e do player. Eles cobrem a exibição de controles de reprodução como pausa, play, avanço rápido e retrocesso, além da implementação da lógica de replay. Para uma referência completa dos métodos do delegate, consulte o arquivo de cabeçalho AliPlayerPictureInPictureDelegate.h, localizado em AliyunPlayer.framework dentro da pasta SDK do demo do player SDK.

1. Defina o delegate Picture-in-Picture.

   /**
   * @brief Sets the delegate for Picture-in-Picture events.
   */
   -(void) setPictureinPictureDelegate:(id<AliPlayerPictureInPictureDelegate>)delegate;
   
   // Set the Picture-in-Picture delegate.
   [self.player setPictureinPictureDelegate:self];

2. Adicione propriedades e implemente os métodos do delegate.

   1. Adicione propriedades ao seu view controller para gerenciar o estado do player e da janela Picture-in-Picture.

      #import "YourUIViewController.h"
      #import <AliyunPlayer/AliyunPlayer.h>
      
      @interface YourUIViewController () <AVPDelegate, AliPlayerPictureInPictureDelegate>
      // The player instance.
      @property (nonatomic, strong) AliPlayer *player;
      // The container view for the player.
      @property (nonatomic, strong) UIView *playerView;
      // Tracks whether the Picture-in-Picture window is paused.
      @property (nonatomic, assign) BOOL isPipPaused;
      // Tracks the current playback status of the player, updated by the onPlayerStatusChanged:oldStatus:newStatus: callback.
      @property (nonatomic, assign) AVPStatus currentPlayerStatus;
      // A weak reference to the picture-in-picture controller. This is set in the pictureInPictureControllerWillStartPictureInPicture: callback and should be set to nil before the view controller is deallocated. Using a weak reference is recommended.
      @property (nonatomic, weak) AVPictureInPictureController *pipController;
      // Tracks playback progress, updated by the 'position' parameter in the playback progress callback.
      @property (nonatomic, assign) int64_t currentPosition;
      
      @end

      Nota

      A propriedade pipController deve ser declarada com um atributo weak ou assign para evitar ciclos de retenção. Se você usar assign, defina manualmente a propriedade como nil no momento apropriado.

   2. No seu método delegate onPlayerStatusChanged:, notifique o controlador picture-in-picture para atualizar seu estado.

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

   3. No seu método delegate onPlayerEvent:, atualize o estado do Picture-in-Picture em resposta aos eventos de reprodução.

      - (void)onPlayerEvent:(AliPlayer*)player eventType:(AVPEventType)eventType {
          if (eventType == AVPEventCompletion) {
            if (_pipController) {
             self.isPipPaused = YES; // When playback finishes, set the PiP state to paused.
             [self.pipController invalidatePlaybackState];
          }
        } else if (eventType == AVPEventSeekEnd) {
          // The seek operation is complete.
            if (_pipController) {
             [self.pipController invalidatePlaybackState];
          }
        }
      }

   4. Implemente os métodos do delegate.

      • Implemente o callback para quando o Picture-in-Picture estiver prestes a começar.

        /**
         @brief Tells the delegate that 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];
        }

      • Implemente o callback para quando o Picture-in-Picture estiver prestes a parar.

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

      • Implemente o callback para restaurar a UI antes que o Picture-in-Picture pare.

        /**
         @brief Tells the delegate to restore the user interface before Picture-in-Picture stops.
         @param pictureInPictureController The picture-in-picture controller.
         @param completionHandler A completion handler to call with YES to allow the system to complete the restoration.
         */
        - (void)pictureInPictureController:(AVPictureInPictureController *)pictureInPictureController restoreUserInterfaceForPictureInPictureStopWithCompletionHandler:(void (^)(BOOL restored))completionHandler {
            if (_pipController) {
              _pipController = nil;
          }
          completionHandler(YES);
        }

      • Implemente o callback que fornece o intervalo de tempo reproduzível.

        /**
         @brief Asks the delegate for 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);
            }
        }

      • Implemente o callback que informa se a reprodução está pausada.

        /**
         @brief Asks the delegate whether playback is currently paused.
         @param pictureInPictureController The picture-in-picture controller.
         @return A Boolean value indicating whether playback is paused.
         */
        - (BOOL)pictureInPictureControllerIsPlaybackPaused:(nonnull AVPictureInPictureController *)pictureInPictureController{
            return self.isPipPaused;
        }

        Nota

        Este callback é invocado antes do início do Picture-in-Picture. Ele deve retornar false neste ponto para que a janela PiP seja iniciada. Retornar true impede o início do Picture-in-Picture.

      • Implemente o callback para lidar com as ações de avançar e retroceder a partir dos controles do Picture-in-Picture.

        /**
         @brief Tells the delegate that the user has requested to skip forward or backward.
         @param pictureInPictureController The picture-in-picture controller.
         @param skipInterval The time interval to skip.
         @param completionHandler A completion handler that you must call after 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];
        }

      • Implemente o callback para lidar com as ações de play e pause a partir dos controles do Picture-in-Picture.

        /**
         @brief Tells the delegate that the user has toggled the play/pause button.
         @param pictureInPictureController The picture-in-picture controller.
         @param playing A Boolean value indicating whether playback should start.
         */
        - (void)pictureInPictureController:(nonnull AVPictureInPictureController *)pictureInPictureController setPlaying:(BOOL)playing {
            if (!playing){
              [self.player pause];
              self.isPipPaused = YES;
            } else {
              // Tip: If you want the play button to restart the video after playback completes, add the following block.
              if (self.currentPlayerStatus == AVPStatusCompletion) {
                 [self.player seekToTime:0 seekMode:AVP_SEEKMODE_ACCURATE];
              }
        
              [self.player start];
              self.isPipPaused = NO;
          }
          [pictureInPictureController invalidatePlaybackState];
        }

Picture-in-picture no aplicativo

O Picture-in-picture é externo ao aplicativo por padrão. Para implementar o picture-in-picture dentro do aplicativo, primeiro chame a seguinte interface para verificar se o picture-in-picture está ativo:

/**
 @brief Tells the delegate whether picture-in-picture is enabled.
 @param pictureInPictureController The picture-in-picture controller reporting its state.
 @param isEnable `YES` if picture-in-picture is enabled; `NO` otherwise.
 */
- (void)pictureInPictureControllerIsPictureInPictureEnable:(nullable AVPictureInPictureController *)pictureInPictureController isEnable:(BOOL)isEnable;

Para desativar a inicialização automática e mudar para a ativação manual enquanto o picture-in-picture está em execução, use o seguinte código de exemplo:

- (void) pictureInPictureControllerIsPictureInPictureEnable:(nullable AVPictureInPictureController *) pictureInPictureController isEnable:(BOOL) isEnable
{
    if (isEnable && pictureInPictureController) {
        _pipController = pictureInPictureController;
        // Disable 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 {
        // Stop pip.
        [_pipController stopPictureInPicture];
    }
}

// Set the output audio channel using an AVPOutputAudioChannel enumeration value.
// AVP_AUDIO_CHANNEL_NONE: Plays the original audio channels from the input source. This is the default value.
// AVP_AUDIO_CHANNEL_LEFT: Plays only the left audio channel.
// AVP_AUDIO_CHANNEL_RIGHT: Plays only the right audio channel.
self.player.outputAudioChannel = AVP_AUDIO_CHANNEL_NONE;

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

// The parameter is an 8-digit hexadecimal value in ARGB format (alpha, red, green, blue).
// For example, 0x0000ff00 represents green.
[self.player setVideoBackgroundColor:0x0000ff00]

/**
 @brief Play a video by using the video ID and playback credential (PlayAuth). For more information, see: https://www.alibabacloud.com/help/en/vod/user-guide/use-playback-credentials-to-play-videos
 @param source An AVPVidAuthSource object.
 @see AVPVidAuthSource
 */
- (void)setAuthSource:(AVPVidAuthSource*)source;

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

// Set to 1 to enable background decoding or 0 to disable it. Default: 0.
[self.player setOption:ALLOW_DECODE_BACKGROUND valueInt:1];

// Replace x.x.x with the version of your Player SDK.
pod 'AliPlayerSDK_iOS_VVC_CODEC_PLUGIN', 'x.x.x'

// Replace x.x.x with the version of your all-in-one SDK.
pod 'AliVCSDK_Standard/AliPlayerSDK_iOS_VVC_CODEC', 'x.x.x'

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

/**
 @brief Sets the callback for VidAuth source expiration notifications.

 This callback is triggered when the player detects that the current VidAuth source has expired. A VidAuth source expires if its PlayAuth or playback URL has expired.
 You can refresh the VidAuth source in this callback and pass the new object via the `callback` parameter to ensure smooth playback.

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

/**
 @protocol AVPSourceRefreshCallback
 @brief A protocol for handling the results of a source refresh, which you must implement.

 This protocol notifies your application when the player requests a source refresh, such as when a resource
 has expired or needs to be updated. The methods in this protocol are called to provide the refresh results,
 including success or failure.

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

/**
 @brief Called by the player when the refresh operation succeeds.
 
 @param newSource The new source object containing the updated information.

 This method indicates that the refresh operation has been successfully completed. You must pass
 the updated `newSource` back to the player so that it can load the new 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. You can use `errorMsg` to capture failure
 details and handle the error accordingly.
 */
- (void)onError:(NSString *)errorMsg;

@end

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

        // ------------------- Start of user implementation -------------------
        // Call your custom function to retrieve a new PlayAuth from your app server.
        // clinetGetPlayAuthFunction is a sample function name. Replace it with your actual implementation.
        [self clinetGetPlayAuthFunction:vidAuth.vid success:^(NSString* newPlayAuth){
            // 1. In the success callback, after retrieving the new credential:
            [vidAuth setPlayAuth:newPlayAuth];
            // 2. Pass the updated source object back to the player via the SDK's callback.
            [callback onSuccess:vidAuth];
        } failure:^(NSString* errorMsg) {
            // In the failure callback.
            // errorMsg contains details about the error.
            [callback onError:errorMsg];
        }];
        // ------------------- End of user implementation -------------------
    }
}];

/**
 @brief Sets the callback for URL source expiration notifications.

 This callback is triggered when the player detects that the current URL source has expired.
 You can refresh the URL source in this callback and return the new URL source via the `callback` parameter to ensure continuous playback.

 @note For more information about how to configure URL signing, see the Alibaba Cloud documentation:
 https://www.alibabacloud.com/help/en/vod/user-guide/configure-url-signing
 
 @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.
 */
-(void)setOnURLSourceExpiredCallback:(void (^)(id expiredSource, id<AVPSourceRefreshCallback> callback))callback;

/**
 @protocol AVPSourceRefreshCallback
 @brief A protocol for handling the results of a source refresh, which you must implement.

 This protocol notifies your application when the player requests a source refresh, such as when a resource
 has expired or needs to be updated. The methods in this protocol are called to provide the refresh results,
 including success or failure.

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

/**
 @brief Called by the player when the refresh operation succeeds.
 
 @param newSource The new source object containing the updated information.

 This method indicates that the refresh operation has been successfully completed. You must pass
 the updated `newSource` back to the player so that it can load the new 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. You can use `errorMsg` to capture failure
 details and handle the error accordingly.
 */
- (void)onError:(NSString *)errorMsg;

@end

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

        // Check if the URL contains "auth_key".
        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, assume the entire URL is the original URL.
            originalUrl = expiredUrl;
        }

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

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

        // 4. Handle the callback.
        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);

    // Handle default values.
    if (!scheme) scheme = @"http://";
    if (!path) path = @"/";

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

// x.x.x must match the version of the player SDK.
pod 'AliPlayerSDK_iOS_AUDIO_ENHANCE_FILTER', 'x.x.x'

[player setFilterValid:@"audioEnhance" valid:YES];  // Enable
[player setFilterValid:@"audioEnhance" valid:NO];   // Disable

AVPFilterConfig *filterConfig = [[AVPFilterConfig alloc] init];
AVPFilter *filterItem = [[AVPFilter alloc] initWithTarget:@"audioEnhance"];
AVPFilterOptions *opts = [[AVPFilterOptions alloc] init];
// Surround sound
[opts setOptions:@"enable_surround" value:@YES];
[opts setOptions:@"surround_effect_type" value:@"3DSurround"]; // The type must be set when you first enable surround sound.
// Dialogue enhancement
[opts setOptions:@"enable_dialoguenhance" value:@YES];
[opts setOptions:@"dialoguenhance_voice" value:@(1.0)]; // Range: 1.0 to 10.0. The voice level must be set when you first enable dialogue enhancement.
// Volume normalization
[opts setOptions:@"enable_normalizer" value:@YES];

[filterItem setOptions:opts];
[filterConfig addFilter:filterItem];
[player setFilterConfig:filterConfig];

AVPFilterOptions *opts = [[AVPFilterOptions alloc] init];
[opts setOptions:@"enable_surround" value:@YES];
[opts setOptions:@"surround_effect_type" value:@"3DSurround"]; // The type can only be set when enabling surround sound for the first time. It is ignored on subsequent calls because the filter is already initialized.
[player updateFilterConfig:@"audioEnhance" options:opts];

Desempenho

Definir uma cena do player

Definir uma cena do player aplica automaticamente os parâmetros ideais para esse cenário, como configurações de buffer e alternância de recursos. Parâmetros personalizados definidos com o método setConfig substituem os padrões da cena.

Exemplo de API

/**
 @brief Sets the player scene.
 @param scene The player scene.
 @see AVPScene
 */
-(void) setPlayerScene:(AVPScene)scene;

Cenas do player

typedef enum _AVPScene {
    /**
     * No specific scene is set.
     */
    SceneNone,
    /**
     * Long video scene, suitable for videos over 30 minutes.
     */
    SceneLong,
    /**
     * Medium video scene, suitable for videos between 5 and 30 minutes.
     */
    SceneMedium,
    /**
     * Short video scene, suitable for videos up to 5 minutes.
     */
    SceneShort,
    /**
     * Live streaming scene.
     */
    SceneLive,
    /**
     * RTS live scene.
     */
    SceneRTSLive
} AVPScene;

Uso

// Set the short video scene.
[self.player setPlayerScene:SceneShort];

// Set the medium video scene.
[self.player setPlayerScene:SceneMedium]; 

// Set the long video scene.
[self.player setPlayerScene:SceneLong];  

// Set the live streaming scene.
[self.player setPlayerScene:SceneLive];   

Pré-renderização

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

Cache local

O Alibaba Cloud Player SDK para iOS fornece um recurso de cache local. Este recurso melhora a velocidade de inicialização e a velocidade de busca, reduz travamentos e economiza tráfego de rede durante reproduções repetidas.

Ativar cache local

/**
 * Enables the local cache. When enabled, content is cached to local files.
 * @param enable A boolean value that specifies whether to enable the local cache. true: enabled, false: disabled. Default value: false.
 * @param maxBufferMemoryKB This parameter is deprecated in v5.4.7.1 and later and has no effect.
 * @param localCacheDir The directory for local cache files. You must specify an absolute path.
 */
[AliPlayerGlobalSettings enableLocalCache:true maxBufferMemoryKB:1024 localCacheDir:@""];

/**
 @brief Configures the automatic cleanup of local cache files.
 @param expireMin This parameter is deprecated in v5.4.7.1 and later and has no effect.
 @param maxCapacityMB The maximum cache size in MB. Default value: 20 GB. During cleanup, if the total cache size exceeds this limit, the oldest cache items are deleted one by one until the total size is within the limit.
 @param freeStorageMB The minimum free disk space in MB. Default value: 0. During cleanup, if the available disk space is less than this value, cache files are deleted one by one until the free space is equal to or greater than this value, or until all cached files are deleted.
 */
[AliPlayerGlobalSettings setCacheFileClearConfig:0 maxCapacityMB:0 freeStorageMB:0];

/**
 * A callback to get the hash value of a URL. This value is used as the unique ID for the URL. You must ensure that each URL has a unique hash value.
 */

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

[AliPlayerGlobalSettings setCacheUrlHashCallback:&CaheUrlHashHandle];

Ativar ou desativar cache para uma URL

// Get the configuration.
AVPConfig *config = [self.player getConfig];
// Specifies whether to enable local caching for the playback URL. Default value: true.
// To enable local caching for this URL, both this setting and the global setting in AliPlayerGlobalSettings must be enabled.
// If this is set to false, local caching is disabled for this URL.
config.enableLocalCache = false;
....// Other settings

// Apply the configuration to the player.
[self.player setConfig:config];

[AliPlayerGlobalSettings enableLocalCache:true];

Pré-carregamento

O Alibaba Cloud Player SDK para iOS fornece um recurso de pré-carregamento, que é um aprimoramento do cache local. O pré-carregamento baixa uma parte de um vídeo para o cache antes do início da reprodução, melhorando a velocidade de inicialização.

[AliPlayerGlobalSettings enableNetworkBalance:false];

1. Ative o recurso de cache local conforme descrito em Cache local.

2. Defina a fonte de dados.

   VidAuth (recomendado)

   AVPVidAuthSource* vidAuthSource = [[AVPVidAuthSource alloc] init];
   [vidAuthSource setVid:@"your_video_id"]; // Required. The video ID.
   [vidAuthSource setPlayAuth:@"<yourPlayAuth>"]; // Required. The playback credential. You must call the GetVideoPlayAuth operation of ApsaraVideo for VOD to generate the credential.
   [vidAuthSource setRegion:@"your_region"]; // This parameter is deprecated in SDK v5.5.5.0 and later. The player automatically parses the region. For earlier versions, this parameter is required and defaults to cn-shanghai.
   [vidAuthSource setQuality:@"AUTO"]; // "AUTO" enables adaptive bitrate streaming.

   VidSts

   AVPVidStsSource* vidStsSource = [[AVPVidStsSource alloc] init];
   [vidStsSource setVid: @""]; // Required. The video ID.
   [vidStsSource setRegion:@""]; // Required. The region where ApsaraVideo VOD is activated. Default value: cn-shanghai.
   [vidStsSource setSecurityToken: @"<yourSecurityToken>"]; // Required. The STS security token. You must call the AssumeRole API operation of STS to obtain the token.
   [vidStsSource setAccessKeySecret: @"<yourAccessKeySecret>"]; // Required. The AccessKey secret of the temporary STS AccessKey pair. You must call the AssumeRole API operation of STS to obtain the AccessKey secret.
   [vidStsSource setAccessKeyId: @"<yourAccessKeyId>"]; // Required. The AccessKey ID of the temporary STS AccessKey pair. You must call the AssumeRole API operation of STS to obtain the AccessKey ID.
   [vidStsSource setQuality:@""]; // "AUTO" specifies adaptive bitrate streaming.

   UrlSource

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

3. Defina os parâmetros da tarefa.

   Nota

   Esses parâmetros aplicam-se apenas a vídeos de múltiplas taxas de bits. Você precisa definir apenas um entre setDefaultBandWidth, setDefaultResolution e 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. Adicione um listener de tarefa.

   Exemplo de código

   @interface YourViewController () <OnPreloadListener>
   
   @property(nonatomic,strong) AliMediaLoaderV2* vodMedialoader; // The preloader.
   @property(nonatomic,strong) AVPVidAuthSource* vidSource; // The VidAuth data source.
   @property(nonatomic,strong) AVPUrlSource* urlSource; // The UrlSource data source.
   @property(nonatomic,strong) AVPVidStsSource* vidStsSource; // The 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 error occurred: %@", urlOrVid);
   }
   
   - (void)onCanceled:(NSString *)taskId urlOrVid:(NSString *)urlOrVid {
       NSLog(@"Task canceled: %@", urlOrVid);
   }
   
   @end

5. Construa a tarefa, adicione-a à instância MediaLoaderV2 e inicie o pré-carregamento.

   VidAuth (recomendado)

   // 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. Opcional: Gerencie tarefas.

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

7. Opcional: Exclua arquivos carregados.

   Para economizar espaço, você pode excluir arquivos em cache. Como o Alibaba Cloud Player SDK para iOS não fornece uma interface de exclusão, você deve excluir manualmente os arquivos do diretório de cache dentro do seu aplicativo.

Pré-carregamento dinâmico

A estratégia de pré-carregamento dinâmico permite controlar o cache para o vídeo atual e o número de vídeos a serem pré-carregados. Isso ajuda a equilibrar a experiência de reprodução com o custo.

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

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

// Configure the number of items to preload. This supports preloading in both directions.
// 1 is the number of previous items to preload, and 3 is the number of next items to preload.
[self.listPlayer setPreloadCount:1 nextCount:3];

// Configure the decreasing offset for dynamic preloading.
[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. Plays and preloads the default bitrate.
     */
    AVPMultiBitratesMode_Default = 0,
    /**
     * Prioritizes a fast time to first frame. The player starts by playing the bitrate that has finished preloading.
     */
    AVPMultiBitratesMode_FCPrio = 1,
    /**
     * Balances a fast time to first frame with smooth playback. The player attempts to play the same bitrate before and after a `moveToNext` call.
     */
    AVPMultiBitratesMode_FC_AND_SMOOTH = 2,
    /**
     * Prioritizes smooth playback. The player attempts to start the next video at the same bitrate as the previous one.
     */
    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 onPlayerEvent callback for AVPEventPrepareDone, select the adaptive bitrate (ABR) mode.
-(void)onPlayerEvent:(AliPlayer*)player eventType:(AVPEventType)eventType {
    switch (eventType) {
        case AVPEventPrepareDone: {
            [self.listPlayer selectTrack:-1];
        }
            break;
        case AVPEventFirstRenderedStart: {
        }
            break;
        default:
            break;
    }
}

Velocidade de download

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

Recursos de rede

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

[AliPlayerGlobalSettings setUseHttp2:true];

// Get the current configuration.
AVPConfig *config = [self.player getConfig];
// Enable HTTP/3 requests.
config.enableHttp3 = YES;
//... other settings
// Apply the configuration to the current player instance.
[self.player setConfig:config];

// The domain format is host[:port]. The port is optional. Use semicolons (;) to separate multiple domain names.
// Global setting.
// This is an absolute setting. Each time you call this method, the new string replaces the previous one. An empty string disables pre-connection.
[AliPlayerGlobalSettings setOption:SET_PRE_CONNECT_DOMAIN value: @"domain1;domain2"];

Plugins pagos

Download de vídeo

O ApsaraVideo Player SDK para iOS permite baixar conteúdo do ApsaraVideo VOD para reprodução offline. O SDK oferece dois modos de download: download padrão e download seguro.

• Download padrão: Os dados de vídeo baixados não são criptografados pela Alibaba Cloud e podem ser reproduzidos usando players de terceiros.

• Download seguro: Os dados de vídeo baixados são criptografados pela Alibaba Cloud. Eles não podem ser reproduzidos por players de terceiros e só podem ser reproduzidos usando o ApsaraVideo Player.

Uso

• O recurso de download de vídeo está disponível apenas para fontes VidSts e VidAuth.

• Para usar o recurso de download de vídeo, você deve ativar e configurar o modo de download no console do ApsaraVideo VOD. Para mais informações, consulte download offline.

• O recurso de download de vídeo suporta downloads retomáveis.

Procedimento

1. Opcional: Configure o arquivo de chave para download seguro. Esta etapa é necessária apenas para download seguro.

   Nota

   Certifique-se de que as informações no arquivo de chave configurado correspondam às informações do seu aplicativo. Caso contrário, o download do vídeo falhará.

   Se você usar o modo de download seguro, deverá configurar o ApsaraVideo Player SDK com o arquivo de chave gerado no console do ApsaraVideo VOD. Este arquivo é usado para descriptografia e verificação durante o download e a reprodução do vídeo. Para instruções sobre como gerar o arquivo de chave, consulte Ativar download seguro.

   Execute esta configuração apenas uma vez no seu aplicativo, conforme mostrado no exemplo a seguir:

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

2. Crie e configure o downloader.

   O código a seguir fornece um exemplo:

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

3. Defina os listeners de eventos.

   O downloader suporta múltiplos listeners de eventos. O código a seguir fornece um exemplo:

   -(void)onPrepared:(AliMediaDownloader *)downloader mediaInfo:(AVPMediaInfo *)info {
       // A download item is successfully prepared.
   }
   -(void)onError:(AliMediaDownloader *)downloader errorModel:(AVPErrorModel *)errorModel {
       // An error occurred during download.
   }
   -(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 a fonte de download.

   Chame o método prepare para preparar a fonte de download. Fontes VidSts e VidAuth são suportadas. O código a seguir fornece um exemplo:

   • VidSts

     // Create a VidSts source.
     AVPVidStsSource* stsSource = [[AVPVidStsSource alloc] init];
     stsSource.region = @"your_region"; // Your ApsaraVideo VOD service region. Default value: cn-shanghai.
     stsSource.vid = @"your_video_id"; // The video ID.
     stsSource.securityToken = @"<yourSecurityToken>"; // The STS security token. To get this token, call the STS AssumeRole operation.
     stsSource.accessKeySecret = @"<yourAccessKeySecret>"; // The AccessKey secret of the temporary STS credential. To get this secret, call the STS AssumeRole operation.
     stsSource.accessKeyId = @"<yourAccessKeyId>"; // The AccessKey ID of the temporary STS credential. To get this ID, call the STS AssumeRole operation.
     
     // If you have enabled parameter pass-through for HLS encryption in the ApsaraVideo VOD console
     // and the default parameter name is MtsHlsUriToken, you must set the config and pass it to the VidSts source.
     // If this feature is not enabled, you can skip the following code.
     VidPlayerConfigGenerator* vp = [[VidPlayerConfigGenerator alloc] init];
     [vp setHlsUriToken:yourMtsHlsUriToken];
     stsSource.playConfig = [vp generatePlayerConfig];
     // Prepare the download source.
     [downloader prepareWithVid:stsSource];

   • VidAuth

     // Create a VidAuth source.
     AVPVidAuthSource *authSource = [[AVPVidAuthSource alloc] init];
     authSource.vid = @"your_video_id"; // The video ID.
     authSource.playAuth = @"<yourPlayAuth>"; // The playback credential. To get this credential, call the ApsaraVideo VOD GetVideoPlayAuth operation.
     authSource.region = @"your_region"; // Deprecated in ApsaraVideo Player SDK V5.5.5.0 and later because the player automatically parses the region.
     // Required for earlier versions.
     // Your ApsaraVideo VOD service region. Default value: cn-shanghai.
     // If you have enabled parameter pass-through for HLS encryption in the ApsaraVideo VOD console
     // and the default parameter name is MtsHlsUriToken, you must set the config and pass it to the VidAuth source.
     // If this feature is not enabled, you can skip the following code.
     VidPlayerConfigGenerator* vp = [[VidPlayerConfigGenerator alloc] init];
     [vp setHlsUriToken:yourMtsHlsUriToken];
     authSource.playConfig = [vp generatePlayerConfig];
     // Prepare the download source.
     [downloader prepareWithVid:authSource];

   Nota

   Se você ativar a passagem de parâmetros para criptografia HLS no console do ApsaraVideo VOD e o nome do parâmetro padrão for MtsHlsUriToken, deverá definir o valor MtsHlsUriToken na fonte de download conforme mostrado no código acima. Para mais informações, consulte passagem de parâmetros para criptografia HLS.

5. Selecione uma faixa de vídeo após a preparação da fonte.

   Após a preparação da fonte de download, o método onPrepared é chamado. O parâmetro mediaInfo do callback contém informações sobre cada faixa de vídeo disponível, como qualidade de vídeo. Selecione uma faixa para baixar. O código a seguir fornece um exemplo:

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

6. Atualize a fonte de download e inicie o download.

   Para evitar que as credenciais VidSts e VidAuth expirem, recomendamos atualizar as informações da fonte antes de iniciar o download. O código a seguir fornece um exemplo:

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

7. Libere o downloader após a conclusão ou falha do download.

   Chame o método destroy para liberar o downloader.

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

Reprodução criptografada

O ApsaraVideo VOD suporta criptografia padrão HLS, criptografia proprietária da Alibaba Cloud e criptografia DRM. Vídeo ao vivo suporta apenas criptografia DRM. Para mais informações, consulte Reprodução criptografada.

Reprodução RTS nativa

O iOS player SDK integra o Native RTS SDK para permitir streaming ao vivo de baixa latência. Para mais informações, consulte Implementar pull de stream baseado em RTS no iOS.

Referências

• API

• Códigos de erro móvel

• FAQ do player iOS