ApsaraVideo Live:Appels audio et vidéo sur Android

Étape 1 : Importer le SDK

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        // Add the Maven repositories for the ARTC SDK
        maven { url 'https://maven.aliyun.com/repository/google' }
        maven { url 'https://maven.aliyun.com/repository/public' }
    }
}

allprojects {
    repositories {
        ...
        // Add the Maven repositories for the ARTC SDK
        maven { url 'https://maven.aliyun.com/repository/google' }
        maven { url 'https://maven.aliyun.com/repository/public' }
    }
}

dependencies {
    // Add the dependency for the real-time audio and video SDK// Replace ${latest_version} with a specific version number
    implementation 'com.aliyun.aio:AliVCSDK_ARTC:${latest_version}'// For versions 7.4.0 and earlier, you must add the keep dependency// implementation 'com.aliyun.aio.keep:keep:1.0.1'
}

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        // Add the relative path to the directory where the ARTC SDK is locatedflatDir {
            dir 'app/libs'
        }
    }
}

allprojects {
    repositories {
        ...
        // Add the relative path to the directory where the ARTC SDK is locatedflatDir {
            dir 'app/libs'
        }
    }
}

// Replace x.y.z with the corresponding version number
implementation(name:'AliVCSDK_ARTC', version: 'x.y.z', ext:'aar')

Étape 2 : Spécifier les architectures CPU prises en charge

Ouvrez le fichier app/build.gradle et spécifiez les architectures CPU prises en charge dans le bloc defaultConfig. Les architectures disponibles incluent armeabi-v7a, arm64-v8a, x86, and x86_64. Sélectionnez les architectures dont vous avez besoin.

android {
    defaultConfig {
        // ...other default configurations// Support for armeabi-v7a and arm64-v8a architectures
        ndk {
             abiFilters "armeabi-v7a", "arm64-v8a"
        }
    }
}	

Étape 3 : Définir les permissions

Configurez les permissions nécessaires à votre application.

Accédez au répertoire app/src/main, ouvrez le fichier AndroidManifest.xml et ajoutez les permissions requises.

<uses-feature android:name="android.hardware.camera" android:required="false" /><uses-permission android:name="android.permission.CAMERA" /><uses-permission android:name="android.permission.RECORD_AUDIO" /><uses-permission android:name="android.permission.INTERNET" /><uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /><!-- Request legacy Bluetooth permissions on older devices. --><uses-permissionandroid:name="android.permission.BLUETOOTH"android:maxSdkVersion="30" /><uses-permissionandroid:name="android.permission.BLUETOOTH_ADMIN"android:maxSdkVersion="30" /><!-- Needed only if your app communicates with already-paired Bluetooth devices. --><uses-permission android:name="android.permission.BLUETOOTH_CONNECT" /><uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" /><uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" /><uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" /><uses-permission android:name="android.permission.READ_PHONE_STATE" /><uses-permission android:name="android.permission.WRITE_SETTINGS"tools:ignore="ProtectedPermissions" /><uses-permission android:name="android.permission.FOREGROUND_SERVICE" />

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" /><uses-permission android:name="android.permission.ACCESS_WIFI_STATE" /><uses-permission android:name="android.permission.BLUETOOTH" /><uses-permission android:name="android.permission.BLUETOOTH_CONNECT" /><uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />

<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" tools:node="remove"/>

<!-- Declare the Bluetooth permission --><uses-permission android:name="android.permission.BLUETOOTH" /><!-- Override and remove the permission for API 31+ --><uses-permission android:name="android.permission.BLUETOOTH_CONNECT" tools:node="remove" />

<!-- Declare the Bluetooth permission and set android:maxSdkVersion to 30 for compatibility with earlier devices --><uses-permission android:name="android.permission.BLUETOOTH"/><!-- Declare the Bluetooth permission for API 31+ --><uses-permission android:name="android.permission.BLUETOOTH_CONNECT"/><!-- Other Bluetooth permissions -->

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
    String[] permissions = {
        android.Manifest.permission.BLUETOOTH_CONNECT
    };
    ActivityCompat.requestPermissions(activity, permissions, REQUEST_BLUETOOTH);
}

<!-- Override and remove the Bluetooth permission declarations from the ARTC SDK --><uses-permission android:name="android.permission.BLUETOOTH" tools:node="remove" /><uses-permission android:name="android.permission.BLUETOOTH_CONNECT" tools:node="remove" />

Étape 4 : Empêcher l'obfuscation du code (facultatif)

Dans le fichier app/proguard-rules.pro, ajoutez les règles ProGuard suivantes pour empêcher l'obfuscation des interfaces publiques du SDK.

-keep class com.aliyun.allinone.** {*;}-keep class com.aliyun.rts.network.AliHttpTool {*;}-keep class com.aliyun.common.AlivcBase {*;}-keep class com.huawei.multimedia.alivc.** {*;}-keep class com.alivc.rtc.** {*;}-keep class com.alivc.component.** {*;}-keep class org.webrtc.** {*;}

FAQ

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" /><uses-permission android:name="android.permission.ACCESS_WIFI_STATE" /><uses-permission android:name="android.permission.BLUETOOTH" /><uses-permission android:name="android.permission.BLUETOOTH_CONNECT" /><uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />

Cette section explique comment utiliser l'ARTC SDK pour créer une application audio et vidéo en temps réel de base. Copiez l'exemple de code pour effectuer un test rapide, puis suivez les étapes afin de comprendre les appels API fondamentaux.

Le diagramme suivant illustre le flux de travail de base d'un appel audio et vidéo en temps réel :

1. Demander les permissions

Avant de lancer un appel vidéo, vérifiez que votre application dispose des permissions requises :

private static final int REQUEST_PERMISSION_CODE = 101;

private static final String[] PERMISSION_MANIFEST = {
    Manifest.permission.RECORD_AUDIO,
    Manifest.permission.READ_PHONE_STATE,
    Manifest.permission.WRITE_EXTERNAL_STORAGE,
    Manifest.permission.READ_EXTERNAL_STORAGE,
    Manifest.permission.CAMERA
};

private static final String[] PERMISSION_MANIFEST33 = {
    Manifest.permission.RECORD_AUDIO,
    Manifest.permission.READ_PHONE_STATE,
    Manifest.permission.CAMERA
};

private static String[] getPermissions() {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
        return PERMISSION_MANIFEST;
    }
    return PERMISSION_MANIFEST33;
}

public boolean checkOrRequestPermission() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        if (ContextCompat.checkSelfPermission(this, "android.permission.CAMERA") != PackageManager.PERMISSION_GRANTED
                || ContextCompat.checkSelfPermission(this, "android.permission.RECORD_AUDIO") != PackageManager.PERMISSION_GRANTED) {
            requestPermissions(getPermissions(), REQUEST_PERMISSION_CODE);
            return false;
        }
    }
    return true;
}

2. Obtenir un jeton d'authentification

Rejoindre un canal ARTC nécessite un jeton d'authentification. Pour savoir comment générer un jeton, consultez Authentification basée sur des jetons. La méthode de génération du jeton (à paramètre unique ou multi-paramètres) détermine quelle API joinChannel appeler.

Environnement de production :

La génération d'un jeton requiert votre AppKey. Coder en dur l'AppKey côté client constitue un risque de sécurité. Nous vous recommandons donc vivement de générer les jetons sur votre serveur d'application avant de les transmettre au client.

Développement et débogage :

Pendant la phase de développement, si votre serveur d'application ne peut pas encore générer de jetons, utilisez l'exemple suivant pour créer des jetons temporaires :

public final class ARTCTokenHelper {
    /**
     * RTC AppId
     */
    public static String AppId = "";

    /**
     * RTC AppKey
     */
    public static String AppKey = "";

    /**
     * Generate a single-parameter meeting token based on channelId, userId, and nonce
     */
    public static String generateSingleParameterToken(String appId, String appKey, String channelId, String userId, long timestamp,  String nonce) {

        StringBuilder stringBuilder = new StringBuilder()
                .append(appId)
                .append(appKey)
                .append(channelId)
                .append(userId)
                .append(timestamp);
        String token =  getSHA256(stringBuilder.toString());
        try{
            JSONObject tokenJson = new JSONObject();
            tokenJson.put("appid", AppId);
            tokenJson.put("channelid", channelId);
            tokenJson.put("userid", userId);
            tokenJson.put("nonce", nonce);
            tokenJson.put("timestamp", timestamp);
            tokenJson.put("token", token);
            String base64Token = Base64.encodeToString(tokenJson.toString().getBytes(StandardCharsets.UTF_8), Base64.NO_WRAP);
            return base64Token;
        }catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * Generate a single-parameter meeting token based on channelId, userId, and timestamp
     */
    public static String generateSingleParameterToken(String appId, String appKey, String channelId, String userId, long timestamp) {
        return generateSingleParameterToken(appId, appKey, channelId, userId, timestamp, "");
    }

    public static String getSHA256(String str) {
        try {
            MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
            byte[] hash = messageDigest.digest(str.getBytes(StandardCharsets.UTF_8));
            return byte2Hex(hash);
        } catch (NoSuchAlgorithmException e) {
            // Consider logging the exception and/or re-throwing as a RuntimeException
            e.printStackTrace();
        }
        return "";
    }

    private static String byte2Hex(byte[] bytes) {
        StringBuilder stringBuilder = new StringBuilder();
        for (byte b : bytes) {
            String hex = Integer.toHexString(0xff & b);
            if (hex.length() == 1) {
                // Use single quote for char
                stringBuilder.append('0');
            }
            stringBuilder.append(hex);
        }
        return stringBuilder.toString();
    }

    public static long getTimesTamp() {
        return System.currentTimeMillis() / 1000 + 60 * 60 * 24;
    }
}

3. Importer les classes du SDK ARTC

Importez les classes et interfaces du SDK ARTC :

// Import ARTC classes
import com.alivc.rtc.AliRtcEngine;
import com.alivc.rtc.AliRtcEngineEventListener;
import com.alivc.rtc.AliRtcEngineNotify;

4. Créer et initialiser le moteur

• Créer le moteur RTC

  Appelez la méthode getInstance[1/2] pour créer une instance AliRTCEngine.

  private AliRtcEngine mAliRtcEngine = null;
  if(mAliRtcEngine == null) {
      mAliRtcEngine = AliRtcEngine.getInstance(this);
  }

• Initialiser le moteur

  • Appelez setChannelProfile pour définir le profil du canal sur AliRTCSdkInteractiveLive (mode interactif).

    Choisissez entre le mode interactif pour le divertissement et le mode communication pour les appels. La sélection du mode approprié garantit une expérience utilisateur fluide et une utilisation efficace du réseau.

    Mode	Publication	Abonnement	Description
    Mode interactif	Des restrictions basées sur les rôles s'appliquent. Seuls les utilisateurs ayant le rôle d'hôte peuvent publier des flux. Les participants peuvent changer de rôle à tout moment pendant la session.	Aucune restriction de rôle. Tous les participants ont l'autorisation de s'abonner aux flux.	En mode interactif, les événements tels que l'arrivée ou le départ d'un hôte sont envoyés aux spectateurs. L'activité d'un spectateur n'est pas transmise à l'hôte, ce qui assure une expérience ininterrompue pour ce dernier. Si vous prévoyez que les spectateurs puissent avoir besoin d'interagir ultérieurement, nous recommandons d'utiliser le mode interactif. Sa flexibilité permet d'ajuster les rôles des utilisateurs pour répondre à différents besoins d'interaction.
    Mode communication	Aucune restriction de rôle. Tous les participants ont l'autorisation de publier des flux.	Aucune restriction de rôle. Tous les participants ont l'autorisation de s'abonner aux flux.	En mode communication, les participants sont informés de la présence des autres dans la session. Bien que ce mode ne différencie pas les rôles des utilisateurs, il est fonctionnellement équivalent au rôle d'hôte en mode interactif. Cela simplifie les opérations et permet aux utilisateurs d'obtenir les fonctionnalités souhaitées avec moins d'appels API.

  • Appelez setClientRole pour définir le rôle de l'utilisateur sur AliRTCSdkInteractive (hôte) ou AliRTCSdkLive (spectateur). Remarque : Le rôle d'hôte publie et s'abonne par défaut. Le rôle de spectateur s'abonne uniquement par défaut, tandis que la prévisualisation et la publication sont désactivées.

    Remarque

    Lorsqu'un utilisateur change de rôle dans un canal, le système ajuste automatiquement l'état de publication des flux audio et vidéo :

    • Passage d'hôte à spectateur : Le système arrête la publication des flux audio et vidéo locaux. Les flux distants abonnés ne sont pas affectés et l'utilisateur peut continuer à regarder les autres participants.

    • Passage de spectateur à hôte : Le système démarre la publication des flux audio et vidéo locaux. Les flux distants abonnés restent inchangés et l'utilisateur peut continuer à regarder les autres participants.

    // Set the channel profile to interactive mode. In RTC, always use AliRTCSdkInteractiveLive.
    mAliRtcEngine.setChannelProfile(AliRtcEngine.AliRTCSdkChannelProfile.AliRTCSdkInteractiveLive);
    // Set the user role. Use AliRTCSdkInteractive to both publish and subscribe to streams, or AliRTCSdkLive to only subscribe.
    mAliRtcEngine.setClientRole(AliRtcEngine.AliRTCSdkClientRole.AliRTCSdkInteractive);

• Configurer les callbacks courants

  Lorsque le SDK rencontre un problème, il tente d'abord une récupération automatique. Pour les erreurs qu'il ne peut pas résoudre, le SDK notifie votre application via des callbacks.

  Voici les principaux callbacks pour les problèmes irrécupérables que votre application doit gérer :

  Cause de l'exception	Callback et paramètres	Solution	Description
  Échec de l'authentification	Le paramètre result du callback onJoinChannelResult est AliRtcErrJoinBadToken.	Votre application doit vérifier si le token est correct.	Si l'authentification échoue lorsqu'un utilisateur appelle une API, le callback renvoie une erreur d'échec d'authentification.
  Expiration imminente du token	onAuthInfoWillExpire	Obtenez un nouveau token et appelez refreshAuthInfo pour mettre à jour les informations d'authentification.	Une erreur d'expiration du token peut survenir lors d'un appel API ou pendant l'exécution. L'erreur est signalée via un callback API ou un callback d'erreur distinct.
  Token expiré	onAuthInfoExpired	Votre application doit rejoindre le canal à nouveau.	Une erreur d'expiration du token peut survenir lors d'un appel API ou pendant l'exécution. L'erreur est signalée via un callback API ou un callback d'erreur distinct.
  Problème de connexion réseau	Le callback onConnectionStatusChange renvoie AliRtcConnectionStatusFailed.	Votre application doit rejoindre le canal à nouveau.	Le SDK récupère automatiquement après de brèves déconnexions réseau. Si la déconnexion dépasse un seuil prédéfini, un délai d'attente se produit et la connexion est interrompue. Votre application doit vérifier l'état du réseau et inviter l'utilisateur à rejoindre le canal.
  Exclusion du canal	onBye	AliRtcOnByeUserReplaced : Vérifiez si un autre utilisateur a rejoint avec le même userId. AliRtcOnByeBeKickedOut : L'utilisateur a été exclu du canal par le serveur d'application et doit le rejoindre à nouveau. AliRtcOnByeChannelTerminated : Le canal a été terminé et l'utilisateur doit le rejoindre à nouveau.	Le service RTC permet à un administrateur de retirer des participants.
  Exception de périphérique local	onLocalDeviceException	Votre application doit vérifier les permissions et le bon fonctionnement du matériel.	Le service RTC prend en charge la détection et le diagnostic des périphériques. Lorsqu'une exception de périphérique local survient et que le SDK ne peut pas la résoudre, il notifie votre application via un callback. Votre application doit alors vérifier l'état du périphérique.

  private AliRtcEngineEventListener mRtcEngineEventListener = new AliRtcEngineEventListener() {
      @Override
      public void onJoinChannelResult(int result, String channel, String userId, int elapsed) {
          super.onJoinChannelResult(result, channel, userId, elapsed);
          handleJoinResult(result, channel, userId);
      }
  
      @Override
      public void onLeaveChannelResult(int result, AliRtcEngine.AliRtcStats stats){
          super.onLeaveChannelResult(result, stats);
      }
  
      @Override
      public void onConnectionStatusChange(AliRtcEngine.AliRtcConnectionStatus status, AliRtcEngine.AliRtcConnectionStatusChangeReason reason){
          super.onConnectionStatusChange(status, reason);
  
          handler.post(new Runnable() {
              @Override
              public void run() {
                  if(status == AliRtcEngine.AliRtcConnectionStatus.AliRtcConnectionStatusFailed) {
                      /* TODO: This callback must be handled. It is triggered only after the SDK's internal recovery strategies fail. We recommend notifying the user. */
                      ToastHelper.showToast(VideoChatActivity.this, R.string.video_chat_connection_failed, Toast.LENGTH_SHORT);
                  } else {
                      /* TODO: Optional. Add business logic here, such as for data analytics or UI updates. */
                  }
              }
          });
      }
      @Override
      public void onLocalDeviceException(AliRtcEngine.AliRtcEngineLocalDeviceType deviceType, AliRtcEngine.AliRtcEngineLocalDeviceExceptionType exceptionType, String msg){
          super.onLocalDeviceException(deviceType, exceptionType, msg);
          /* TODO: This callback must be handled. It is triggered only after the SDK's internal recovery strategies fail. We recommend notifying the user of the device error. */
          handler.post(new Runnable() {
              @Override
              public void run() {
                  String str = "OnLocalDeviceException deviceType: " + deviceType + " exceptionType: " + exceptionType + " msg: " + msg;
                  ToastHelper.showToast(VideoChatActivity.this, str, Toast.LENGTH_SHORT);
              }
          });
      }
  
  };
  
  private AliRtcEngineNotify mRtcEngineNotify = new AliRtcEngineNotify() {
      @Override
      public void onAuthInfoWillExpire() {
          super.onAuthInfoWillExpire();
          /* TODO: This must be handled. The token is about to expire. Your app must get a new authentication token for the current channel and user, and then call refreshAuthInfo. */
      }
  
      @Override
      public void onRemoteUserOnLineNotify(String uid, int elapsed){
          super.onRemoteUserOnLineNotify(uid, elapsed);
      }
  
      // In the onRemoteUserOffLineNotify callback, unbind the renderer for the remote video stream.
      @Override
      public void onRemoteUserOffLineNotify(String uid, AliRtcEngine.AliRtcUserOfflineReason reason){
          super.onRemoteUserOffLineNotify(uid, reason);
      }
  
      // In the onRemoteTrackAvailableNotify callback, set up the renderer for the remote video stream.
      @Override
      public void onRemoteTrackAvailableNotify(String uid, AliRtcEngine.AliRtcAudioTrack audioTrack, AliRtcEngine.AliRtcVideoTrack videoTrack){
          handler.post(new Runnable() {
              @Override
              public void run() {
                  if(videoTrack == AliRtcVideoTrackCamera) {
                      SurfaceView surfaceView = mAliRtcEngine.createRenderSurfaceView(VideoChatActivity.this);
                      surfaceView.setZOrderMediaOverlay(true);
                      FrameLayout view = getAvailableView();
                      if (view == null) {
                          return;
                      }
                      remoteViews.put(uid, view);
                      view.addView(surfaceView, new FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
                      AliRtcEngine.AliRtcVideoCanvas remoteVideoCanvas = new AliRtcEngine.AliRtcVideoCanvas();
                      remoteVideoCanvas.view = surfaceView;
                      mAliRtcEngine.setRemoteViewConfig(remoteVideoCanvas, uid, AliRtcVideoTrackCamera);
                  } else if(videoTrack == AliRtcVideoTrackNo) {
                      if(remoteViews.containsKey(uid)) {
                          ViewGroup view = remoteViews.get(uid);
                          if(view != null) {
                              view.removeAllViews();
                              remoteViews.remove(uid);
                              mAliRtcEngine.setRemoteViewConfig(null, uid, AliRtcVideoTrackCamera);
                          }
                      }
                  }
              }
          });
      }
  
      /* Your app must handle cases where multiple devices attempt to join with the same userId. */
      @Override
      public void onBye(int code){
          handler.post(new Runnable() {
              @Override
              public void run() {
                  String msg = "onBye code:" + code;
                  ToastHelper.showToast(VideoChatActivity.this, msg, Toast.LENGTH_SHORT);
              }
          });
      }
  };
  
  mAliRtcEngine.setRtcEngineEventListener(mRtcEngineEventListener);
  mAliRtcEngine.setRtcEngineNotify(mRtcEngineNotify);

5. Définir les propriétés audio et vidéo

• Définir les propriétés audio

  Appelez setAudioProfile pour configurer le mode d'encodage audio et le scénario audio.

  mAliRtcEngine.setAudioProfile(AliRtcEngine.AliRtcAudioProfile.AliRtcEngineHighQualityMode, AliRtcEngine.AliRtcAudioScenario.AliRtcSceneMusicMode);

• Définir les propriétés vidéo

  Configurez les propriétés du flux vidéo publié, telles que la résolution, le débit binaire et la fréquence d'images.

  // Set video encoding parameters.
  AliRtcEngine.AliRtcVideoEncoderConfiguration aliRtcVideoEncoderConfiguration = new AliRtcEngine.AliRtcVideoEncoderConfiguration();
  aliRtcVideoEncoderConfiguration.dimensions = new AliRtcEngine.AliRtcVideoDimensions(
                  720, 1280);
  aliRtcVideoEncoderConfiguration.frameRate = 20;
  aliRtcVideoEncoderConfiguration.bitrate = 1200;
  aliRtcVideoEncoderConfiguration.keyFrameInterval = 2000;
  aliRtcVideoEncoderConfiguration.orientationMode = AliRtcVideoEncoderOrientationModeAdaptive;
  mAliRtcEngine.setVideoEncoderConfiguration(aliRtcVideoEncoderConfiguration);

6. Configurer les propriétés de publication et d'abonnement

Configurez la publication des flux et le comportement d'abonnement par défaut :

• Appelez publishLocalAudioStream pour publier le flux audio.

• Appelez publishLocalVideoStream pour publier le flux vidéo. Pour un appel audio uniquement, définissez cette valeur sur false.

// The SDK publishes audio by default, so you do not need to call publishLocalAudioStream.
mAliRtcEngine.publishLocalAudioStream(true);
// For a video call, you do not need to call publishLocalVideoStream(true) because the SDK publishes video by default.
// For an audio-only call, you must call publishLocalVideoStream(false) to disable video publishing.
mAliRtcEngine.publishLocalVideoStream(true);

// Set the default to subscribe to remote audio and video streams.
mAliRtcEngine.setDefaultSubscribeAllRemoteAudioStreams(true);
mAliRtcEngine.subscribeAllRemoteAudioStreams(true);
mAliRtcEngine.setDefaultSubscribeAllRemoteVideoStreams(true);
mAliRtcEngine.subscribeAllRemoteVideoStreams(true);

7. Démarrer la prévisualisation locale

• Appelez setLocalViewConfig pour configurer la vue de prévisualisation locale. Cela nécessite un objet AliRtcVideoCanvas.

• Appelez la méthode startPreview pour lancer la prévisualisation vidéo locale.

mLocalVideoCanvas = new AliRtcEngine.AliRtcVideoCanvas();
SurfaceView localSurfaceView = mAliRtcEngine.createRenderSurfaceView(VideoChatActivity.this);
localSurfaceView.setZOrderOnTop(true);
localSurfaceView.setZOrderMediaOverlay(true);
FrameLayout fl_local = findViewById(R.id.fl_local);
fl_local.addView(localSurfaceView, layoutParams);
mLocalVideoCanvas.view = localSurfaceView;
mAliRtcEngine.setLocalViewConfig(mLocalVideoCanvas, AliRtcVideoTrackCamera);
mAliRtcEngine.startPreview();

8. Rejoindre le canal

Appelez joinChannel pour rejoindre un canal. Si le token est généré selon la règle à paramètre unique, appelez l'interface [joinChannel[1/3]](t2309760.xdita#758b964acc7jd) à paramètre unique du SDK. Si le token est généré selon la règle multi-paramètres, appelez l'interface [joinChannel[2/3]](t2309760.xdita#766e40a1cfk4p) multi-paramètres du SDK. Une fois le canal rejoint, le callback onJoinChannelResult fournit le résultat. Si result vaut 0, vous avez rejoint le canal avec succès. Sinon, vérifiez si le token fourni est invalide.

 mAliRtcEngine.joinChannel(token, null, null, null);

9. Configurer la vue distante

Lors de l'initialisation du moteur, configurez le callback mAliRtcEngine.setRtcEngineNotify. Dans le callback onRemoteTrackAvailableNotify, configurez la vue distante pour chaque utilisateur distant :

@Override
public void onRemoteTrackAvailableNotify(String uid, AliRtcEngine.AliRtcAudioTrack audioTrack, AliRtcEngine.AliRtcVideoTrack videoTrack){
    handler.post(new Runnable() {
        @Override
        public void run() {
            if(videoTrack == AliRtcVideoTrackCamera) {
                SurfaceView surfaceView = mAliRtcEngine.createRenderSurfaceView(VideoChatActivity.this);
                surfaceView.setZOrderMediaOverlay(true);
                FrameLayout fl_remote = findViewById(R.id.fl_remote);
                if (fl_remote == null) {
                    return;
                }
                fl_remote.addView(surfaceView, new FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
                AliRtcEngine.AliRtcVideoCanvas remoteVideoCanvas = new AliRtcEngine.AliRtcVideoCanvas();
                remoteVideoCanvas.view = surfaceView;
                mAliRtcEngine.setRemoteViewConfig(remoteVideoCanvas, uid, AliRtcVideoTrackCamera);
            } else if(videoTrack == AliRtcVideoTrackNo) {
                FrameLayout fl_remote = findViewById(R.id.fl_remote);
                fl_remote.removeAllViews();
                mAliRtcEngine.setRemoteViewConfig(null, uid, AliRtcVideoTrackCamera);
            }
        }
    });
}

10. Quitter le canal et détruire le moteur

Lorsque la session audio et vidéo se termine, quittez le canal et détruisez le moteur :

1. Appelez stopPreview pour arrêter la prévisualisation vidéo.

2. Appelez leaveChannel pour quitter le canal.

3. Appelez destroy pour détruire le moteur et libérer ses ressources.

private void destroyRtcEngine() {
    mAliRtcEngine.stopPreview();
    mAliRtcEngine.setLocalViewConfig(null, AliRtcVideoTrackCamera);
    mAliRtcEngine.leaveChannel();
    mAliRtcEngine.destroy();
    mAliRtcEngine = null;
}

11. Démonstration