ApsaraVideo VOD:Fonctionnalités avancées

import com.aliyun.private_service.PrivateService;

PrivateService.setOnPremiumLicenseVerifyCallback(new PrivateService.OnPremiumLicenseVerifyCallback() {
    @Override
    public void onPremiumLicenseVerifyCallback(PrivateService.PremiumBizType type, boolean isValid, String errorMsg) {
        Log.d(TAG, "onPremiumLicenseVerifyCallback: " + type + " isValid: " + isValid + " errorMsg: " + errorMsg);
    }
});

Lecture de vidéos avec transparence

/**
 * Set alpha render mode.
 *
 * @param alphaRenderMode The specified alpha render mode. See {@link AlphaRenderMode}.
 */
abstract public void setAlphaRenderMode(AlphaRenderMode alphaRenderMode);

//--------------View usage-------------
// For View, transparency must be set.
//TextureView
TextureView aliplayerView; // View used for playback.
aliplayerView.setOpaque(false);

//SurfaceView
SurfaceView aliplayerView; // View used for playback.
aliplayerView.getHolder().setFormat(PixelFormat.TRANSLUCENT);
aliplayerView.setZOrderOnTop(true); // Place SurfaceView at the top of the display window.

//-----------AliPlayer usage-----------
// Set alpha mode.
aliPlayer.setAlphaRenderMode(IPlayer.AlphaRenderMode.RENDER_MODE_ALPHA_AT_RIGHT);
// Set the asset corresponding to the alpha mode.
UrlSource urlSource = new UrlSource();
urlSource.setUri("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_right.mp4");
aliPlayer.setDataSource(urlSource);
aliPlayer.setOnCompletionListener(new IPlayer.OnCompletionListener() {
    @Override
    public void onCompletion() {
        // Optional: If transition issues occur after single-instance playback completes, clear the screen.
        aliPlayer.clearScreen();
    }
}
aliPlayer.setAutoPlay(true);
aliPlayer.prepare();

Le SDK Player Android permet d'ajouter et de changer des sous-titres externes aux formats SRT, SSA, ASS et VTT.

1. Créez une vue pour afficher les sous-titres.

   Créez différentes vues selon le format des sous-titres.

   Développer pour voir le code

   // For displaying SRT and VTT subtitles.
   SubtitleView subtitleView = new SubtitleView(getContext());
   // For player V7.6.0 and later, we recommend using VttSubtitleView to display SRT and VTT subtitles.
   VttSubtitleView vttSubtitleView = new VttSubtitleView(getContext());
   // For displaying ASS and SSA subtitles.
   AssSubtitleView assSubtitleView = new AssSubtitleView(getContext());
   // Add the subtitle view to the layout.
   viewGroup.addView(assSubtitleView);

   Lors de l'intégration du lecteur version 7.6.0 ou ultérieure et de l'utilisation de VttSubtitleView pour afficher les sous-titres SRT et VTT, configurez l'écouteur suivant :

   // Required for player 7.6.0 and later.
   mAliPlayer.setOnVideoSizeChangedListener(new IPlayer.OnVideoSizeChangedListener() {
       @Override
       public void onVideoSizeChanged(int width, int height) {
           int viewWidth = getWidth();
           int viewHeight = getHeight();
           IPlayer.ScaleMode mode = mVideoListPlayer.getScaleMode();
           SubTitleBase.VideoDimensions videoDimensions = SubTitleBase.getVideoDimensionsWhenRenderChanged(width, height, viewWidth, viewHeight, mode);
           vttSubtitleView.setVideoRenderSize(videoDimensions.videoDisplayWidth, videoDimensions.videoDisplayHeight);
       }
   });

2. Ajoutez des sous-titres.

   Important

   Définissez les fichiers de sous-titres dans le rappel onPrepared.

   mAliPlayer.setOnPreparedListener(new IPlayer.OnPreparedListener() {
       @Override
       public void onPrepared() {
           // Set subtitles (must be done in onPrepared).
           mAliPlayer.addExtSubtitle(EXT_SUBTITLE_URL);
       }
   });

3. Configurez les écouteurs liés aux sous-titres.

   Développer pour voir le code

   mAliPlayer.setOnSubtitleDisplayListener(new IPlayer.OnSubtitleDisplayListener() {
               @Override
               public void onSubtitleExtAdded(int trackIndex, String url) {
                   // trackIndex: subtitle index; true: show the subtitle; false: hide the subtitle.
                   mAliPlayer.selectExtSubtitle(trackIndex, true);
               }
   
               @Override
               public void onSubtitleShow(int trackIndex, long id, String data) {
                   // Subtitle.
                   SubtitleView.Subtitle subtitle = new SubtitleView.Subtitle();
                   subtitle.id = String.valueOf(id);
                   subtitle.content = data;
                   // Show subtitle.
                   mSubtitleView.show(subtitle);
               }
   
               @Override
               public void onSubtitleHide(int trackIndex, long id) {
                   // Remove subtitle.
                   mSubtitleView.dismiss(String.valueOf(id));
               }
   
               @Override
               public void onSubtitleHeader(int trackIndex, String header) {
               }
           }
       );

Sous-titres externes (rendu personnalisé basé sur des composants de rendu)

La prise en charge complète des sous-titres externes WebVTT est mise en œuvre à l'aide de VttSubtitleView et WebVttResolver, permettant une personnalisation flexible de la taille, de la couleur et des polices spécifiques des sous-titres.

1. Créez CustomStyleWebVttResolver et implémentez WebVttResolver.

   public class CustomStyleWebVttResolver extends WebVttResolver {
   
       // Implement creation method.
       public CustomStyleWebVttResolver(Context context) {
           super(context);
           // Initialize fonts and other resources here later.
       }
   }

2. Redéfinissez applyTextSpans pour personnaliser les styles.

   Cette méthode est appelée après que la classe parente a analysé les styles de base, permettant un traitement secondaire des sous-titres.

   • Méthode 1 : Modifiez VttContentAttribute et appelez la méthode de la classe parente.

     /**
      * Override text style application logic to implement custom style effects.
      * This method is called after the parent class parses basic styles, allowing secondary processing of font size, color, and other attributes.
      *
      * @param spannableStringBuilder Used to build styled text.
      * @param vttContentAttribute Style attribute object for the current text segment (includes font, color, size, etc.).
      * @param start Start position for style application (inclusive).
      * @param end End position for style application (exclusive).
      */
     @Override
     protected void applyTextSpans(SpannableStringBuilder spannableStringBuilder, VttContentAttribute vttContentAttribute, int start, int end) {
         // Set.
         // Save original font size (in px) for later adjustment.
         // Default font size is 0.0533f times video height.
         double originalFontSizePx = vttContentAttribute.fontSizePx;
     
         // Double the font size.
         vttContentAttribute.fontSizePx = originalFontSizePx * 2;
         
         // Change font color to red.
         vttContentAttribute.mPrimaryColour = Color.argb(255, 255, 0, 0);
     
         // Call parent class method to apply text.
         super.applyTextSpans(spannableStringBuilder, vttContentAttribute, start, end);
     }

   • Opérez directement sur SpannableStringBuilder pour modifier les styles WebVTT directement.

     Important

     Cette méthode peut entraîner la perte des styles WebVTT natifs.

     /**
      * Override text style application logic to implement custom style effects.
      * This method is called after the parent class parses basic styles, allowing secondary processing of font size, color, and other attributes.
      *
      * @param spannableStringBuilder Used to build styled text.
      * @param vttContentAttribute Style attribute object for the current text segment (includes font, color, size, etc.).
      * @param start Start position for style application (inclusive).
      * @param end End position for style application (exclusive).
      */
     @Override
     protected void applyTextSpans(SpannableStringBuilder spannableStringBuilder, VttContentAttribute vttContentAttribute, int start, int end) {
         // Set font color.
         spannableStringBuilder.setSpan(
             new ForegroundColorSpan(Color.RED),
             start, end,
             Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
         );
         
         // Set absolute size.
         spannableStringBuilder.setSpan(
             new AbsoluteSizeSpan(20), // Unit: px.
             start, end,
             Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
         );
         
         // Set relative size.
         // spannableStringBuilder.setSpan(
         //     new RelativeSizeSpan(2.0f), // Multiple of TextView default font size.
         //     start, end,
         //     Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
         // );
     }

3. Définissez des polices personnalisées (Typeface).

   1. Chargez les polices personnalisées depuis le répertoire asset/fonts/.

      private Typeface mTypeface;
      
      public CustomStyleWebVttResolver(Context context) {
          super(context);
          initializeFonts(context);
      }
      
      private void initializeFonts(Context context) {
          try {
              // Load font from assets/fonts/.
              mTypeface = Typeface.createFromAsset(context.getAssets(), "fonts/LongCang.ttf");
          } catch (Exception e) {
              Log.e("Font", "Failed to load font", e);
              mTypeface = Typeface.DEFAULT; // Safe fallback.
          }
      }

   2. Appliquez les polices personnalisées aux sous-titres.

      @Override
      protected void applyTextSpans(SpannableStringBuilder builder, VttContentAttribute attr, int start, int end) {
          // Apply custom font.
          // Must be placed after super.applyTextSpans() to override fonts possibly set by the parent class.
          // Calling super.applyTextSpans() is optional.
          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
              builder.setSpan(new TypefaceSpan(mTypeface), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
          } else {
              builder.setSpan(new CustomTypefaceSpan(mTypeface), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
          }
      }

      Compatibilité avec les anciennes versions d'Android : Étant donné que TypefaceSpan dans Android P (API 28) et les versions antérieures ne prend pas en charge le passage direct d'un objet Typeface, vous devez créer un MetricAffectingSpan personnalisé.

      /**
        * Custom Typeface Span class.
        * Inherits from MetricAffectingSpan to correctly apply Typeface during text drawing and measurement.
        * Solves the issue where standard TypefaceSpan cannot directly use a Typeface object.
      */
      private static class CustomTypefaceSpan extends MetricAffectingSpan {
      
          // Custom font to apply.
          private final Typeface typeface;
      
          /**
            * Constructor.
            *
            * @param typeface Typeface object to apply (must not be null).
            */
          public CustomTypefaceSpan(Typeface typeface) {
              this.typeface = typeface;
          }
      
          /**
            * Update text drawing state.
            * Called during actual text drawing to set the paint's font.
            *
            * @param tp TextPaint object used for drawing text.
            */
          @Override
          public void updateDrawState(TextPaint tp) {
              tp.setTypeface(typeface);
          }
      
          /**
            * Update text measurement state.
            * Called during text layout calculation (e.g., width, line breaks) to ensure measurement matches actual drawing.
            *
            * @param p TextPaint object used for measuring text.
            */
          @Override
          public void updateMeasureState(TextPaint p) {
              p.setTypeface(typeface);
          }
      }

4. Intégrez au lecteur.

   1. Initialisez la vue des sous-titres.

      // Initialize subtitleView.
      private void initSubtitleView() {
          // Get context.
          Context context = getContext();
      
          // Create CustomStyleWebVttResolver.
          CustomStyleWebVttResolver mResolver = new CustomStyleWebVttResolver(context);
      
          // Create VttSubtitleView and pass CustomStyleWebVttResolver.
          VttSubtitleView mVttSubtitleView = new VttSubtitleView(context, mResolver);
      
          // Add to video container.
          rootView.addView(mVttSubtitleView);
      }

   2. Liez les rappels de sous-titres externes.

      // Set subtitle listener.
      mAliPlayer.setOnSubtitleDisplayListener(new IPlayer.OnSubtitleDisplayListener() {
          @Override
          public void onSubtitleExtAdded(int trackIndex, String url) {
              mAliPlayer.selectExtSubtitle(trackIndex, true);
          }
      
          @Override
          public void onSubtitleShow(int trackIndex, long id, String data) {
              if (mVttSubtitleView != null) {
                  // Show subtitle.
                  mVttSubtitleView.show(id, data); 
              }
          }
      
          @Override
          public void onSubtitleHide(int trackIndex, long id) {
              // Hide subtitle.
              mVttSubtitleView.dismiss(id);
          }
      
          @Override
          public void onSubtitleHeader(int i, String header) {
              if (!TextUtils.isEmpty(header)) {
                  // Apply WebVTT header styles.
                  mVttSubtitleView.setVttHeader(header);
              }
          }
      });

Désactivez la lecture vidéo pour obtenir une lecture audio uniquement. Configurez PlayerConfig avant d'appeler prepare.

PlayerConfig config = aliPlayer.getConfig();
config.mDisableVideo = true;  // Enable audio-only playback.
aliPlayer.setConfig(config);

Si l'appareil figure sur la liste noire cloud du décodage matériel H.265 ou si le décodage matériel H.265 échoue, une dégradation adaptative se déclenche : si un flux de secours H.264 existe, le lecteur l'utilise ; sinon, il passe au décodage logiciel H.265.

// Maintain a Map at the application layer to store key-value pairs of original URLs and backup URLs. When switching, query the backup URL in the Map based on the original URL.
 AliPlayerGlobalSettings.setAdaptiveDecoderGetBackupURLCallback(new AliPlayerGlobalSettings.OnGetBackupUrlCallback() {
    @Override
    public String getBackupUrlCallback(int oriBizScene, int oriCodecType, String original_url) {
        String kurl = original_url;
        if (!H265toH264Map.get(kurl).isEmpty()) {
            return H265toH264Map.get(kurl);
        } else {
            return "";
        }
    }
});

Le SDK Player Android offre une fonctionnalité de capture d'écran pour la vidéo en cours, mise en œuvre par l'interface snapshot. Elle capture les données d'origine et les renvoie sous forme de bitmap. L'interface de rappel est OnSnapShotListener. Exemple :

// Set screenshot callback.
aliPlayer.setOnSnapShotListener(new OnSnapShotListener(){
    @Override
    public void onSnapShot(Bitmap bm, int with, int height){
        // Obtain the bitmap and image dimensions.
    }
});
// Capture the current playback frame.
aliPlayer.snapshot();

En configurant ApsaraVideo VOD, le SDK Player Android peut mettre en œuvre une lecture d'aperçu, prenant en charge les méthodes de lecture VidSts et VidAuth (VidAuth est recommandé pour VOD). Pour les instructions de configuration et d'utilisation, consultez Aperçu des vidéos.

VidSts vidSts = new VidSts;
....
VidPlayerConfigGen configGen = new VidPlayerConfigGen();
configGen.setPreviewTime(20);// 20-second preview.
vidSts.setPlayConfig(configGen);// Set for playback source.
...

Le SDK Player Android fournit un mécanisme de liste noire de décodage matériel. Pour les appareils qui ne peuvent explicitement pas utiliser le décodage matériel, le décodage logiciel est utilisé directement afin d'éviter des opérations inefficaces. Exemple :

DeviceInfo deviceInfo = new DeviceInfo();
deviceInfo.model="Lenovo K320t";
AliPlayerFactory.addBlackDevice(BlackType.HW_Decode_H264 ,deviceInfo );

Définissez le Referer de la requête à l'aide de PlayerConfig. Combiné à la liste noire/liste d'autorisation Referer dans la console, cela permet de contrôler les permissions d'accès. Exemple :

// Get configuration first.
PlayerConfig config = aliPlayer.getConfig();
// Set referer, for example: http://example.aliyundoc.com. (Note: Include the protocol part when setting the referer.)
config.mReferrer = referrer;
....// Other settings.
  // Set configuration for the player.
aliPlayer.setConfig(config);

Définissez le UserAgent de la requête à l'aide de PlayerConfig. Le lecteur inclut l'UA dans les requêtes. Exemple :

// Get configuration first.
PlayerConfig config = aliPlayer.getConfig();
// Set UA.
config.mUserAgent = "UserAgent to set";
....// Other settings.
  // Set configuration for the player.
aliPlayer.setConfig(config);

Définissez le délai d'attente réseau et le nombre de tentatives à l'aide de PlayerConfig. Exemple :

// Get configuration first.
PlayerConfig config = aliPlayer.getConfig();
// Set network timeout duration, in milliseconds.
config.mNetworkTimeout = 5000;
// Set timeout retry count. The interval between retries is networkTimeout. networkRetryCount=0 means no retry; the retry policy is determined by the app. Default value is 2.
config.mNetworkRetryCount=2;
....// Other settings.
  // Set configuration for the player.
aliPlayer.setConfig(config);

Le SDK Player Android fournit des interfaces pour contrôler le cache et la latence via PlayerConfig. Exemple :

// Get configuration first.
PlayerConfig config = aliPlayer.getConfig();
// Maximum latency. Note: Valid for live streaming. When latency is large, the player SDK internally synchronizes frames to keep latency within this range.
config.mMaxDelayTime = 5000;
// Maximum buffer duration, in ms. The player loads up to this duration of buffer data each time.
config.mMaxBufferDuration = 50000;
// High buffer duration, in ms. When poor network conditions cause data loading, loading stops when buffer duration reaches this value.
config.mHighBufferDuration = 3000;
// Startup buffer duration, in ms. Shorter duration means faster startup but may cause quick entry into loading state after playback starts.
config.mStartBufferDuration = 500;
....// Other settings.
// Maximum backward buffer duration, in ms. Default is 0.
config.mMaxBackwardBufferDurationMs = 0;

// Set configuration for the player.
aliPlayer.setConfig(config);

À l'aide de la méthode PlayerConfig, vous pouvez ajouter des paramètres d'en-tête HTTP aux requêtes du lecteur. Exemple :

// Get configuration first.
PlayerConfig config = aliPlayer.getConfig();
// Define headers.
String[] headers = new String[1];
headers[0]="Host:example.com";// For example, set Host in the header.
// Set headers.
config.setCustomHeaders(headers);
....// Other settings.
  // Set configuration for the player.
aliPlayer.setConfig(config);

Picture-in-Picture

Procédure :

1. Dans le fichier AndroidManifest.xml, déclarez les permissions Picture-in-Picture.

   <activity
     android:name=".PictureInPictureActivity"
     android:exported="true"
     android:supportsPictureInPicture="true"
     android:configChanges="screenSize|smallestScreenSize|screenLayout|orientation" />

2. Basculez l'Activity cible en mode Picture-in-Picture.

   Rational aspectRatio = new Rational(16, 9); // Aspect ratio for Picture-in-Picture; adjust based on your business needs.
   PictureInPictureParams.Builder pipBuilder = new PictureInPictureParams.Builder();
   pipBuilder.setAspectRatio(aspectRatio);
   enterPictureInPictureMode(pipBuilder.build());

   Vous pouvez déclencher le mode Picture-in-Picture depuis un événement OnClick (clic), en quittant l'application ou en y revenant. Méthodes d'implémentation :

   Déclencheur OnClick (événement clic)

   button.setOnClickListener(new View.OnClickListener() {
       @Override
       public void onClick(View v) {
           Rational aspectRatio = new Rational(16, 9); // Aspect ratio for Picture-in-Picture.
           PictureInPictureParams.Builder pipBuilder = new PictureInPictureParams.Builder();
           pipBuilder.setAspectRatio(aspectRatio);
           enterPictureInPictureMode(pipBuilder.build());
       }
   });

   Déclenchement en quittant l'application

   @Override
   protected void onUserLeaveHint() {
       super.onUserLeaveHint();
       Rational aspectRatio = new Rational(16, 9); // Aspect ratio for Picture-in-Picture.
       PictureInPictureParams.Builder pipBuilder = new PictureInPictureParams.Builder();
       pipBuilder.setAspectRatio(aspectRatio);
       enterPictureInPictureMode(pipBuilder.build());
   
       Log.e(TAG, "Picture-in-Picture onUserLeaveHint");
   }

   Déclenchement au retour dans l'application

   @Override
   public void onBackPressed() {
       super.onBackPressed();
       // Trigger from back press.
       enterPictureInPictureMode();
   }

3. Gérez l'interface utilisateur pour l'apparition/disparition du Picture-in-Picture.

   @Override
   public void onPictureInPictureModeChanged(boolean isInPictureInPictureMode, Configuration newConfig) {
       super.onPictureInPictureModeChanged(isInPictureInPictureMode, newConfig);
       if (isInPictureInPictureMode) {
           // Handle entering Picture-in-Picture mode.
           // hide UI
           Log.e(TAG, "Entered Picture-in-Picture mode");
       } else {
           // Handle exiting Picture-in-Picture mode.
           // show UI 
           Log.e(TAG, "Exited Picture-in-Picture mode");
       }
   }

Dégradation RTS Live

Lecture live RTS.

Le SDK Player Android fournit la méthode setOutputAudioChannel pour définir le canal audio de sortie. Si la source d'entrée est stéréo, vous pouvez basculer vers le canal gauche ou droit à l'aide de cette méthode. Si la source d'entrée est mono, le paramètre n'a aucun effet.

/*
OutputAudioChannel.OUTPUT_AUDIO_CHANNEL_LEFT switches to left channel playback,
OutputAudioChannel.OUTPUT_AUDIO_CHANNEL_RIGHT switches to right channel playback,
OutputAudioChannel.OUTPUT_AUDIO_CHANNEL_NONE does not switch channels, maintaining the input source channels.
*/
aliPlayer.setOutputAudioChannel();

Configurez un écouteur pour obtenir les données des flux audio et vidéo. Les flux ne doivent pas être chiffrés, car les flux chiffrés ne peuvent pas être analysés.

// Optional configuration 1: Whether to return the address of underlying data.
IPlayer.RenderFrameCallbackConfig config = new IPlayer.RenderFrameCallbackConfig();
config.mVideoDataAddr = true;// Whether to return only the address of underlying video data.
config.mAudioDataAddr = true;// Whether to return only the address of underlying audio data.
aliPlayer.setRenderFrameCallbackConfig(config);

// Optional configuration 2: For hardware decoding, RenderFrame returns texture_oes_id; for software decoding, RenderFrame returns source data.
aliPlayer.enableHardwareDecoder(true);
// Set listener to obtain audio and video data.
aliPlayer.setOnRenderFrameCallback(frameInfo -> {
    if (frameInfo.frameType == FrameInfo.FrameType_video) {
        // Video data.
    } else {
        // Audio data.
    }
    return false;
});

Le SDK Player Android permet de définir la couleur d'arrière-plan pour le rendu du lecteur. Interface et instructions d'utilisation :

Exemple d'interface

/**
 * Set video background color.
 *
 * @param color  ARGB
 */
abstract public void setVideoBackgroundColor(int color);

Instructions d'utilisation

// Parameter is an 8-digit hexadecimal value. Each pair of digits represents A (alpha transparency), R (red), G (green), B (blue) in order.
// For example, 0x0000ff00 represents green.
aliPlayer.setVideoBackgroundColor(0x0000ff00);

vidAuthDéfinir le domaine de lecture spécifié

À l'aide de vidAuth, vous pouvez spécifier des champs tels que le domaine pour le vid. Pour les champs pris en charge, consultez Paramètres de requête GetPlayInfo. Interface et instructions d'utilisation :

Exemple d'interface

/**
 * Set playback parameters.
 *
 * @param playConfig Playback parameters.
 */
public void setPlayConfig(VidPlayerConfigGen playConfig);

Instructions d'utilisation

Utilisez la méthode addPlayerConfig de VidPlayerConfigGen pour ajouter le champ playDomain.

vidAuth = new VidAuth();
VidPlayerConfigGen configGen = new VidPlayerConfigGen();
// Add playDomain field. For other fields you can add, refer to
//https://www.alibabacloud.com/help/zh/vod/developer-reference/api-vod-2017-03-21-getplayinfo
configGen.addPlayerConfig("playDomain", "com.xxx.xxx");
vidAuth.setPlayConfig(configGen);

Plugin de décodage H.266

Le H.266 (VVC/Versatile Video Coding) est une norme de codage vidéo de nouvelle génération qui réduit considérablement le débit binaire à qualité équivalente. La capacité de décodage H.266 est conditionnée indépendamment sous forme de plugin pour une intégration à la demande.

Prérequis

1. Version du SDK Player/intégré V7.6.0 ou ultérieure.

2. Autorisation de licence Édition Professionnelle obtenue. Obtenir une licence SDK Player.

3. ApsaraVideo Player avec le plugin de décodage H.266 prend uniquement en charge les vidéos H.266 transcodées par ApsaraVideo VOD via le transcodage audio et vidéo.

Intégrer le plugin

// x.x.x matches the player SDK version number.
com.aliyun.sdk.android:AlivcVVCCodec:x.x.x

// x.x.x matches the integrated SDK version number.
com.aliyun.sdk.android:AlivcVVCCodec:x.x.x-aio

Activer le plugin

AliPlayerGlobalSettings.enableCodecPlugin("vvc", true);

Codes d'erreur associés

Pour les codes d'erreur du plugin de décodage H.266, consultez Problèmes courants pour les lecteurs sur toutes les plateformes.

Rafraîchissement automatique des sources de lecture

L'activation du rafraîchissement automatique des sources de lecture évite les interruptions de lecture causées par l'expiration des sources sous des mécanismes d'authentification.

Prérequis

1. Version du SDK Player/intégré V7.9.0 ou ultérieure.

2. Utilisation de la source VidAuth pour la lecture ou votre activité a configuré la signature d'URL.

/**
 * Set the listener for VidAuth source expiration events.
 *
 * This feature enables automated VidAuth source refresh to avoid playback interruptions
 * caused by expiration. When the listener is triggered, you can refresh the VidAuth source
 * and return the updated VidAuth using {@link SourceRefreshCallback#onSuccess}.
 *
 * @param listener The interface for listening to VidAuth source expiration events. See {@link OnVidAuthExpiredListener}.
 */
abstract public void setOnVidAuthExpiredListener(OnVidAuthExpiredListener listener);

/**
 * Listener for VidAuth source expiration notifications.
 * Handles events when a VidAuth source expires.
 */
public interface OnVidAuthExpiredListener {

    /**
     * Called when the player detects that the VidAuth source has expired.
     *
     * You can refresh the VidAuth source in this callback and return the new VidAuth
     * using {@link SourceRefreshCallback#onSuccess}.
     *
     * @param expiredSource The expired VidAuth source object. See {@link VidAuth}.
     * @param callback The callback used to provide the updated VidAuth source to the player. See {@link SourceRefreshCallback}.
     */
    void onVidAuthExpired(VidAuth expiredSource, SourceRefreshCallback<VidAuth> callback);
}

/**
 * A callback interface for handling playback source refresh results.
 *
 * This interface is applicable to playback source types that require dynamic updates,
 * such as URL source or VidAuth source. When the player triggers a refresh request,
 * the refresh result can be returned via this interface by invoking either the `onSuccess` or `onError` method.
 */
public interface SourceRefreshCallback<T extends SourceBase> {
    /**
     * Called by the player when the refresh operation succeeds.
     *
     * @param newSource The new playback source object containing the updated information. See {@link SourceBase}.
     *
     * This method indicates that the refresh operation was successfully completed. Developers should provide
     * the new playback source within this method so that the player can load the latest resource.
     */
    void onSuccess(T newSource);

    /**
     * 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 the `errorMsg`
     * to capture details of the failure and proceed with subsequent handling.
     */
    void onError(String errorMsg);
}

// Set VID playback credential expiration listener.
aliPlayer.setOnVidAuthExpiredListener(new AliPlayer.OnVidAuthExpiredListener() {
    @Override
    public void onVidAuthExpired(VidAuth vidAuth, UrlPlayer.SourceRefreshCallback<VidAuth> sourceRefreshCallback) {
        
        String vid = vidAuth.getVid();

        // ------------------- User implementation starts -------------------
        // Call your own function to get new PlayAuth from your app server.
        // clinetGetPlayAuthFunction is an example function name; replace it with your own implementation.
        clinetGetPlayAuthFunction(vid, new PlayAuthCallback() {
            
            /**
             * Callback when new credentials are successfully obtained.
             * @param newPlayAuth New playback credential string obtained from your server.
             */
            @Override
            public void onAuthSuccess(String newPlayAuth) {                
                // 1. Update the old vidAuth object with the new PlayAuth.
                vidAuth.setPlayAuth(newPlayAuth);
                
                // 2. Return the updated object to the player via the SDK callback.
                sourceRefreshCallback.onSuccess(vidAuth);
            }

            /**
             * Callback when obtaining new credentials fails.
             * @param errorMessage Detailed error message.
             */
            @Override
            public void onAuthError(String errorMessage) {                
                // Return the error message to the player via the SDK callback.
                sourceRefreshCallback.onError(errorMessage);
            }
        });
        // ------------------- User implementation ends -------------------
    }
});

/**
 * Set the listener for URL source expiration events.
 *
 * This feature enables URL refresh to avoid playback interruptions caused by
 * URL expiration due to authentication. When the listener is triggered,
 * you can refresh the URL source and return the updated URL source using {@link SourceRefreshCallback#onSuccess}.
 *
 * @param listener Listener for handling URL source expiration events. See {@link OnURLSourceExpiredListener}.
 *
 * <p>For more information on configuring URL authentication, see
 * <a href="https://www.alibabacloud.com/help/zh/vod/user-guide/configure-url-signing?spm=a2c4g.11186623.0.0.560c4140fGh8MW">URL authentication documentation</a>.</p>
 */
abstract public void setOnURLSourceExpiredListener(OnURLSourceExpiredListener listener);

/**
 * A callback interface for handling playback source refresh results.
 *
 * This interface is applicable to playback source types that require dynamic updates,
 * such as URL source or VidAuth source. When the player triggers a refresh request,
 * the refresh result can be returned via this interface by invoking either the `onSuccess` or `onError` method.
 */
public interface SourceRefreshCallback<T extends SourceBase> {
    /**
     * Called by the player when the refresh operation succeeds.
     *
     * @param newSource The new playback source object containing the updated information. See {@link SourceBase}.
     *
     * This method indicates that the refresh operation was successfully completed. Developers should provide
     * the new playback source within this method so that the player can load the latest resource.
     */
    void onSuccess(T newSource);

    /**
     * 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 the `errorMsg`
     * to capture details of the failure and proceed with subsequent handling.
     */
    void onError(String errorMsg);
}

/**
 * Listener for URL source expiration notifications.
 * This helps process expired sources and prevents playback interruptions.
 */
public interface OnURLSourceExpiredListener {

    /**
     * Called when the player detects that the URL source (UrlSource) has expired.
     *
     * You can refresh the URL source in this callback and return the new UrlSource
     * using {@link SourceRefreshCallback#onSuccess}.
     *
     * @param expiredSource The expired UrlSource object. See {@link UrlSource}.
     * @param callback The refresh callback used to return the updated UrlSource to the player. See {@link SourceRefreshCallback}.
     */
    void onUrlSourceExpired(UrlSource expiredSource, SourceRefreshCallback<UrlSource> callback);
}

// Set the player's URL expiration listener.
mAliyunVodPlayer.setOnURLSourceExpiredListener(new UrlPlayer.OnURLSourceExpiredListener() {
    @Override
    public void onUrlSourceExpired(UrlSource urlSource, UrlPlayer.SourceRefreshCallback<UrlSource> sourceRefreshCallback) {
        String expiredUrl = urlSource.getUri();
        Log.d(TAG, "[onUrlSourceExpired] Received expired URL: " + expiredUrl);

        // 1. Check if the authentication key is valid (assuming authenticationKey is a member variable of the class).
        if (authenticationKey == null || authenticationKey.trim().isEmpty()) {
            Log.e(TAG, "Refresh failed: Authentication key is empty.");
            sourceRefreshCallback.onError("REFRESH_ERROR: Authentication key is missing.");
            return; // Exit early if the key is invalid.
        }

        // 2. Calculate the validity duration (expiration time) for the playback URL.
        // If the class member validTime is valid, use it; otherwise, default to 3600 seconds (1 hour).
        long validityDuration = (AliyunVodPlayerView.this.validTime > 0) ? validTime : 3600;
        long newExpireTime = (System.currentTimeMillis() / 1000) + validityDuration;

        // 3. Extract the original URL from the expired URL (using authentication type A as an example).
        // Restore the original resource address by removing URL parameters (e.g., "?auth_key=").
        int authKeyIndex = expiredUrl.indexOf("?auth_key=");
        if (authKeyIndex == -1) {
            authKeyIndex = expiredUrl.indexOf("&auth_key=");
        }
        // Safely handle cases where auth_key is not found.
        String originalUrl = (authKeyIndex != -1) ? expiredUrl.substring(0, authKeyIndex) : expiredUrl;

        // 4. Generate a new authenticated URL using a utility class.
        String newAuthUrl = CdnAuthUtil.aAuth(originalUrl, authenticationKey, newExpireTime);

        // 5. Check the generated authenticated URL and return the result via callback.
        if (newAuthUrl != null && !newAuthUrl.isEmpty()) {
            Log.i(TAG, "Refresh success, new URL: " + newAuthUrl);
            // Create a UrlSource object as required by the SDK and set the new URL.
            UrlSource resultSource = new UrlSource();
            resultSource.setUri(newAuthUrl);
            sourceRefreshCallback.onSuccess(resultSource);
        } else {
            Log.e(TAG, "Refresh failed: Failed to generate new authorized URL.");
            sourceRefreshCallback.onError("REFRESH_ERROR: Failed to generate new URL.");
        }
    }
});

Fonctions utilitaires supplémentaires

En prenant l'authentification de type A comme exemple.

// Authenticated URL generation function.
private String generateAuthUrl(String uri, String key, long exp) {
    Pattern uriPattern = Pattern.compile("^(https?://)?([^/?]+)(/[^?]*)?(\\?.*)?$");
    Matcher m = uriPattern.matcher(uri);

    if (!m.matches()) {
        return null;
    }

    String scheme = (m.group(1) != null) ? m.group(1) : "http://";
    String host = m.group(2);
    String path = (m.group(3) != null) ? m.group(3) : "/";
    String args = (m.group(4) != null) ? m.group(4) : "";

    String rand = "0";
    String uid = "0";

    String sstring = String.format("%s-%d-%s-%s-%s", path, exp, rand, uid, key);
    String hashvalue = md5sum(sstring);
    String authKey = String.format("%d-%s-%s-%s", exp, rand, uid, hashvalue);

    if (!args.isEmpty()) {
        return String.format("%s%s%s%s&auth_key=%s", scheme, host, path, args, authKey);
    } else {
        return String.format("%s%s%s%s?auth_key=%s", scheme, host, path, args, authKey);
    }
}

// MD5 calculation utility function.
private String md5sum(String src) {
    try {
        MessageDigest md = MessageDigest.getInstance("MD5");
        md.update(src.getBytes(StandardCharsets.UTF_8));
        byte[] digest = md.digest();

        StringBuilder hexString = new StringBuilder();
        for (byte b : digest) {
            hexString.append(String.format("%02x", b));
        }
        return hexString.toString();
    } catch (NoSuchAlgorithmException e) {
        throw new RuntimeException("MD5 algorithm not found", e);
    }
}

Changer de carte réseau liée

Le SDK Player Android fournit la méthode AliPlayerGlobalSettings.enableSwitchNIC pour basculer automatiquement de carte réseau lors d'anomalies réseau, garantissant une lecture stable des ressources. Exemple :

AliPlayerGlobalSettings.enableSwitchNIC(true);

Amélioration audio

Le SDK Player Android fournit un plugin d'amélioration audio pour améliorer l'expérience de lecture audio, comprenant la normalisation du volume, l'amélioration de la voix et le son surround.

Présentation de la fonctionnalité

• Normalisation du volume : Ajuste automatiquement tout le contenu audio à un niveau de volume constant, améliorant considérablement l'expérience de lecture pour les vidéos dont le volume d'origine est trop faible ou trop élevé.

  • Canaux pris en charge : Mono / Stéréo / 5.1 / 7.1.

  • Fréquences d'échantillonnage prises en charge : 16kHz / 44.1kHz / 48kHz.

• Amélioration de la voix : Améliore intelligemment les dialogues tout en préservant le timbre d'origine, rendant les voix plus claires et plus brillantes dans les scènes bruyantes.

  • Canaux pris en charge : Stéréo.

  • Fréquences d'échantillonnage prises en charge : 44.1kHz / 48kHz.

• Son surround : Applique un rendu surround virtuel aux vidéos multicanaux et stéréo, offrant une expérience immersive sur casque ou appareils standards. Inclut les modes 3DSurround (surround stéréo) et MegaBass (super basses).

  • Canaux pris en charge : Mono / Stéréo / 5.1 / 7.1.

  • Fréquences d'échantillonnage prises en charge : 44.1kHz / 48kHz.

Prérequis

1. Version du SDK Player/intégré V7.13.0 ou ultérieure.

2. Autorisation de licence Édition Professionnelle obtenue. Obtenir une licence SDK Player.

Intégrer le plugin

// x.x.x matches the player SDK version number.
implementation 'com.aliyun.sdk.android:AlivcAudioEnhanceFilter:x.x.x'

Interfaces de la fonctionnalité

player.setFilterValid("audioEnhance", true);   // Enable.
player.setFilterValid("audioEnhance", false);  // Disable.

FilterConfig filterConfig = new FilterConfig();
FilterConfig.Filter filterItem = new FilterConfig.Filter("audioEnhance");
FilterConfig.FilterOptions opts = new FilterConfig.FilterOptions();
// Surround sound.
opts.setOption("enable_surround", true);
opts.setOption("surround_effect_type", "3DSurround"); // Type must be set together with enable_surround on first use.
// Voice enhancement.
opts.setOption("enable_dialoguenhance", true);
opts.setOption("dialoguenhance_voice", 1.0f); // 1.0 ~ 10.0. Voice must be set together with enable_dialoguenhance on first use.
// Volume normalization.
opts.setOption("enable_normalizer", true);

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"]; // If not the first time enabling surround, this Type setting is invalid because initialization is already complete.
[player updateFilterConfig:@"audioEnhance" options:opts];

/**
 * Set the player scenario.
 *
 * @param scene 
 */
abstract public void setPlayerScene(PlayerScene scene);

public enum PlayerScene {
    /**
     * Scenario: none.
     */
    NONE,
    /**
     * Long video scenario: applies to videos longer than 30 minutes.
     */
    LONG,
    /**
     * Medium video scenario: applies to videos between 5 and 30 minutes.
     */
    MEDIUM,
    /**
     * Short video scenario: applies to videos up to 5 minutes.
     */
    SHORT,
    /**
     * Live scenario.
     */
    LIVE,
    /**
     * Ultra-low latency live scenario.
     */
    RTS_LIVE
}

// Set short video scenario.
aliPlayer.setPlayerScene(PlayerScene.SHORT)

// Set medium video scenario.
aliPlayer.setPlayerScene(PlayerScene.MEDIUM)

// Set long video scenario.
aliPlayer.setPlayerScene(PlayerScene.LONG)

// Set live scenario.
aliPlayer.setPlayerScene(PlayerScene.LIVE)

Le SDK Player Android permet de rendre rapidement la première image avant le début de la lecture, ce qui peut améliorer la vitesse de démarrage.

aliPlayer.setOption(ALLOW_PRE_RENDER, 1);

Le cache local améliore la vitesse de démarrage, la vitesse de recherche et réduit les saccades lors de lectures répétées, tout en économisant la bande passante.

Activer le cache local

// Enable local cache (default path).
AliPlayerGlobalSettings.enableLocalCache(true, this);

/**
 * You can also use the following code for cache settings.
 * Enable local cache. After enabling, content is cached to local files.
 * @param enable: Local cache feature switch. true: enable, false: disable. Disabled by default.
 * @param maxBufferMemoryKB: Deprecated since version 5.4.7.1, currently has no effect.
 * @param localCacheDir: Must be set. Local cache directory as an absolute path.
 * AliPlayerGlobalSettings.enableLocalCache(enable, maxBufferMemoryKB, localCacheDir);
 */

/**
 * Local cache file cleanup configuration.
 * @param expireMin - Deprecated since version 5.4.7.1, currently has no effect.
 * @param maxCapacityMB - Maximum cache capacity in MB. Default is 20 GB. During cleanup, if total cache size exceeds this value, cache items are deleted one by one from oldest to newest until size is ≤ maxCapacityMB.
 * @param freeStorageMB - Minimum free disk space in MB. Default is 0. During cleanup, if current disk space is less than this value, cache items are deleted one by one until free space ≥ this value or all cache is cleared.
 * public static void setCacheFileClearConfig(long expireMin,
 *         long maxCapacityMB,
 *         long freeStorageMB)
 */

 /**
  * Set callback for loading URL hash value. If not set, SDK uses MD5 algorithm.
  * public static void setCacheUrlHashCallback(AliPlayerGlobalSettings.OnGetUrlHashCallback cb)
  */

Activer ou désactiver le cache local pour une URL unique

// Get configuration first.
PlayerConfig config = aliPlayer.getConfig();
// Whether to enable local cache for the playback URL. Default is true. When global local cache is enabled and this is set to true, local cache takes effect for this URL. If set to false, local cache is disabled for this URL.
config.mEnableLocalCache = false;
....// Other settings.

// Set configuration for the player.
aliPlayer.setConfig(config);

Le préchargement est une évolution du cache local qui améliore la vitesse de démarrage vidéo en définissant l'utilisation de la mémoire pour la mise en cache vidéo.

AliPlayerGlobalSettings.enableNetworkBalance(false);

1. Activez le cache local. Pour les étapes détaillées, consultez Cache local.

2. Définissez la source de données.

   VidAuth (recommandé)

   VidAuth vidAuth = new VidAuth();
   vidAuth.setVid("Vid info");// Required parameter: Video ID.
   vidAuth.setPlayAuth("<yourPlayAuth>");// Required parameter: Playback credential, generated by calling the GetVideoPlayAuth API of VOD.
   vidAuth.setRegion("Access region");// For player SDK version 5.5.5.0 and later, this parameter is deprecated and not required; the player automatically parses the region. For versions before 5.5.5.0, this parameter is required; the default VOD access region is cn-shanghai.
   vidAuth.setQuality("Selected definition") //"AUTO" represents adaptive bitrate.

   VidSts

   VidSts vidSts = new VidSts();
   vidSts.setVid("Vid info");// Required parameter: Video ID. vidSts.setAccessKeyId("<yourAccessKeyId>");// Required parameter: Access key ID of the STS temporary AK pair, generated by calling the AssumeRole API of STS.  vidSts.setAccessKeySecret("<yourAccessKeySecret>");// Required parameter: Access key of the STS temporary AK pair, generated by calling the AssumeRole API of STS.  vidSts.setSecurityToken("<yourSecurityToken>");// Required parameter: STS security token, generated by calling the AssumeRole API of STS.  vidSts.setRegion("Access region");// Required parameter: VOD access region; default is cn-shanghai.
   vidSts.setQuality("Selected definition") //"AUTO" represents adaptive bitrate.

   UrlSource

   UrlSource urlSource = new UrlSource();
   urlSource.setUri("Playback address");// Required parameter: Playback address, which can be a third-party VOD address or an Alibaba Cloud VOD playback address.

3. Définissez les paramètres de la tâche.

   Remarque

   S'applique uniquement aux vidéos multi-débits. Choisissez l'une des options suivantes : setDefaultBandWidth, setDefaultResolution ou setDefaultQuality.

   PreloadConfig preloadConfig = new PreloadConfig();
   // Set preloading bitrate for multi-bitrate streams.
   preloadConfig.setDefaultBandWidth(400000);
   // Set preloading resolution for multi-bitrate streams.
   preloadConfig.setDefaultResolution(640 * 480);
   // Set preloading quality for multi-bitrate streams.
   preloadConfig.setDefaultQuality("FD");
   // Set preloading duration.
   preloadConfig.setDuration(1000);

4. Ajoutez l'écouteur de tâche.

   Développer pour voir le code

   /**
    * Preloading listener implementation.
    */
   private static class PreloadListenerImpl extends OnPreloadListener {
   
       @Override
       public void onError(@NonNull String taskId, @NonNull String urlOrVid, @NonNull ErrorInfo errorInfo) {
           // Loading error.
       }
   
       @Override
       public void onCompleted(@NonNull String taskId, @NonNull String urlOrVid) {
           // Loading completed.
       }
   
       @Override
       public void onCanceled(@NonNull String taskId, @NonNull String urlOrVid) {
          // Loading canceled.
       }
   }

5. Construisez la tâche et ajoutez-la à l'instance MediaLoaderV2 pour démarrer le préchargement.

   VidAuth (recommandé)

   // Build preloading.
   PreloadTask mPreloadTask = new PreloadTask(vidAuth, preloadConfig);
   // Get MediaLoaderV2 instance.
   MediaLoaderV2 mediaLoaderV2 = MediaLoaderV2.getInstance();
   // Add task and start preloading.
   String taskId = mediaLoaderV2.addTask(mPreloadTask, PreloadListenerImpl)

   VidSts

   // Build preloading.
   PreloadTask mPreloadTask = new PreloadTask(vidSts, preloadConfig);
   // Get MediaLoaderV2 instance.
   MediaLoaderV2 mediaLoaderV2 = MediaLoaderV2.getInstance();
   // Add task and start preloading.
   String taskId = mediaLoaderV2.addTask(mPreloadTask, PreloadListenerImpl);

   UrlSource

   // Build preloading.
   PreloadTask mPreloadTask = new PreloadTask(urlSource, preloadConfig);
   // Get MediaLoaderV2 instance.
   MediaLoaderV2 mediaLoaderV2 = MediaLoaderV2.getInstance();
   // Add task and start preloading.
   String taskId = mediaLoaderV2.addTask(mPreloadTask, PreloadListenerImpl)

6. Facultatif : Gérez les tâches.

   mediaLoaderV2.cancelTask(taskId);// Cancel preloading task with specified task ID.
   mediaLoaderV2.pauseTask(taskId);// Pause preloading task with specified task ID.
   mediaLoaderV2.resumeTask(taskId);// Resume preloading task with specified task ID.

7. Facultatif : Supprimez les fichiers chargés.

   Supprimez les fichiers chargés selon vos besoins pour économiser de l'espace. Le SDK Player Android ne fournit pas d'interface de suppression ; supprimez les fichiers du répertoire de chargement dans votre application.

La stratégie de préchargement dynamique permet aux intégrateurs de contrôler à la fois le cache de la vidéo en cours de lecture et le nombre ainsi que le cache des éléments préchargés, équilibrant ainsi l'expérience de lecture et les coûts.

// Enable recommended configuration and dynamic preloading.
aliListPlayer.setPreloadScene(IListPlayer.SceneType.SCENE_SHORT);

// Configure baseline preloading duration.
// Set preloading duration to 1000ms.
PreloadConfig config = new PreloadConfig();
config.mPreloadDuration = 1000;
aliListPlayer.updatePreloadConfig(config);

// Configure number of preloads, supporting bidirectional.
// 1 for forward preloads, 3 for backward preloads.
aliListPlayer.setPreloadCount(1, 3);

// Configure dynamic preloading decrement offset.
aliListPlayer.enablePreloadStrategy(IListPlayer.StrategyType.STRATEGY_DYNAMIC_PRELOAD_DURATION, true);
aliListPlayer.setPreloadStrategy(IListPlayer.StrategyType.STRATEGY_DYNAMIC_PRELOAD_DURATION, "{\"algorithm\": \"sub\",\"offset\": \"200\"}");

Préchargement vidéo HLS multi-débits

Dans les scénarios de lecture vidéo HLS multi-débits avec listPlayer, les intégrateurs peuvent précharger des flux correspondant à la définition de lecture actuelle et choisir des modes de préchargement en fonction des besoins métier.

  /**
   * Default configuration, play and preload default bitrate.
   */
  MultiBitratesMode_Default(0),

  /**
   * First frame priority configuration, decrease first frame cost. Only play bitrate of the HLS stream which has been preloaded.
   */
  MultiBitratesMode_FCPrio(1),

  /**
   * Balance first frame and playback smoothness, play the same bitrate before and after moveToNext, and prioritize first frame performance.
   */
  MultiBitratesMode_FC_AND_SMOOTH(2),

  /**
   * Playback smoothness priority configuration, play the same bitrate before and after moveToNext.
   */
  MultiBitratesMode_SmoothPrio(3);

// Select multi-bitrate loading mode.
aliListPlayer.SetMultiBitratesMode(preLoadMode);

// (Optional) Select startup bitrate.
aliListPlayer.setDefaultBandWidth(defaultBandWidth)

// (Optional) In onPrepared callback, select ABR mode.
aliListPlayer.setOnPreparedListener(new IPlayer.OnPreparedListener() {
    @Override
    public void onPrepared() {
        // ABR only affects multi-bitrate m3u8.
        aliListPlayer.selectTrack(-1);
    }
});

Obtenez la vitesse de téléchargement vidéo actuelle via le rappel onInfo, mis en œuvre par l'interface getExtraValue. Exemple :

aliPlayer.setOnInfoListener(new IPlayer.OnInfoListener() {
    @Override
    public void onInfo(InfoBean infoBean) {
        if(infoBean.getCode() == InfoCode.CurrentDownloadSpeed){
            // Current download speed.
            long extraValue = infoBean.getExtraValue();
        }
    }
});

HTTPDNS

// Enable enhanced HTTPDNS.
AliPlayerGlobalSettings.enableEnhancedHttpDns(true);
// Optional: Add HTTPDNS pre-resolution domains.
DomainProcessor.getInstance().addPreResolveDomain("player.***alicdn.com");

HTTP/2

AliPlayerGlobalSettings.setUseHttp2(true);

Pré-connexion TCP HTTP

Pour les requêtes de lecture vidéo HTTP (non-HTTPS), l'établissement préalable de connexions TCP améliore considérablement l'expérience utilisateur, réduit le temps de connexion réseau, assure une lecture immédiate et continue, et optimise l'utilisation des ressources réseau et système. Utilisation :

// Domain format is host[:port]; port is optional. Separate multiple domains with semicolons (;).
// Global setting.
// Full interface uses the current string each time it's set (more - add, less - remove). Empty string stops pre-connection.
AliPlayerGlobalSettings.setOption(AliPlayerGlobalSettings.SET_PRE_CONNECT_DOMAIN, "domain1;domain2");

Le SDK Player Android fournit une fonctionnalité de téléchargement vidéo pour les services VOD, permettant aux utilisateurs de mettre en cache des vidéos localement à l'aide d'ApsaraVideo Player. Il offre deux méthodes de téléchargement : téléchargement standard et téléchargement sécurisé.

• Téléchargement standard

  Les données vidéo téléchargées ne sont pas chiffrées par Alibaba Cloud et peuvent être lues par des lecteurs tiers.

• Téléchargement sécurisé

  Les données vidéo téléchargées sont chiffrées par Alibaba Cloud. Les lecteurs tiers ne peuvent pas les lire. Seul ApsaraVideo Player peut les lire.

Instructions d'utilisation

• Seules les méthodes VidSts et VidAuth prennent en charge le téléchargement vidéo.

• Pour utiliser la fonctionnalité de téléchargement vidéo du lecteur, activez et configurez le mode de téléchargement dans la console VOD. Pour les étapes détaillées, consultez Téléchargement hors ligne.

• Le téléchargement vidéo prend en charge les téléchargements interrompus et repris.

Procédure

1. Facultatif : Configurez le fichier de vérification de chiffrement pour le téléchargement sécurisé. Requis uniquement pour le téléchargement sécurisé ; non nécessaire pour le téléchargement standard.

   Remarque

   Assurez-vous que le fichier de vérification de chiffrement configuré correspond aux informations de votre application ; sinon, le téléchargement vidéo échouera.

   Pour le téléchargement sécurisé, configurez le fichier de clé généré dans la console VOD dans le SDK Player pour la vérification de déchiffrement lors du téléchargement et de la lecture vidéo. Pour la génération du fichier de clé, consultez Activer le téléchargement sécurisé.

   Nous recommandons de configurer cela une seule fois dans Application. Exemple :

   PrivateService.initService(getApplicationContext(),  "Path to encryptedApp.dat file"); // We recommend storing the encryptedApp.dat verification file on the phone and setting its local file path here.

2. Créez et configurez le téléchargeur.

   Créez un téléchargeur à l'aide d'AliDownloaderFactory. Exemple :

   AliMediaDownloader mAliDownloader = null;
   ......
   // Create downloader.
   mAliDownloader = AliDownloaderFactory.create(getApplicationContext());
   // Configure download save path.
   mAliDownloader.setSaveDir("Save folder path");

3. Configurez les écouteurs d'événements.

   Le téléchargeur fournit plusieurs écouteurs d'événements. Exemple :

   Développer pour voir le code

   mAliDownloader.setOnPreparedListener(new AliMediaDownloader.OnPreparedListener() {
      @Override
      public void onPrepared(MediaInfo mediaInfo) {
          // Download item prepared successfully.
      }
   });
   mAliDownloader.setOnProgressListener(new AliMediaDownloader.OnProgressListener() {
      @Override
      public void onDownloadingProgress(int percent) {
          // Download progress percentage.
      }
      @Override
      public void onProcessingProgress(int percent) {
          // Processing progress percentage.
      }
   });
   mAliDownloader.setOnErrorListener(new AliMediaDownloader.OnErrorListener() {
      @Override
      public void onError(ErrorInfo errorInfo) {
          // Download error.
      }
   });
   mAliDownloader.setOnCompletionListener(new AliMediaDownloader.OnCompletionListener() {
      @Override
      public void onCompletion() {
          // Download successful.
      }
   });

4. Préparez la source de téléchargement.

   Préparez la source de téléchargement à l'aide de la méthode prepare. Les sources de téléchargement prennent en charge les méthodes VidSts et VidAuth. Exemples :

   • VidSts

     // Create VidSts
     VidSts aliyunVidSts = new VidSts();
     aliyunVidSts.setVid("Vid information"); // Video ID (VideoId).
     aliyunVidSts.setAccessKeyId("<yourAccessKeyId>"); // AccessKey ID of the temporary STS AccessKey pair, generated by calling the AssumeRole operation of the Security Token Service (STS).
     aliyunVidSts.setAccessKeySecret("<yourAccessKeySecret>"); // AccessKey secret of the temporary STS AccessKey pair, generated by calling the AssumeRole operation of the Security Token Service (STS).
     aliyunVidSts.setSecurityToken("<yourSecurityToken>"); // Security Token Service (STS) token, generated by calling the AssumeRole operation of the Security Token Service (STS).
     aliyunVidSts.setRegion("region"); // The region of the video-on-demand (VOD) service. Default value: cn-shanghai.
     // If you have enabled HLS encryption parameter pass-through in the VOD console and the default parameter name is MtsHlsUriToken,
     // you must set the config and pass it into the vid, as shown below.
     // If you have not enabled HLS encryption parameter pass-through in the VOD console, skip the following code.
     VidPlayerConfigGen vidConfig = new VidPlayerConfigGen();
     vidConfig.setMtsHlsUriToken("<yourMtsHlsUriToken>");
     aliyunVidSts.setPlayerConfig(vidConfig);
             
     
     // Prepare the download source
     mAliDownloader.prepare(aliyunVidSts)

   • VidAuth

     // Create VidAuth.
     VidAuth vidAuth = new VidAuth();
     vidAuth.setVid("Vid info");// Video ID.
     vidAuth.setPlayAuth("<yourPlayAuth>");// Playback credential, generated by calling VOD GetVideoPlayAuth API.
     vidAuth.setRegion("Access region");// For player SDK version 5.5.5.0 and later, this parameter is deprecated and not required; the player automatically parses the region. For versions before 5.5.5.0, this parameter is required; VOD access region default is cn-shanghai.
     // If you enabled HLS standard encryption parameter pass-through in VOD console with default parameter name MtsHlsUriToken, set config and pass it to vid as follows.
     VidPlayerConfigGen vidConfig = new VidPlayerConfigGen();
     vidConfig.setMtsHlsUriToken("<yourMtsHlsUriToken>");
     vidAuth.setPlayerConfig(config);
     // Prepare download source.
     mAliDownloader.prepare(vidAuth);

   Remarque

   • Le format du fichier source correspond au format du fichier téléchargé ; le modifier n'est pas pris en charge.

   • Si vous avez activé le transfert de paramètre de chiffrement standard HLS dans la console VOD avec le nom de paramètre par défaut MtsHlsUriToken, consultez Transfert de paramètre de chiffrement standard HLS, puis définissez la valeur MtsHlsUriToken dans la source VOD comme indiqué ci-dessus.

5. Après une préparation réussie, sélectionnez l'élément de téléchargement et démarrez le téléchargement.

   Après une préparation réussie, la méthode OnPreparedListener est appelée. Le TrackInfo renvoyé contient des informations telles que la définition du flux vidéo. Sélectionnez un Track pour le téléchargement. Exemple :

   public void onPrepared(MediaInfo mediaInfo) {
       // Download item prepared successfully.
       List<TrackInfo> trackInfos = mediaInfo.getTrackInfos();
       // For example: download the first TrackInfo.
       mAliDownloader.selectItem(trackInfos.get(0).getIndex());
       // Start download.
       mAliDownloader.start();
   }

6. (Facultatif) Mettez à jour la source de téléchargement.

   Pour éviter l'expiration de VidSts et VidAuth, vous pouvez mettre à jour les informations de la source de téléchargement et démarrer le téléchargement. Exemple :

   // Update download source.
   mAliDownloader.updateSource(VidSts);
   // Start download.
   mAliDownloader.start();

7. Après un succès ou un échec du téléchargement, libérez le téléchargeur.

   Après un téléchargement réussi, appelez release dans le rappel onCompletion ou onError pour libérer le téléchargeur. Exemple :

   mAliDownloader.stop();
   mAliDownloader.release();

8. Facultatif : Supprimez les fichiers téléchargés.

   Vous pouvez supprimer les fichiers téléchargés pendant ou après le téléchargement. Exemple :

   // Delete file via object.
   mAliDownloader.deleteFile();
   // Delete via static method; returns 0 if successful.
   AliDownloaderFactory.deleteFile("Path to download folder","Video ID","Video format","Downloaded video index");

Étapes suivantes

Les vidéos téléchargées peuvent être lues à l'aide d'ApsaraVideo Player. Étapes :

1. Une fois le téléchargement terminé, obtenez le chemin absolu du fichier vidéo.

   String path = mAliDownloader.getFilePath();

2. Définissez le chemin absolu via VOD UrlSource pour la lecture.

    UrlSource urlSource = new UrlSource();
           urlSource.setUri("Playback address");// Set absolute path of downloaded video.
           aliPlayer.setDataSource(urlSource);