Audio and video calls on Android

Step 1: Import the 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 located
        flatDir {
            dir 'app/libs'
        }
    }
}

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

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

Step 2: Specify supported CPU architectures

Open the app/build.gradle file and specify the supported CPU architectures in the defaultConfig block. Available architectures include armeabi-v7a, arm64-v8a, x86, and x86_64. Select the architectures you require.

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

Step 3: Set permissions

Set the permissions your app needs.

Go to the app/src/main directory, open the AndroidManifest.xml file, and add the required permissions.

<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-permission
  android:name="android.permission.BLUETOOTH"
  android:maxSdkVersion="30" />
<uses-permission
  android: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" />

Step 4: Prevent code obfuscation (optional)

In the app/proguard-rules.pro file, add the following ProGuard rules to prevent the SDK's public interfaces from being obfuscated.

-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" />

This section explains how to use the ARTC SDK to build a basic real-time audio and video application. You can copy the code sample to test the features quickly, then follow the steps to understand the core API calls.

The following diagram shows the basic workflow for a real-time audio and video call:

1. Request permissions

When a user starts a video call, check if your app has been granted the necessary permissions:

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. Get an authentication token

Joining an ARTC channel requires an authentication token to verify the user's identity. For details on how to generate a token, see Token-based authentication. A token can be generated by using a single-parameter or multi-parameter method. The method you use determines which joinChannel API you must call.

Production environment:

Since generating a token requires your AppKey, hardcoding the AppKey on the client side is a security risk. In a production environment, we strongly recommend that you generate tokens on your App Server and send them to the client.

Development and debugging:

During development, if your App Server cannot yet generate tokens, you can use the logic in the following sample to create temporary tokens. The reference code is as follows:

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. Import ARTC SDK classes

Import the relevant classes and interfaces from the ARTC SDK:

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

4. Create and initialize the engine

• Create the RTC engine

  Call the getInstance[1/2] method to create an AliRTCEngine instance.

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

• Initialize the engine

  • Call setChannelProfile to set the channel profile to AliRTCSdkInteractiveLive (interactive mode).

    You can choose between interactive mode for entertainment and communication mode for calls. Choosing the right mode ensures a smooth user experience and efficient network use.

    Mode	Publishing	Subscribing	Description
    Interactive mode	Role-based restrictions apply. Only users assigned the host role can publish streams. Participants can switch roles at any time during the session.	No role restrictions. All participants have permission to subscribe to streams.	In interactive mode, events such as a host joining or leaving are sent to viewers. A viewer's activity is not sent to the host, which ensures an uninterrupted experience for the host. If you anticipate that viewers may need to interact in the future, we recommend using interactive mode. Its flexibility lets you adjust user roles to meet different interaction needs.
    Communication mode	No role restrictions. All participants have permission to publish streams.	No role restrictions. All participants have permission to subscribe to streams.	In communication mode, participants are aware of each other's presence in the session. Although this mode does not differentiate user roles, it is functionally equivalent to the host role in interactive mode. This simplifies operations, allowing users to achieve the desired functionality with fewer API calls.

  • Call setClientRole to set the user role to AliRTCSdkInteractive (host) or AliRTCSdkLive (viewer). Note: The host role publishes and subscribes by default. The viewer role only subscribes by default, with preview and publishing disabled.

    Note

    When a user switches roles in a channel, the system adjusts the publishing status of audio and video streams accordingly:

    • Switch from host to viewer: The system stops publishing local audio and video streams. Subscribed remote streams are not affected, and the user can continue to watch other participants.

    • Switch from viewer to host: The system starts publishing local audio and video streams. Subscribed remote streams remain unchanged, and the user can continue to watch other 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);

• Set common callbacks

  If the SDK encounters an issue, it first attempts to recover automatically with its internal retry mechanisms. For errors it cannot resolve, the SDK notifies your app through callbacks.

  The following are key callbacks for issues that the SDK cannot handle, which your application must listen for and respond to:

  Cause of exception	Callback and parameters	Solution	Description
  Authentication failed	The result parameter of the onJoinChannelResult callback is AliRtcErrJoinBadToken.	Your app must check if the token is correct.	If authentication fails when a user calls an API, the API's callback returns an authentication failure error.
  Token about to expire	onAuthInfoWillExpire	Get a new token and call refreshAuthInfo to update the authentication information.	A token expiration error can occur either when an API is called or during runtime. The error is reported through an API callback or a separate error callback.
  Token expired	onAuthInfoExpired	Your app must rejoin the channel.	A token expiration error can occur either when an API is called or during runtime. The error is reported through an API callback or a separate error callback.
  Network connection issue	The onConnectionStatusChange callback returns AliRtcConnectionStatusFailed.	Your app must rejoin the channel.	The SDK can automatically recover from brief network disconnections. If the disconnection time exceeds a preset threshold, a timeout occurs and the connection is dropped. Your app must check the network status and guide the user to rejoin the channel.
  Kicked from the channel	onBye	AliRtcOnByeUserReplaced: Check if another user has joined with the same userId. AliRtcOnByeBeKickedOut: The user was kicked from the channel by the App Server and must rejoin. AliRtcOnByeChannelTerminated: The channel was terminated, and the user must rejoin.	The RTC service allows an administrator to remove participants.
  Local device exception	onLocalDeviceException	Your app must check permissions and whether the hardware is working correctly.	The RTC service supports device detection and diagnostics. When a local device exception occurs that the SDK cannot resolve, it notifies your app via a callback. Your app must then intervene to check the device status.

  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. Set audio and video properties

• Set audio properties

  Call setAudioProfile to set the audio encoding mode and audio scenario.

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

• Set video properties

  Set properties for the published video stream, such as resolution, bitrate, and frame rate.

  // 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. Set publishing and subscribing properties

Configure stream publishing and the default subscription behavior:

• Call publishLocalAudioStream to publish the audio stream.

• Call publishLocalVideoStream to publish the video stream. For an audio-only call, set this to 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. Start the local preview

• Call setLocalViewConfig to configure the local preview view. This requires an AliRtcVideoCanvas object.

• Call the startPreview method to start the local video preview.

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. Join the channel

Call joinChannel to join a channel. If the token is generated based on the single-parameter rule, call the SDK's single-parameter joinChannel[1/3] interface. If the token is generated based on the multi-parameter rule, call the SDK's multi-parameter joinChannel[2/3] interface. After you join the channel, the onJoinChannelResult callback provides the result. If the result is 0, you have successfully joined the channel. Otherwise, check if the provided token is invalid.

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

9. Set the remote view

When initializing the engine, set the mAliRtcEngine.setRtcEngineNotify callback. In the onRemoteTrackAvailableNotify callback, set the remote view for the remote user. The sample code is as follows:

@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. Leave the channel and destroy the engine

When the audio and video session ends, leave the channel and destroy the engine. Follow the steps below to end the session.

1. Call stopPreview to stop the video preview.

2. Call leaveChannel to leave the channel.

3. Call destroy to destroy the engine and release its resources.

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

11. Demonstration