录制与回放

// 注意：建议在业务服务器上执行创建房间操作，不要在客户端执行
String url = "https://api.netless.link/v5/rooms";

OkHttpClient client = new OkHttpClient();

JSONObject requestBody = new JSONObject();
try {
    requestBody.put("name", "我的 Fastboard 录制房间");
    requestBody.put("isRecord", true); // 开启录制功能
} catch (JSONException e) {
    e.printStackTrace();
}

RequestBody body = RequestBody.create(
    MediaType.parse("application/json"), 
    requestBody.toString()
);

Request request = new Request.Builder()
    .url(url)
    .addHeader("token", "NETLESSSDK_YWs9xxxxxxM2MjRi") // 替换为你的 SDK Token
    .addHeader("region", "cn-hz") // 替换为你的数据中心
    .post(body)
    .build();

client.newCall(request).enqueue(new Callback() {
    @Override
    public void onResponse(Call call, Response response) throws IOException {
        if (response.isSuccessful()) {
            String responseBody = response.body().string();
            try {
                JSONObject json = new JSONObject(responseBody);
                String uuid = json.getString("uuid");
                Log.i(TAG, "房间 UUID: " + uuid);
                Log.i(TAG, "房间已开启录制功能");
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void onFailure(Call call, IOException e) {
        Log.e(TAG, "创建房间失败: " + e.getMessage());
    }
});

import com.herewhite.sdk.WhiteSdk;
import com.herewhite.sdk.WhiteSdkConfiguration;
import com.herewhite.sdk.Player;
import com.herewhite.sdk.PlayerConfiguration;
import com.herewhite.sdk.PlayerListener;
import com.herewhite.sdk.domain.PlayerPhase;
import com.herewhite.sdk.domain.PlayerState;
import com.herewhite.sdk.domain.SDKError;
import com.herewhite.sdk.domain.Region;
import com.herewhite.sdk.domain.WindowParams;
import com.herewhite.sdk.domain.Promise;

public class ReplayActivity extends AppCompatActivity implements PlayerListener {
    
    private static final String TAG = "ReplayActivity";
    private WhiteboardView whiteboardView;
    private WhiteSdk whiteSdk;
    private Player player;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_replay);
        
        // 1. 创建白板视图
        whiteboardView = findViewById(R.id.whiteboard_view);
        
        // 2. 配置并初始化 WhiteSdk
        initWhiteSdk();
        
        // 3. 创建回放播放器
        createReplayPlayer();
    }
    
    private void initWhiteSdk() {
        // 配置 SDK
        WhiteSdkConfiguration config = new WhiteSdkConfiguration("RMxxxAQ", true); // 替换为你的 App Identifier
        config.setRegion(Region.cn); // 设置数据中心
        config.setUseMultiViews(true); // 启用多窗口回放
        
        // 初始化 WhiteSdk
        whiteSdk = new WhiteSdk(whiteboardView, this, config);
    }
    
    private void createReplayPlayer() {
        // 配置回放参数
        PlayerConfiguration playerConfig = new PlayerConfiguration(
            "a7xxx69",  // 房间 UUID
            "NETLESSROOM_YWxxxjk"  // Room Token
        );
        
        // 设置回放时间范围
        playerConfig.setBeginTimestamp(1609459200000L); // 回放开始时间（毫秒）
        playerConfig.setDuration(45 * 60 * 1000L);      // 回放持续时间（毫秒）
        
        // 配置多窗口参数（如果录制时使用了多窗口模式）
        WindowParams windowParams = new WindowParams();
        windowParams.setContainerSizeRatio(9f / 16f); // 设置窗口比例
        playerConfig.setWindowParams(windowParams);
        
        // 创建回放播放器
        whiteSdk.createPlayer(playerConfig, this, new Promise<Player>() {
            @Override
            public void then(Player p) {
                player = p;
                Log.i(TAG, "回放播放器创建成功");
                
                // 初始化播放位置并开始播放
                player.seekToScheduleTime(0);
                player.play();
            }
            
            @Override
            public void catchEx(SDKError error) {
                Log.e(TAG, "创建回放播放器失败: " + error.getMessage());
            }
        });
    }
    
    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (player != null) {
            player.stop();
        }
    }
    
    // 实现 PlayerListener 回调方法（见下文）
}

// 播放控制
player.play();     // 开始播放
player.pause();    // 暂停播放
player.stop();     // 停止播放

// 跳转到指定位置（单位：毫秒，相对于回放开始时间）
player.seekToScheduleTime(10 * 60 * 1000); // 跳转到第 10 分钟

// 设置播放倍速
player.setPlaybackSpeed(1.5); // 1.5 倍速播放
player.setPlaybackSpeed(1.0); // 恢复正常速度

// 获取播放状态信息（同步方法）
PlayerPhase phase = player.getPlayerPhase();
PlayerTimeInfo timeInfo = player.getPlayerTimeInfo();
Log.i(TAG, "当前播放进度: " + timeInfo.getScheduleTime());
Log.i(TAG, "回放总时长: " + timeInfo.getTimeDuration());
Log.i(TAG, "播放状态: " + phase);

// 设置观看模式
player.setObserverMode(PlayerObserverMode.directory); // 跟随模式，跟随录制时的视角变化
player.setObserverMode(PlayerObserverMode.freedom);   // 自由模式，可以自由调整视角

public class ReplayActivity extends AppCompatActivity implements PlayerListener {
    
    // ... 其他代码 ...
    
    @Override
    public void onPhaseChanged(PlayerPhase phase) {
        // 播放状态变化回调
        Log.i(TAG, "播放状态: " + phase);
        switch (phase) {
            case waitingFirstFrame:
                Log.i(TAG, "等待首帧");
                break;
            case playing:
                Log.i(TAG, "正在播放");
                break;
            case pause:
                Log.i(TAG, "已暂停");
                break;
            case stopped:
                Log.i(TAG, "已停止");
                break;
            case ended:
                Log.i(TAG, "播放结束");
                break;
            case buffering:
                Log.i(TAG, "正在缓冲");
                break;
        }
    }
    
    @Override
    public void onLoadFirstFrame() {
        // 首帧加载完成回调
        Log.i(TAG, "首帧加载完成");
    }
    
    @Override
    public void onPlayerStateChanged(PlayerState modifyState) {
        // 播放器状态变化回调
        // 可以在这里获取场景状态、全局状态等信息
    }
    
    @Override
    public void onStoppedWithError(SDKError error) {
        // 播放出错回调
        Log.e(TAG, "播放出错: " + error.getMessage());
    }
    
    @Override
    public void onScheduleTimeChanged(long time) {
        // 播放进度变化回调（约每 500ms 回调一次）
        Log.d(TAG, "当前播放进度: " + time + "ms");
        
        // 更新 UI 显示播放进度
        runOnUiThread(() -> {
            int minutes = (int) (time / 60000);
            int seconds = (int) ((time % 60000) / 1000);
            // 更新进度显示
        });
    }
    
    @Override
    public void onSliceChanged(String slice) {
        // 切片变化回调（一般不需要实现）
    }
    
    @Override
    public void onCatchErrorWhenAppendFrame(SDKError error) {
        // 追加帧错误回调
        Log.e(TAG, "追加帧错误: " + error.getMessage());
    }
    
    @Override
    public void onCatchErrorWhenRender(SDKError error) {
        // 渲染错误回调
        Log.e(TAG, "渲染错误: " + error.getMessage());
    }
}

import com.herewhite.sdk.combinePlayer.PlayerSyncManager;
import com.herewhite.sdk.combinePlayer.NativePlayer;

public class SyncReplayActivity extends AppCompatActivity implements PlayerListener {
    
    private WhiteSdk whiteSdk;
    private Player whitePlayer;
    private PlayerSyncManager syncManager;
    private NativePlayer mediaPlayer;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_sync_replay);
        
        // 1. 创建原生媒体播放器（以 ExoPlayer 为例）
        mediaPlayer = new WhiteExoPlayer(this);
        ((WhiteExoPlayer) mediaPlayer).setVideoPath("https://example.com/video.m3u8");
        
        // 2. 创建同步管理器
        syncManager = new PlayerSyncManager(mediaPlayer, new PlayerSyncManager.Callbacks() {
            @Override
            public void startBuffering() {
                Log.d(TAG, "开始缓冲");
            }
            
            @Override
            public void endBuffering() {
                Log.d(TAG, "缓冲结束");
            }
        });
        
        // 3. 初始化 WhiteSdk 并创建白板回放
        WhiteSdkConfiguration config = new WhiteSdkConfiguration("RMxxxAQ", true);
        config.setRegion(Region.cn);
        whiteSdk = new WhiteSdk(whiteboardView, this, config);
        
        PlayerConfiguration playerConfig = new PlayerConfiguration("a7xxx69", "NETLESSROOM_YWxxxjk");
        playerConfig.setBeginTimestamp(1609459200000L);
        playerConfig.setDuration(45 * 60 * 1000L);
        
        whiteSdk.createPlayer(playerConfig, this, new Promise<Player>() {
            @Override
            public void then(Player player) {
                whitePlayer = player;
                
                // 关联白板播放器到同步管理器
                syncManager.setWhitePlayer(player);
                
                // 开始同步播放
                player.seekToScheduleTime(0);
                syncManager.play();
            }
            
            @Override
            public void catchEx(SDKError error) {
                Log.e(TAG, "创建回放失败: " + error.getMessage());
            }
        });
    }
    
    @Override
    public void onPhaseChanged(PlayerPhase phase) {
        // 重要！必须同步白板播放器的阶段变化
        if (syncManager != null) {
            syncManager.updateWhitePlayerPhase(phase);
        }
        
        Log.i(TAG, "播放状态: " + phase);
    }
    
    // 播放控制
    private void play() {
        if (syncManager != null) {
            syncManager.play();
        }
    }
    
    private void pause() {
        if (syncManager != null) {
            syncManager.pause();
        }
    }
    
    private void seekTo(long time) {
        if (syncManager != null) {
            syncManager.seek(time);
        }
    }
    
    private void setPlaybackSpeed(float speed) {
        if (syncManager != null) {
            syncManager.setPlaybackSpeed(speed);
        }
    }
    
    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (whitePlayer != null) {
            whitePlayer.stop();
        }
        if (mediaPlayer != null) {
            mediaPlayer.release();
        }
    }
    
    // 实现其他 PlayerListener 方法...
}

whiteSdk.isPlayable(playerConfig, new Promise<Boolean>() {
    @Override
    public void then(Boolean isPlayable) {
        if (isPlayable) {
            // 可以创建回放
            whiteSdk.createPlayer(playerConfig, listener, promise);
        } else {
            Log.w(TAG, "该房间没有可用的回放数据");
        }
    }
    
    @Override
    public void catchEx(SDKError error) {
        Log.e(TAG, "检查回放状态失败: " + error.getMessage());
    }
});

// 注意：建议在业务服务器上执行创建房间操作，不要在客户端执行
let url = URL(string: "https://api.netless.link/v5/rooms")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.setValue("NETLESSSDK_YWs9xxxxxxM2MjRi", forHTTPHeaderField: "token") // 替换为你的 SDK Token
request.setValue("cn-hz", forHTTPHeaderField: "region") // 替换为你的数据中心

let parameters: [String: Any] = [
    "name": "我的 Fastboard 录制房间",
    "isRecord": true  // 开启录制功能
]

request.httpBody = try? JSONSerialization.data(withJSONObject: parameters)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("创建房间失败:", error)
        return
    }
    
    if let data = data,
       let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
        print("房间 UUID:", json["uuid"] ?? "")
        print("房间已开启录制功能")
    }
}
task.resume()

import UIKit
import Whiteboard

class ReplayViewController: UIViewController {
    
    var boardView: WhiteBoardView!
    var whiteSDK: WhiteSDK!
    var player: WhitePlayer?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // 1. 创建白板视图
        boardView = WhiteBoardView()
        boardView.frame = view.bounds
        view.addSubview(boardView)
        
        // 2. 配置并初始化 WhiteSDK
        let config = WhiteSdkConfiguration(app: "RMxxxAQ") // 替换为你的 App Identifier
        config.region = .CN // 替换为你的数据中心
        whiteSDK = WhiteSDK(whiteBoardView: boardView, config: config)
        
        // 3. 配置回放参数
        let playerConfig = WhitePlayerConfig(
            room: "a7xxx69",  // 房间 UUID
            roomToken: "NETLESSROOM_YWxxxjk"  // Room Token
        )
        
        // 设置回放时间范围
        playerConfig.beginTimestamp = NSNumber(value: Date(timeIntervalSince1970: 1609459200).timeIntervalSince1970) // 回放开始时间
        playerConfig.duration = NSNumber(value: 45 * 60) // 回放持续时间（秒）
        
        // 4. 创建回放播放器
        whiteSDK.createReplayer(with: playerConfig, callbacks: self) { [weak self] success, player, error in
            if let error = error {
                print("创建回放播放器失败:", error.localizedDescription)
                return
            }
            
            if success, let player = player {
                self?.player = player
                print("回放播放器创建成功")
                
                // 开始播放
                player.play()
            }
        }
    }
}

// MARK: - WhitePlayerEventDelegate
extension ReplayViewController: WhitePlayerEventDelegate {
    
    func phaseChanged(_ phase: WhitePlayerPhase) {
        switch phase {
        case .waitingFirstFrame:
            print("等待首帧")
        case .playing:
            print("正在播放")
        case .pause:
            print("已暂停")
        case .stopped:
            print("已停止")
        case .ended:
            print("播放结束")
        case .buffering:
            print("正在缓冲")
        @unknown default:
            break
        }
    }
    
    func loadFirstFrame() {
        print("首帧加载完成")
    }
    
    func stoppedWithError(_ error: Error) {
        print("播放出错:", error.localizedDescription)
    }
    
    func scheduleTimeChanged(_ time: TimeInterval) {
        print("当前播放进度:", time, "秒")
    }
}

// 播放控制
player.play()     // 开始播放
player.pause()    // 暂停播放
player.stop()     // 停止播放

// 跳转到指定位置（单位：秒，相对于回放开始时间）
player.seekToScheduleTime(10 * 60) // 跳转到第 10 分钟

// 带回调的跳转
player.seekToScheduleTime(10 * 60) { result in
    switch result {
    case .success:
        print("跳转成功")
    case .fail:
        print("跳转失败")
    case .outOfRange:
        print("跳转位置超出范围")
    @unknown default:
        break
    }
}

// 设置播放倍速
player.playbackSpeed = 1.5  // 1.5 倍速播放
player.playbackSpeed = 1.0  // 恢复正常速度

// 获取播放状态信息
print("当前播放状态:", player.phase)
print("播放速度:", player.playbackSpeed)
print("时间信息:", player.timeInfo)

// 设置观看模式
player.setObserverMode(.directory)  // 跟随模式，跟随录制时的视角变化
player.setObserverMode(.freedom)    // 自由模式，可以自由调整视角

// 禁止用户调整视角
player.disableCameraTransform = true   // 禁止用户通过手势调整视角
player.disableCameraTransform = false  // 允许用户调整视角

import UIKit
import AVKit
import Whiteboard

class CombineReplayViewController: UIViewController {
    
    var boardView: WhiteBoardView!
    var whiteSDK: WhiteSDK!
    var combinePlayer: WhiteCombinePlayer?
    var playerView: UIView!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // 创建视频播放视图
        playerView = UIView(frame: CGRect(x: 0, y: 0, width: view.bounds.width, height: 300))
        view.addSubview(playerView)
        
        // 创建白板视图
        boardView = WhiteBoardView(frame: CGRect(x: 0, y: 300, width: view.bounds.width, height: view.bounds.height - 300))
        view.addSubview(boardView)
        
        // 初始化 WhiteSDK
        let config = WhiteSdkConfiguration(app: "RMxxxAQ")
        config.region = .CN
        whiteSDK = WhiteSDK(whiteBoardView: boardView, config: config)
        
        // 创建混合播放器
        let mediaUrl = URL(string: "https://example.com/video.m3u8")!
        combinePlayer = WhiteCombinePlayer(mediaUrl: mediaUrl)
        combinePlayer?.delegate = self
        
        // 配置回放参数
        let playerConfig = WhitePlayerConfig(room: "a7xxx69", roomToken: "NETLESSROOM_YWxxxjk")
        playerConfig.beginTimestamp = NSNumber(value: Date(timeIntervalSince1970: 1609459200).timeIntervalSince1970)
        playerConfig.duration = NSNumber(value: 45 * 60)
        
        // 创建白板回放播放器
        whiteSDK.createReplayer(with: playerConfig, callbacks: self) { [weak self] success, player, error in
            if let error = error {
                print("创建回放播放器失败:", error.localizedDescription)
                return
            }
            
            if success, let player = player {
                // 配置混合播放器
                self?.combinePlayer?.whitePlayer = player
                
                // 显示视频画面
                if let nativePlayer = self?.combinePlayer?.nativePlayer {
                    let playerLayer = AVPlayerLayer(player: nativePlayer)
                    playerLayer.frame = self?.playerView.bounds ?? .zero
                    self?.playerView.layer.addSublayer(playerLayer)
                }
                
                // WhitePlayer 需要先手动 seek 到 0 才会触发缓冲行为
                player.seekToScheduleTime(0)
                
                print("混合播放器创建成功")
            }
        }
    }
    
    // 播放控制
    func playVideo() {
        combinePlayer?.play()
    }
    
    func pauseVideo() {
        combinePlayer?.pause()
    }
    
    func seekToTime(_ time: TimeInterval) {
        let cmTime = CMTime(seconds: time, preferredTimescale: 1)
        combinePlayer?.seek(to: cmTime) { finished in
            print("跳转完成:", finished)
        }
    }
    
    func setPlaybackSpeed(_ speed: CGFloat) {
        combinePlayer?.playbackSpeed = speed
    }
}

// MARK: - WhitePlayerEventDelegate
extension CombineReplayViewController: WhitePlayerEventDelegate {
    
    func phaseChanged(_ phase: WhitePlayerPhase) {
        // 注意！必须完成该操作，WhiteCombinePlayer 才能正确同步状态
        combinePlayer?.updateWhitePlayerPhase(phase)
        
        switch phase {
        case .playing:
            print("正在播放")
        case .pause:
            print("已暂停")
        case .ended:
            print("播放结束")
        default:
            break
        }
    }
    
    func stoppedWithError(_ error: Error) {
        print("播放出错:", error.localizedDescription)
    }
}

// MARK: - WhiteCombineDelegate
extension CombineReplayViewController: WhiteCombineDelegate {
    
    func combinePlayerStartBuffering() {
        // 任意一端进入缓冲
        print("开始缓冲")
    }
    
    func combinePlayerEndBuffering() {
        // 两端都结束缓冲
        print("缓冲结束")
    }
}

var url = "https://api.netless.link/v5/rooms";
var requestInit = {
    method: "POST",
    headers: {
        "content-type": "application/json",
        "token": "NETLESSSDK_YWs9xxxxxxM2MjRi", // 替换为你的 SDK Token
        "region": "cn-hz", // 替换为你的数据中心
    },
    body: JSON.stringify({
        name: "我的 Fastboard 录制房间",
        isRecord: true, // 开启录制功能
    }),
};

fetch(url, requestInit).then(function(response) {
    return response.json();
}).then(function(roomJSON) {
    // 创建房间成功，获取房间信息
    console.log("房间 UUID:", roomJSON.uuid);
    console.log("房间已开启录制功能");
}).catch(function(err) {
    console.error("创建房间失败:", err);
});

import { replayFastboard, createReplayUI } from "@netless/fastboard";

// 创建回放播放器
const player = await replayFastboard({
    sdkConfig: {
        appIdentifier: "RMxxxAQ", // 替换为你的 App Identifier
        region: "cn-hz", // 替换为你的数据中心
    },
    replayRoom: {
        room: "a7xxx69", // 房间 UUID
        roomToken: "NETLESSROOM_YWxxxjk", // Room Token
        beginTimestamp: new Date("2023-01-01 08:00:00").getTime(), // 回放开始时间
        duration: 45 * 60 * 1000, // 回放持续时间（毫秒）
    },
    managerConfig: {
        cursor: true, // 显示光标
    },
});

// 创建并挂载回放 UI
const ui = createReplayUI(player, document.getElementById("whiteboard"));

// 可选：更新 UI 配置
ui.update({ 
    theme: "dark", 
    language: "zh-CN" 
});

// 使用完毕后销毁
// ui.destroy();

import React from "react";
import { useReplayFastboard, ReplayFastboard } from "@netless/fastboard-react";

function ReplayComponent() {
    const player = useReplayFastboard(() => ({
        sdkConfig: {
            appIdentifier: "RMxxxAQ", // 替换为你的 App Identifier
            region: "cn-hz",
        },
        replayRoom: {
            room: "a7xxx69", // 房间 UUID
            roomToken: "NETLESSROOM_YWxxxjk", // Room Token
            beginTimestamp: new Date("2023-01-01 08:00:00").getTime(),
            duration: 45 * 60 * 1000,
        },
        managerConfig: {
            cursor: true,
        },
    }));

    return (
        <ReplayFastboard 
            player={player} 
            theme="light" 
            language="zh-CN" 
        />
    );
}

const player = await replayFastboard({
    sdkConfig: {
        appIdentifier: "RMxxxAQ",
        region: "cn-hz",
    },
    replayRoom: {
        room: "a7xxx69",
        roomToken: "NETLESSROOM_YWxxxjk",
        beginTimestamp: new Date("2023-01-01 08:00:00").getTime(),
        duration: 45 * 60 * 1000,
    },
    // 如果实时房间启用了 AppliancePlugin，回放时也需要配置
    enableAppliancePlugin: {
        cdn: {
            fullWorkerUrl: "path/to/fullWorker.js",
            subWorkerUrl: "path/to/subWorker.js",
        },
        strokeWidth: {
            min: 1,
            max: 32
        },
        syncOpt: {
            interval: 200
        },
    },
    // 如果实时房间启用了 AppInMainViewPlugin，回放时也需要配置
    enableAppInMainViewPlugin: true,
});

// 播放控制
player.play();     // 开始播放
player.pause();    // 暂停播放
player.stop();     // 停止播放

// 跳转到指定位置（单位：毫秒，相对于回放开始时间）
player.seek(10 * 60 * 1000); // 跳转到第 10 分钟

// 设置播放倍速
player.setPlaybackRate(1.5); // 1.5 倍速播放
player.setPlaybackRate(1.0); // 恢复正常速度

// 获取播放状态信息
console.log("当前播放进度:", player.currentTime.value); // 当前播放位置（毫秒）
console.log("总时长:", player.duration.value);          // 回放总时长（毫秒）
console.log("播放状态:", player.phase.value);           // 播放状态
console.log("播放速度:", player.playbackRate.value);    // 当前播放速度
console.log("是否可播放:", player.canplay.value);       // 是否准备好播放

// 监听播放进度变化
const unsubscribeProgress = player.currentTime.subscribe(time => {
    console.log("当前播放进度:", time + "ms");
});

// 监听播放状态变化
const unsubscribePhase = player.phase.subscribe(phase => {
    switch(phase) {
        case "playing":
            console.log("正在播放");
            break;
        case "pause":
            console.log("已暂停");
            break;
        case "buffering":
            console.log("正在缓冲");
            break;
        case "ended":
            console.log("播放结束");
            break;
        case "waitingFirstFrame":
            console.log("等待首帧");
            break;
    }
});

// 监听播放速度变化
const unsubscribeRate = player.playbackRate.subscribe(rate => {
    console.log("播放速度:", rate + "x");
});

// 取消订阅
// unsubscribeProgress();
// unsubscribePhase();
// unsubscribeRate();

// 只渲染白板内容，不包含控制 UI
player.bindContainer(document.getElementById("whiteboard"));

// 可选：移动 collector 到指定位置
player.bindCollector(document.getElementById("collector"));

import { replayFastboard } from "@netless/fastboard";
import CombinePlayerFactory from "@netless/combine-player";

// 1. 创建白板回放播放器
const player = await replayFastboard({
    sdkConfig: {
        appIdentifier: "RMxxxAQ", // 替换为你的 App Identifier
        region: "cn-hz",
    },
    replayRoom: {
        room: "a7xxx69", // 房间 UUID
        roomToken: "NETLESSROOM_YWxxxjk", // Room Token
        beginTimestamp: new Date("2023-01-01 08:00:00").getTime(),
        duration: 45 * 60 * 1000,
    },
    managerConfig: {
        cursor: true,
    },
    // 如果实时房间启用了插件，回放时也需要配置
    enableAppliancePlugin: {},
});

// 2. 绑定白板容器
const whiteboard = document.getElementById("whiteboard");
player.bindContainer(whiteboard);

// 3. 配置视频播放器参数
const factoryParams = {
    url: "https://example.com/rtc-recording.mp4", // RTC 录制的视频地址
    videoDOM: document.getElementById("videoDom"), // 用于存放视频播放器的 DOM 节点
};

// 4. 创建同步播放器
const combinePlayer = new CombinePlayerFactory(player.player, factoryParams).create(false);

// 5. 使用同步播放器控制播放
combinePlayer.play();   // 开始播放
combinePlayer.pause();  // 暂停播放
combinePlayer.seek(10 * 1000); // 跳转到 10 秒位置（单位：毫秒）

// 6. 监听播放状态变化
combinePlayer.setOnStatusChange((status, message) => {
    console.log("播放状态:", status, message);
});

// 7. 获取播放信息
console.log("播放速率:", combinePlayer.playbackRate);
console.log("总时长:", combinePlayer.timeDuration);
console.log("当前状态:", combinePlayer.combinedStatus);