rtc_ctrl_interface.h

浏览该文件的文档.

// Copyright (c) 2022 NetEase, Inc. All rights reserved.
// Use of this source code is governed by a MIT license that can be
// found in the LICENSE file.
 
#ifndef RTC_CTRL_INTERFACE_H
#define RTC_CTRL_INTERFACE_H
 
#include "pre_rtc_ctrl_interface.h"
 
namespace neroom {
 
class INERoomRtcController : public INEPreviewRoomRtcController {
public:
    using NERtcCallback = NECallback<>;
 
    using NERoomTakeSnapshotCallback = NECallback<NERoomTakeSnapshotInfo>;
 
public:
    ~INERoomRtcController() override = default;
 
    virtual void joinRtcChannel(const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual void joinRtcChannel(const std::string& channelName, const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual void leaveRtcChannel(const NERtcCallback& callback) = 0;
 
    virtual void leaveRtcChannel(const std::string& channelName, const NERtcCallback& callback) = 0;
 
    virtual void muteMyAudio(const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual void muteMyAudio(bool enableMediaPub = false, const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual void unmuteMyAudio(const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual void unmuteMyAudio(bool enableMediaPub = false, const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual int setupRemoteVideoCanvas(const std::string& userUuid, const NERoomVideoView& videoView) = 0;
 
    virtual int setupLocalVideoSubStreamCanvas(const NERoomVideoView& videoView) = 0;
 
    virtual int setupRemoteVideoSubStreamCanvas(const std::string& userUuid, const NERoomVideoView& videoView) = 0;
 
    virtual int subscribeRemoteVideoStream(const std::string& userUuid, NEVideoStreamType streamType) = 0;
 
    virtual int unsubscribeRemoteVideoStream(const std::string& userUuid) = 0;
 
    virtual int subscribeRemoteVideoSubStream(const std::string& userUuid) = 0;
 
    virtual int unsubscribeRemoteVideoSubStream(const std::string& userUuid) = 0;
 
    virtual int subscribeRemoteVideoStreamByRtcUid(uint64_t rtcUid, NEVideoStreamType streamType, bool subscribe) = 0;
 
    virtual int subscribeRemoteVideoSubStreamByRtcUid(uint64_t rtcUid, bool subscribe) = 0;
 
    virtual int setupRemoteVideoCanvasByRtcUid(uint64_t rtcUid, const NERoomVideoView& videoView) = 0;
 
    virtual int setupRemoteVideoSubStreamCanvasByRtcUid(uint64_t rtcUid, const NERoomVideoView& videoView) = 0;
 
    virtual void muteMyVideo(const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual void unmuteMyVideo(const NERtcCallback& callback = NERtcCallback()) = 0;
 
    ROOMKIT_DEPRECATED("use startAppShare with NERoomSourceID instead")
    virtual void startAppShare(void* hwnd, bool preferMotion = false, const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual void startAppShare(NERoomSourceID sourceID, const NERoomScreenSharingOption& option, const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual void startAppShare(NERoomSourceID sourceID,
        const NERoomScreenSharingOption& option,
        bool stopCurrentShare = false,
        const NERtcCallback& callback = NERtcCallback()) = 0;
 
    ROOMKIT_DEPRECATED("use switchScreenCaptureSource instead")
    virtual int switchAppShare(void* hwnd, bool preferMotion = false) = 0;
 
    ROOMKIT_DEPRECATED("use startScreenShare with NERoomSourceID instead")
    virtual void startScreenShare(const uint32_t& monitorId,
        const std::list<void*>& excludedWindowList = std::list<void*>(),
        bool preferMotion = false,
        const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual void startScreenShare(NERoomSourceID sourceID,
        const NERoomScreenSharingOption& option,
        const std::list<void*>& excludedWindowList = std::list<void*>(),
        const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual void startScreenShare(NERoomSourceID sourceID,
        const NERoomScreenSharingOption& option,
        const std::list<void*>& excludedWindowList = std::list<void*>(),
        bool stopCurrentShare = false,
        const NERtcCallback& callback = NERtcCallback()) = 0;
 
    ROOMKIT_DEPRECATED("use switchScreenCaptureSource instead")
    virtual int switchScreenShare(const uint32_t& monitorId, const std::list<void*>& excludedWindowList, bool preferMotion = false) = 0;
 
    ROOMKIT_DEPRECATED("use startRectShare with NERoomScreenSharingOption instead")
    virtual void startRectShare(const NERectangle& sourceRectangle,
        const NERectangle& regionRectangle,
        const std::list<void*>& excludedWindowList = std::list<void*>(),
        bool preferMotion = false,
        const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual void startRectShare(const NERectangle& sourceRectangle,
        const NERectangle& regionRectangle,
        const std::list<void*>& excludedWindowList = std::list<void*>(),
        bool preferMotion = false,
        bool stopCurrentShare = false,
        const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual void startRectShare(const NERectangle& sourceRectangle,
        const NERectangle& regionRectangle,
        const NERoomScreenSharingOption& option,
        const std::list<void*>& excludedWindowList = std::list<void*>(),
        const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual void startRectShare(const NERectangle& sourceRectangle,
        const NERectangle& regionRectangle,
        const NERoomScreenSharingOption& option,
        const std::list<void*>& excludedWindowList = std::list<void*>(),
        bool stopCurrentShare = false,
        const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual void switchScreenCaptureSource(const NERoomScreenCaptureInfo& sourceInfo,
        const NERectangle& regionRectangle,
        const NERoomScreenSharingOption& option,
        const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual int setExcludeWindowList(const std::list<void*>& excludedWindowList) = 0;
 
    virtual void stopShare(const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual void pauseShare(const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual void resumeShare(const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual int startSystemAudioLoopbackCapture() = 0;
 
    virtual int stopSystemAudioLoopbackCapture() = 0;
 
    virtual void muteMemberAudio(const std::string& userUuid, const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual void unmuteMemberAudio(const std::string& userUuid, const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual void muteMemberVideo(const std::string& userUuid, const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual void unmuteMemberVideo(const std::string& userUuid, const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual int enableMediaPub(NEMediaPubType mediaType, bool enable) = 0;
 
    virtual int enableMediaPub(const std::string& channelName, NEMediaPubType mediaType, bool enable) = 0;
 
    virtual void stopMemberShare(const std::string& userUuid, const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual void stopMemberSystemAudioShare(const std::string& userUuid, const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual std::string getScreenSharingUserUuid() const = 0;
 
    virtual int setExternalAudioSource(bool enabled, int sampleRate, int channels) = 0;
 
    virtual int pushExternalAudioFrame(const NERoomAudioFrame& frame) = 0;
 
    virtual int adjustUserPlaybackSignalVolume(const std::string& userUuid, int volume) = 0;
 
    virtual int enableEarBack(int volume) = 0;
 
    virtual int disableEarBack() = 0;
 
    virtual int startAudioMixing(const NERoomCreateAudioMixingOption& option) = 0;
 
    virtual int pauseAudioMixing() = 0;
 
    virtual int resumeAudioMixing() = 0;
 
    virtual int stopAudioMixing() = 0;
 
    virtual int setAudioMixingSendVolume(int volume) = 0;
 
    virtual int setAudioMixingPlaybackVolume(int volume) = 0;
 
    virtual int playEffect(uint32_t effectId, const NERoomCreateAudioEffectOption& option) = 0;
 
    virtual int stopEffect(uint32_t effectId) = 0;
 
    virtual int pauseEffect(uint32_t effectId) = 0;
 
    virtual int resumeEffect(uint32_t effectId) = 0;
 
    virtual int setEffectSendVolume(uint32_t effectId, int volume) = 0;
 
    virtual int setEffectPlaybackVolume(uint32_t effectId, int volume) = 0;
 
    virtual int stopAllEffects() = 0;
 
    virtual int pauseAllEffects() = 0;
 
    virtual int resumeAllEffects() = 0;
 
    virtual void startChannelMediaRelay(const NERtcCallback& callback = NERtcCallback()) = 0;
 
    virtual void startChannelMediaRelay(const std::string& roomUuid, const NERtcCallback& callback) = 0;
 
    virtual int stopChannelMediaRelay() = 0;
 
    virtual int setAudioSubscribeOnlyBy(const std::vector<std::string>& userUuids) = 0;
 
    virtual int sendSEIMsg(const std::string& data, NERoomRtcVideoStreamType type) = 0;
 
    virtual int enableLocalAudioSubStream() = 0;
 
    virtual int disableLocalAudioSubStream() = 0;
 
    virtual int pauseLocalAudioRecording() = 0;
 
    virtual int resumeLocalAudioRecording() = 0;
 
    virtual int pauseLocalVideoCapture() = 0;
 
    virtual int resumeLocalVideoCapture() = 0;
 
    virtual int setClientRole(NERoomRTCClientRole clientRole) = 0;
 
    /*
     * @brief 开启 RTC 媒体流加密
     * @param libPath 动态库地址，必传；(Windows: .dll; Mac: .dylib; Linux: .so)
     * @return int 0 是成功，其他为失败
     * @since v1.39.0
     */
    virtual int enableCustomEncryption(const std::string& libPath) = 0;
 
    /*
     * 开启 RTC 媒体流加密
     * @param key 加密密钥，由业务服务端生成密钥，必传
     * @param encryptionType 加密方式，加密方式(目前仅支持 kNEEncryptionTypeGMCryptoSM4ECB)
     * @return int 0 是成功，其他为失败
     */
    virtual int enableEncryption(const std::string& key, NEEncryptionType encryptionType) = 0;
 
    virtual int disableEncryption() = 0;
 
    virtual void disconnectMyAudio(const NERtcCallback& callback) = 0;
 
    virtual void reconnectMyAudio(const NERtcCallback& callback) = 0;
 
    virtual int adjustChannelPlaybackSignalVolume(int volume) = 0;
 
    virtual int adjustChannelPlaybackSignalVolume(const std::string& channelName, int volume) = 0;
 
    virtual int enableLocalAudio(const std::string& channelName, bool enable) = 0;
 
    virtual int takeLocalSnapshot(NERoomRtcVideoStreamType stream_type, const NERoomTakeSnapshotCallback& callback) = 0;
 
    virtual int takeRemoteSnapshot(const std::string& userUuid, NERoomRtcVideoStreamType stream_type, const NERoomTakeSnapshotCallback& callback) = 0;
 
    virtual int enableCaption(bool enable) = 0;
    virtual int setCaptionTranslationLanguage(NERoomCaptionTranslationLanguage language) = 0;
 
    virtual int setCaptionTranslationConfig(const NERoomCaptionTranslationConfig& config) = 0;
 
    virtual void startShareSystemAudio(const NERtcCallback& callback) = 0;
 
    virtual void startShareSystemAudio(bool stopCurrentShare = false, const NERtcCallback& callback = NERtcCallback()) = 0;
    virtual void stopShareSystemAudio(const NERtcCallback& callback) = 0;
    virtual int enableLocalVideo(bool enable) = 0;
 
    virtual int setCloudProxy(NERoomRtcTransportType transportType) = 0;
 
    virtual int setVideoStreamLayerCount(NERoomRtcVideoStreamLayerCount layerCount) = 0;
};
 
}  // namespace neroom
 
#endif  // RTC_CTRL_INTERFACE_H