ApsaraVideo VOD:Android player FAQ

By default, the player SDK provides a callback for the playback progress every 500 ms. You can modify this callback interval. To retrieve the current playback progress more frequently, shorten the interval. The following code provides an example:

// Modify the callback interval.
PlayerConfig config = mAliyunLivePlayer.getConfig();
config.mPositionTimerIntervalMs = 100;// The callback interval in ms.
mAliyunLivePlayer.setConfig(config);

mAliPlayer.setOnInfoListener(new IPlayer.OnInfoListener() {
        @Override
        public void onInfo(InfoBean infoBean) {
        if(infoBean.getCode() == InfoCode.CurrentPosition){
            // The current playback progress.
            long currentPosition = infoBean.getExtraValue();
        }
    }
});

To retrieve raw audio and video data, switch to software decoding and play an unencrypted video. The following code provides an example:

// Switch to software decoding.
mAliPlayer.enableHardwareDecoder(false);
IPlayer.RenderFrameCallbackConfig renderFrameCallbackConfig = new IPlayer.RenderFrameCallbackConfig();
// Specifies whether to return only the underlying video data address. Default value: true.
renderFrameCallbackConfig.mVideoDataAddr = false;
// Specifies whether to return only the underlying audio data address. Default value: false.
renderFrameCallbackConfig.mAudioDataAddr = false;
mAliPlayer.setRenderFrameCallbackConfig(renderFrameCallbackConfig);

mAliPlayer.setOnRenderFrameCallback(new IPlayer.OnRenderFrameCallback() {
    @Override
    public boolean onRenderFrame(FrameInfo frameInfo) {
        return false;
    }
});

You can retrieve the video width and height in one of the following three ways:

• After the AliPlayer instance completes the `prepare` method and enters the `prepared` state, you can retrieve the width and height using the following methods:

  mAliyunPlayer.setOnPreparedListener(new IPlayer.OnPreparedListener() {
      @Override
      public void onPrepared() {
            mAliyunPlayer.getVideoWidth();
                mAliyunPlayer.getVideoHeight();
      }
  });

• Listen for the video size change callback:

  mAliyunPlayer.setOnVideoSizeChangedListener(new IPlayer.OnVideoSizeChangedListener() {
      @Override
      public void onVideoSizeChanged(int width, int height) {
  
      }
  });

• You can obtain it using the track method:

  mAliyunPlayer.setOnTrackReadyListener(new IPlayer.OnTrackReadyListener() {
      @Override
      public void onTrackReady(MediaInfo mediaInfo) {
      List<TrackInfo> trackInfos = mediaInfo.getTrackInfos();
          for (TrackInfo trackInfo : trackInfos) {
          if(trackInfo.getType() == TrackInfo.Type.TYPE_VIDEO){
          trackInfo.getVideoWidth();
          trackInfo.getVideoHeight();
          }
      }
      }
  });

When you enable automatic bitrate switching by calling the mAliPlayer.selectTrack(TrackInfo.AUTO_SELECT_INDEX) interface, the player SDK calculates the current network speed. If the network speed can support the next bitrate level for 10 seconds, the player switches to that bitrate. Otherwise, the player does not switch.

• When switching from a high bitrate to a low bitrate, if the network speed reaches the next bitrate level within 10 seconds, the player finishes playing the cached high-bitrate content before switching.

• When switching from a low bitrate to a high bitrate, the player switches immediately. The switch occurs if the network speed increases to the next bitrate level for 10 seconds.

To enable automatic bitrate switching, you must first transcode the video into an adaptive bitrate stream in the console. Then, specify that the player retrieves the adaptive bitrate stream. The following code shows an example of using the VidAuth playback method:

VidAuth vidAuth = new VidAuth();
List<Definition> list = new ArrayList<>();
list.add(Definition.DEFINITION_AUTO);
vidAuth.setDefinition(list);

You can customize the retry logic. When a retry is triggered, the retry event is sent to an external service that determines the specific retry logic. The following code provides an example:

PlayerConfig config = mAliPlayer.getConfig();
// 1. Set the number of retries. In this example, it is set to 0.
config.mNetworkRetryCount = 0;
mAliPlayer.setConfig(config);

mAliPlayer.setOnInfoListener(new IPlayer.OnInfoListener() {
    @Override
    public void onInfo(InfoBean infoBean) {
        // 2. Listen for the retry event.
       if(infoBean.getCode() == InfoCode.NetworkRetry){
            // TODO: Process the logic as needed.
        }
    }
});

The following code shows how to switch the seek mode:

// Inaccurate seek.
mAliPlayer.seekTo(1000);
mAliPlayer.seekTo(1000, IPlayer.SeekMode.Inaccurate);
// Accurate seek.
mAliPlayer.seekTo(1000,IPlayer.SeekMode.Accurate);

Solution: You can use an interface to set the maximum interval for accurate seek. Increasing the maximum interval reduces the frequency at which accurate seek switches to inaccurate seek, which improves seek accuracy. However, a longer interval means that the seek operation will take more time if the seek point is far from a keyframe. You should set a reasonable maximum interval for accurate seek based on your business needs. The following code provides an example:

// Unit: ms.
mAliPlayer.setMaxAccurateSeekDelta(10000);

Troubleshoot the issue as follows:

1. Check whether the CPU architecture is x86.

   The player SDK supports only the arm64-v8a and armeabi-v7a architectures. It does not support the x86 architecture.

2. Check whether both the .so files and Maven dependencies for the player SDK are integrated in the project.

   For example, you may have integrated the player SDK using a Maven dependency in `build.gradle` and also integrated the player-related dynamic libraries in the `libs` directory of the project's module.

   Recommended solution: If you are using both methods, delete the dynamic libraries and use only the Maven dependency. If you must integrate dynamic libraries, check that all player SDK-related .so files are from the same version. For information about how to integrate the player SDK and obtain the dynamic libraries, see Integrate the SDK. The following figure shows the player-related dynamic libraries:

3. If you integrated a partial package, confirm that the AlivcFFmpeg version dependency is correct.

   For information about AlivcFFmpeg version dependencies, see AlivcFFmpeg version dependencies.

Troubleshoot the issue as follows:

1. Confirm whether the crash occurred in the player SDK.

   Check for a crash stack with the AliyunPlayer prefix. If a stack with this prefix exists, the issue is in the player SDK.

2. Upgrade to the latest version of the player SDK and verify whether the issue is fixed.

3. If the issue persists, prepare the relevant crash files (including all threads), crash logs, and crash scenario information. For more information, see How to retrieve issue logs.

Troubleshoot the issue as follows:

1. Check whether the source video itself has black bars.

2. You can adjust the player's scaling mode using the following interface.

   /*
   SCALE_ASPECT_FILL: Fills the screen proportionally. The video is cropped.
   SCALE_ASPECT_FIT: Scales the video proportionally. Black bars may appear.
   SCALE_TO_FILL: Fills the screen without maintaining proportions. The video is distorted.
   */
   mAliPlayer.setScaleMode();

3. If the scaling mode does not meet your needs, you can adjust the size of the SurfaceView or TextureView at the application layer.

Troubleshoot the issue as follows:

1. Play the video with another player to check whether it is an audio-only file.

2. Confirm that the view that renders the video is configured correctly. For example, check whether a display view is set for the player or has been removed from the playback interface. For instructions on setting the display view, see Step 4 in Basic features.

Troubleshoot the issue as follows:

1. Check whether the CPU architecture meets the requirements.

   The player SDK supports dynamic libraries for only the arm64-v8a and armeabi-v7a architectures.

2. Check whether the player SDK version is too old.

   If you are using player SDK V5.4.6.0-full or earlier, we recommend that you upgrade to V5.4.6.0-full-15467853 or a later version. For the latest and historical versions of the player SDK, see Android SDK release notes.

Versions of the player SDK earlier than V5.4.5.0 do not support using the list player AliListPlayer to play HLS (m3u8) videos. Starting from V5.4.5.0, HLS (m3u8) videos are supported. However, you must enable local caching. For information about how to enable local caching, see Local cache.

The following code provides an example:

// The VidSts playback method is used as an example.
VidSts vidSts = new VidSts();
// The code for setting parameters such as vid, AccessKeyId, AccessKeySecret, and token is omitted. For more information, see the player creation settings in the Basic Features topic.
/*
    Parameter 1: The desired playback definition. Valid values: FD, LD, SD, HD, 2K, 4K, and OD.
    Parameter 2: Specifies whether to enforce playback of the desired definition. false: Does not enforce playback of the desired definition. The player SDK searches for a definition to play based on the default order. true: Enforces playback of the desired definition. If the desired definition is not found, the video is not played.
*/
vidSts.setQuality("",false);