tencent cloud

<com.tencent.rtmp.ui.TXCloudVideoView
            android:id="@+id/video_view"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_centerInParent="true"
            android:visibility="gone"/>

// `mPlayerView` is the video rendering view added in step 3
TXCloudVideoView mPlayerView = findViewById(R.id.video_view);
// Create a player object
TXVodPlayer mVodPlayer = new TXVodPlayer(getActivity());
// Associate the player object with the video rendering view
mVodPlayer.setPlayerView(mPlayerView);

@Override
public void onDestroy() {
    super.onDestroy();
    mVodPlayer.stopPlay(true); // `true` indicates to clear the last-frame image
    mPlayerView.onDestroy(); 
}

// Start playback
mVodPlayer.startVodPlay(url)

// Pause the video
mVodPlayer.pause();

// Resume the video
mVodPlayer.resume();

// Stop the video
mVodPlayer.stopPlay(true);

int time = 600; // In seconds if the value is of `int` type
// float time = 600; // In seconds if the value is of `float` type
// Adjust the playback progress
mVodPlayer.seek(time);

float time = 600; // Unit is seconds for float type
// Adjust progress
mVodPlayer.seek(time, true); // Precise seek
mVodPlayer.seek(time, false); // Imprecise seek

long pdtTimeMs = 600; // Unit is milliseconds
mVodPlayer.seekToPdtTime(time);

float startTimeInSecond = 60; // Unit: Second
mVodPlayer.setStartTime(startTimeInSecond);   // Set the playback start time
mVodPlayer.startVodPlay(url);

 // Fill the screen at the original aspect ratio
mVodPlayer.setRenderMode(TXLiveConstants.RENDER_MODE_FULL_FILL_SCREEN);
// Normal playback (the Home button is below the video image)
mVodPlayer.setRenderRotation(TXLiveConstants.RENDER_ROTATION_PORTRAIT);

// Set playback at 1.2X rate
mVodPlayer.setRate(1.2); 

// Set playback loop
mVodPlayer.setLoop(true);
// Get the current playback loop status
mVodPlayer.isLoop(); 

// Mute or unmute the player. true: Mute; false: Unmute
mVodPlayer.setMute(true);

// Take a screenshot
mVodPlayer.snapshot(new ITXSnapshotListener() {
    @Override
    public void onSnapshot(Bitmap bmp) {
        if (null != bmp) {
           // Get the screenshot bitmap
        }
    }
});

mVodPlayer.setAutoPlay(false);  // Set manual playback
mVodPlayer.startVodPlay(url);    // The video will be loaded after `startVodPlay` is called and won't be played back automatically after being loaded successfully.
// ......
// Display the ad on the player UI
// ......  
mVodPlayer.resume();  // Call `resume` to start playing back the video after the ad display ends

TXVodPlayConfig mPlayConfig = new TXVodPlayConfig();
Map<String, String> headers = new HashMap<>();
headers.put("Referer", "${Refer Content}");
mPlayConfig.setHeaders(headers);
mVodPlayer.setConfig(mPlayConfig);

 mVodPlayer.stopPlay(true);
 mVodPlayer.enableHardwareDecode(true);
 mVodPlayer.startVodPlay(flvUrl, type);

// Get the array of multiple bitrates. The TXBitrateItem class fields mean: index - bitrate index; width - video width; height - video height; bitrate - video bitrate 
ArrayList<TXBitrateItem> bitrates = mVodPlayer.getSupportedBitrates(); 
int index = bitrates.get(i).index; // Specify the bitrate index to be played 
mVodPlayer.setBitrateIndex(index); // Switch the bitrate to the desired clarity

// Get the index of the currently played bitrate. The return value of -1000 is the default value, indicating that no bitrate has been set; the return value of -1 indicates that adaptive streaming is enabled 
int index = mVodPlayer.getBitrateIndex();

mVodPlayer.setBitrateIndex(-1); // Pass in `-1` for the `index` parameter

TXVodPlayConfig mPlayConfig = new TXVodPlayConfig();
// If it is set to `true`, the bitrate can be switched smoothly when IDR frames are aligned. If it is set to `false`, multi-bitrate URLs are opened faster.
mPlayConfig.setSmoothSwitchBitrate(true); 
mVodPlayer.setConfig(mPlayConfig);

mVodPlayer.setVodListener(new ITXVodPlayListener() {
    @Override
    public void onPlayEvent(TXVodPlayer player, int event, Bundle param) {
        if (event == TXLiveConstants.PLAY_EVT_PLAY_PROGRESS) {
            // Loading progress in ms
            int playable_duration_ms = param.getInt(TXLiveConstants.EVT_PLAYABLE_DURATION_MS);
            mLoadBar.setProgress(playable_duration_ms); // Set the loading progress bar

            // Playback progress in ms
            int progress_ms = param.getInt(TXLiveConstants.EVT_PLAY_PROGRESS_MS);
            mSeekBar.setProgress(progress_ms);  // Set the playback progress bar

            // Total video duration in ms
            int duration_ms = param.getInt(TXLiveConstants.EVT_PLAY_DURATION_MS);
            // It can be used to set duration display, etc.
            
            // Get the PDT time. This function is supported starting from version 11.6 of the player's advanced edition. 
            long pdt_time_ms = param.getLong(TXVodConstants.EVT_PLAY_PDT_TIME_MS);
        }
    }

    @Override
    public void onNetStatus(TXVodPlayer player, Bundle bundle) {
    }
});

mVodPlayer.setVodListener(new ITXVodPlayListener() {
    @Override
    public void onPlayEvent(TXVodPlayer player, int event, Bundle param) {
        if (event == TXLiveConstants.PLAY_EVT_PLAY_LOADING) {
            // Show the current network speed

        } else if (event == TXLiveConstants.PLAY_EVT_VOD_LOADING_END) {
            // Hide the view showing the current network speed
        }
    }

    @Override
    public void onNetStatus(TXVodPlayer player, Bundle bundle) {
        // Get the real-time speed in Kbps
        int speed = bundle.getInt(TXLiveConstants.NET_STATUS_NET_SPEED);
    }
});

mVodPlayer.setVodListener(new ITXVodPlayListener() {
    @Override
    public void onPlayEvent(TXVodPlayer player, int event, Bundle param) {
    }

    @Override
    public void onNetStatus(TXVodPlayer player, Bundle bundle) {
        // Get the video width
        int videoWidth = bundle.getInt(TXLiveConstants.NET_STATUS_VIDEO_WIDTH);
        // Get the video height
        int videoHeight = bundle.getInt(TXLiveConstants.NET_STATUS_VIDEO_HEIGHT);
    }
});

// Get the video width and height. The values can be returned only after the `PLAY_EVT_VOD_PLAY_PREPARED` event callback is received from the player
mVodPlayer.getWidth();
mVodPlayer.getHeight();

TXVodPlayConfig config = new TXVodPlayConfig();
config.setMaxBufferSize(10);  // Maximum buffer size during playback in MB
mVodPlayer.setConfig(config);  // Pass in `config` to `mVodPlayer`

File sdcardDir = getApplicationContext().getExternalFilesDir(null);
if (sdcardDir != null) {
    // Set the global cache directory of the playback engine
   TXPlayerGlobalSetting.setCacheFolderPath(sdcardDir.getPath() + "/txcache");
    // Set the global cache directory and cache size in MB of the playback engine
    TXPlayerGlobalSetting.setMaxCacheSize(200); 
}

// Use the player

// Add TXSubtitleView to the layout XML where the player is located. 
<com.tencent.rtmp.ui.TXSubtitleView
            android:id="@+id/subtitle_view"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"/>
              
mSubtitleView = findViewById(R.id.subtitle_view);
// Set the subtitle rendering target object.
mVodPlayer.setSubtitleView(mSubtitleView);

// Pass in the subtitle URL, subtitle name, and subtitle type. It is recommended to add subtitles before starting the playback.
mVodPlayer.addSubtitleSource("https://mediacloud-76607.gzc.vod.tencent-cloud.com/DemoResource/subtitleVTT.vtt", "subtitleName", TXVodConstants.VOD_PLAY_MIMETYPE_TEXT_VTT);

// After starting to play the video, select the added external subtitle. Please call it after receiving the VOD_PLAY_EVT_VOD_PLAY_PREPARED event.
@Override
public void onPlayEvent(TXVodPlayer player, int event, Bundle param) {
    if (event == TXVodConstants.VOD_PLAY_EVT_VOD_PLAY_PREPARED) {
        List<TXTrackInfo> subtitleTrackInfoList = mVodPlayer.getSubtitleTrackInfo();
        for (TXTrackInfo track : subtitleTrackInfoList) {
            Log.d(TAG, "TrackIndex= " + track.getTrackIndex() + " ,name= " + track.getName());
            if (TextUtils.equals(track.getName(), "subtitleName")) {
                // Selected Subtitles
                mVodPlayer.selectTrack(track.trackIndex);
            } else {
                // If other subtitles are not required, proceed with deselectTrack.
                mVodPlayer.deselectTrack(track.trackIndex);
            }
        }
    }
}


// If needed, you can listen for track switching messages.
mVodPlayer.setVodListener(new ITXVodPlayListener() {
    @Override
    public void onPlayEvent(TXVodPlayer player, int event, Bundle param) {
        if (event == TXVodConstants.VOD_PLAY_EVT_SELECT_TRACK_COMPLETE) {
            int trackIndex = param.getInt(TXVodConstants.EVT_KEY_SELECT_TRACK_INDEX);
            int errorCode = param.getInt(TXVodConstants.EVT_KEY_SELECT_TRACK_ERROR_CODE);
            Log.d(TAG, "receive VOD_PLAY_EVT_SELECT_TRACK_COMPLETE, trackIndex=" + trackIndex + " ,errorCode=" + errorCode);
        }
    }

    @Override
    public void onNetStatus(TXVodPlayer player, Bundle status) {

    }
});

// For detailed parameter configuration, please refer to the API documentation.
TXSubtitleRenderModel model = new TXSubtitleRenderModel();
model.canvasWidth = 1920;  // Width of the subtitle rendering canvas
model.canvasHeight = 1080;  // Height of the subtitle rendering canvas model
model.fontColor = 0xFFFFFFFF; // Set the font color of the subtitle, default is white and opaque
model.isBondFontStyle = false;  // Set whether the subtitle font is bold
mVodPlayer.setSubtitleStyle(model);

// Returns a list of audio track information
List<TXTrackInfo> soundTrackInfoList = mVodPlayer.getAudioTrackInfo();
for (TXTrackInfo trackInfo : soundTrackInfoList) {
    if (trackInfo.trackIndex ==  0) {
        // Switch to the required audio track by checking the trackIndex or name
        mVodPlayer.selectTrack(trackInfo.trackIndex);
    } else {
        // Deselect the unwanted audio track
        mVodPlayer.deselectTrack(trackInfo.trackIndex);
    }
}