Tous les produits
Search
Centre de documentation

:Android

Dernière mise à jour :Aug 19, 2026

Cette rubrique explique comment intégrer le SDK ApsaraVideo Player au SDK RTS natif sur Android pour activer RTS.

Intégration du SDK

Ajoutez les dépendances du SDK ApsaraVideo Player et du SDK RTS natif en utilisant l'une des méthodes suivantes :

  • Méthode 1 : Intégration via Maven

    1. Dans le fichier app/build.gradle de votre projet, ajoutez les dépendances pour le SDK ApsaraVideo Player et le SDK RTS natif.

      implementation 'com.aliyun.sdk.android:AlivcArtc:5.4.4.0'
      implementation 'com.aliyun.rts.android:RtsSDK:2.1.0'
      implementation 'com.aliyun.sdk.android:AliyunPlayer:5.4.4.0-full'
      Remarque
      • Une fois que vous avez ajouté les dépendances AlivcArtc et RtsSDK, le SDK ApsaraVideo Player charge automatiquement le SDK RTS en tant que plug-in.

      • La version de la dépendance Maven fournie ici est donnée à titre indicatif. Pour connaître la dernière version du SDK ApsaraVideo Player, consultez Historique des versions du SDK Android. Pour la dernière version du SDK RTS, consultez Diffusion RTS sur Android.

      • Assurez-vous que les versions du SDK ApsaraVideo Player et du SDK RTS natif sont compatibles. Pour plus d'informations, consultez Compatibilité des versions du SDK.

    2. Ajoutez les URL des dépôts Maven.

      Ajoutez ces URL au fichier build.gradle situé dans le répertoire racine de votre projet.

      // The Maven repository for MPChart. You can remove this if you do not need charts.
      maven { url 'https://jitpack.io' }
      // The Maven repository for Alibaba Cloud SDKs (ApsaraVideo Player SDK, RTS SDK).
      maven { url 'http://maven.aliyun.com/nexus/content/repositories/releases' }
  • Méthode 2 : Intégration manuelle des fichiers AAR

    1. Copiez les fichiers .aar requis dans le répertoire app/libs.aar文件

    2. Dans le fichier app/build.gradle, ajoutez le code suivant :

      dependencies{
          implementation fileTree(dir: 'libs', include: ['*.aar'])
      }

Utilisation de l'API du SDK

Appelez l'API du SDK ApsaraVideo Player pour utiliser la fonctionnalité RTS. Pour plus d'informations sur les autres fonctionnalités du SDK ApsaraVideo Player, consultez Fonctionnalités avancées et Référence de l'API.

Remarque
  • Les extraits de code suivants sont fournis à titre d'exemple. Pour obtenir le code source complet, consultez notre projet open source.

  • Lors de la lecture d'un flux RTS avec le SDK ApsaraVideo Player, vous ne pouvez pas appeler la méthode pause() pour mettre en pause le flux en direct. Vous devez plutôt appeler stop() pour arrêter la lecture, puis appeler prepare() pour la redémarrer.

  • L'opération seek n'est pas prise en charge.

  • Chargement de la bibliothèque

    Ajoutez System.loadLibrary("RtsSDK"); à l'Activity appropriée.

    static {
        System.loadLibrary("RtsSDK");
    }
  • Création d'un lecteur

    La classe AliPlayerFactory propose deux types de lecteurs : AliPlayer et AliListPlayer. Pour lire une seule source multimédia, utilisez AliPlayer. Le code suivant montre comment créer une instance AliPlayer :

    AliPlayer aliyunVodPlayer;
    .....
    aliyunVodPlayer = AliPlayerFactory.createAliPlayer(getApplicationContext());
  • Définition des écouteurs du lecteur

    Le lecteur fournit divers écouteurs pour gérer les événements, tels que onPrepared et onCompletion. Le code suivant montre comment définir ces écouteurs :

    aliyunVodPlayer.setOnErrorListener(new IPlayer.OnErrorListener() {
        @Override
        public void onError(ErrorInfo errorInfo) {
            // Called when an error occurs.
        }
    });
    aliyunVodPlayer.setOnPreparedListener(new IPlayer.OnPreparedListener() {
        @Override
        public void onPrepared() {
            // Called when the player is prepared.
        }
    });
    aliyunVodPlayer.setOnVideoSizeChangedListener(new IPlayer.OnVideoSizeChangedListener() {
        @Override
        public void onVideoSizeChanged(int width, int height) {
            // Called when the video resolution changes.
        }
    });
    aliyunVodPlayer.setOnRenderingStartListener(new IPlayer.OnRenderingStartListener() {
        @Override
        public void onRenderingStart() {
            // Called when the first frame is rendered.
        }
    });
    aliyunVodPlayer.setOnInfoListener(new IPlayer.OnInfoListener() {
        @Override
        public void onInfo(int type, long extra) {
            // Called for playback information events, such as loop start, buffering progress, or current position.
        }
    });
    aliyunVodPlayer.setOnLoadingStatusListener(new IPlayer.OnLoadingStatusListener() {
        @Override
        public void onLoadingBegin() {
            // Called when buffering starts.
        }
        @Override
        public void onLoadingProgress(int percent, float kbps) {
            // Buffering progress.
        }
        @Override
        public void onLoadingEnd() {
            // Called when buffering finishes.
        }
    });
    aliyunVodPlayer.setOnSubtitleDisplayListener(new IPlayer.OnSubtitleDisplayListener() {
        @Override
        public void onSubtitleShow(long id, String data) {
            // Called when a subtitle is displayed.
        }
        @Override
        public void onSubtitleHide(long id) {
            // Called when a subtitle is hidden.
        }
    });
    aliyunVodPlayer.setOnTrackChangedListener(new IPlayer.OnTrackChangedListener() {
        @Override
        public void onChangedSuccess(TrackInfo trackInfo) {
            // Called when the track or resolution is switched successfully.
        }
        @Override
        public void onChangedFail(TrackInfo trackInfo, ErrorInfo errorInfo) {
            // Called when switching the track or resolution fails.
        }
    });
    aliyunVodPlayer.setOnStateChangedListener(new IPlayer.OnStateChangedListener() {
        @Override
        public void onStateChanged(int newState) {
            // Called when the player state changes.
        }
    });
    aliyunVodPlayer.setOnSnapShotListener(new IPlayer.OnSnapShotListener() {
        @Override
        public void onSnapShot(Bitmap bm, int with, int height) {
            // Called when a snapshot is captured.
        }
    });
  • Création d'une source de données

    Le lecteur prend en charge quatre types de sources de lecture : VidSts, VidAuth, VidMps et UrlSource. Pour utiliser la fonctionnalité RTS pour la lecture directe via URL, vous devez utiliser le protocole artc:// dans l'URL lors de l'utilisation de UrlSource.

    UrlSource urlSource = new UrlSource();
    urlSource.setUri("artc://");
    aliyunVodPlayer.setDataSource(urlSource);
  • Définition de la vue d'affichage

    Si la source de lecture contient de la vidéo, vous devez définir une vue d'affichage pour rendre les images vidéo. Les vues SurfaceView et TextureView sont prises en charge. L'exemple suivant utilise une vue SurfaceView :

    surfaceView = (SurfaceView) findViewById(R.id.playview);
    surfaceView.getHolder().addCallback(new SurfaceHolder.Callback() {
        @Override
        public void surfaceCreated(SurfaceHolder holder) {
            aliyunVodPlayer.setDisplay(holder);
        }
        @Override
        public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
            aliyunVodPlayer.surfaceChanged();
        }
        @Override
        public void surfaceDestroyed(SurfaceHolder holder) {
            aliyunVodPlayer.setDisplay(null);
        }
    });
  • Contrôle de la lecture

    Vous devez créer votre propre interface utilisateur pour les commandes de lecture et appeler les méthodes correspondantes du lecteur dans les gestionnaires d'événements des boutons. L'exemple suivant présente les opérations de contrôle de base telles que la lecture et l'arrêt :

    // Prepare the player. In the onPrepared callback, call start() to begin playback.
    aliyunVodPlayer.prepare();
    // Start playback.
    aliyunVodPlayer.start();
    // Stop playback.
    aliyunVodPlayer.stop();
    // Reset the player.
    aliyunVodPlayer.reset();
    // Release the player. Once released, the player instance cannot be reused.
    aliyunVodPlayer.release();
  • Configuration des paramètres de lecture

    Configurez les paramètres de lecture pour optimiser les performances de RTS.

    // Get the current configuration.
    PlayerConfig config = mAliyunVodPlayer.getConfig();
    // Set the maximum latency to 1,000 ms. Latency is managed by the ARTC protocol.
    config.mMaxDelayTime = 1000;
    // Set the start buffer and high buffer duration to 10 ms. Buffering is managed by the ARTC protocol.
    config.mHighBufferDuration = 10;
    config.mStartBufferDuration = 10;
    ....// Other settings
    // Apply the configuration to the player.
    mAliyunVodPlayer.setConfig(config);
  • Journalisation

    // Enable logging
    Logger.getInstance(context).enableConsoleLog(true);
    Logger.getInstance(context).setLogLevel(Logger.LogLevel.AF_LOG_LEVEL_TRACE);
    // Disable logging
    Logger.getInstance(context).enableConsoleLog(false);
    Logger.getInstance(context).setLogLevel(Logger.LogLevel.AF_LOG_LEVEL_NONE);
  • Dégradation du flux en direct

    La dégradation du flux en direct est une stratégie de secours qui convertit une URL de lecture avec le préfixe artc:// en une URL HTTP-FLV. Vous pouvez ensuite mettre à jour la source UrlSource du lecteur et redémarrer la lecture.

    /**
     * Degradation strategy
     */
    private void willBeDemoted() {
        mRtsAliPlayer.stop();
        if (mUrl.startsWith("artc://")) {
            setDataSource("http://xxxx.flv");
            mRtsAliPlayer.prepare();
        }
    }
  • Obtention du TraceId

    L'événement InfoCode.DirectComponentMSG dans le rappel onInfo indique un message transmis par le composant RTS sous-jacent. Pour obtenir le TraceId, analysez la chaîne extraMsg de cet événement. Lorsque le message contient code=104 (l'événement d'ID de trace), vous pouvez extraire le TraceId en analysant la sous-chaîne qui suit le délimiteur -sub-.

    private static final int TRACE_ID_CODE = 104;
    
    // Listen for the player's onInfo callback and parse the RTS event message.
    mRtsAliPlayer.setOnInfoListener(infoBean -> {
        if (infoBean.getCode() == InfoCode.DirectComponentMSG) {
            String extraMsg = infoBean.getExtraMsg();
            parseDirectComponentMSG(extraMsg);
        }
    });
    
    private void parseDirectComponentMSG(String msg) {
        if (msg.contains("code=" + TRACE_ID_CODE)) {
            parseTraceId(msg);
        }
    }
    
    /**
     * Parses the TraceId.
     */
    private void parseTraceId(String msg) {
        String[] split = msg.split("-sub-");
        if (split.length >= 1) {
            mTraceId = "RequestId:" + (split[1].substring(0, split[1].length() - 1));
            mTraceId = mTraceId.replace("\"", "").replace("\\", "");
        }
    }