PanoRtcEngine.h

浏览该文件的文档.

 
#pragma once
#include "PanoRtcDefs.h"
#include "PanoRtcDevice.h"
#include "PanoRtcStats.h"
#include "PanoWhiteboard.h"
#include "PanoRtcStream.h"
#include "PanoVideoRender.h"
#include "PanoAnnotation.h"
#include "PanoRtcGroup.h"
#include "PanoRtcMessage.h"
#include "PanoObserver.h"
#include "PanoController.h"
#include "PanoRecording.h"
 
PANORTC_NS_BEGIN
 
 
class RtcEngine
{
public:
    class Callback;
 
    struct Configuration
    {
        Callback *callback = nullptr;
        const char* appId = nullptr;
        const char* rtcServer = nullptr;
        AudioAecType audioAecType = AudioAecType::Default;
        VideoHwAccelerationType videoHwAcceleration = VideoHwAccelerationType::None;
        uint32_t audioScenario = 0;
    };
 
    struct ChannelConfiguration
    {
        ChannelMode mode = ChannelMode::Mode_1v1;
        uint32_t serviceFlags = kChannelServiceMedia | kChannelServiceWhiteboard | kChannelServiceMessage;
        bool subscribeAudioAll = true;
        const char *userName = nullptr;
        int attendeeId = -1;
    };
 
    virtual QResult initialize(const Configuration &config) = 0;
 
    virtual QResult joinChannel(const char *token,
                                const char *channelId,
                                uint64_t userId,
                                const ChannelConfiguration &config) = 0;
 
    virtual QResult leaveChannel() = 0;
 
    virtual QResult startAudio() = 0;
    virtual QResult stopAudio() = 0;
    virtual QResult startSoundCardShare() = 0;
    virtual QResult stopSoundCardShare() = 0;
    virtual QResult startSoundCardMonitor(RtcRenderSink *sink) = 0;
    virtual QResult stopSoundCardMonitor() = 0;
    virtual QResult startVideo(void *window, const VideoConfig &config) = 0;
    virtual QResult startVideo(RtcRenderSink *sink, VideoProfileType profileType) = 0;
    virtual QResult startVideo(RtcRenderSink *sink, const VideoSourceConfig &config) = 0;
    virtual QResult stopVideo() = 0;
    virtual QResult subscribeAudio(uint64_t userId) = 0;
    virtual QResult unsubscribeAudio(uint64_t userId) = 0;
    virtual QResult subscribeVideo(uint64_t userId, void *window, const VideoConfig &config) = 0;
    virtual QResult subscribeVideo(uint64_t userId, RtcRenderSink *sink, VideoProfileType profileType) = 0;
    virtual QResult unsubscribeVideo(uint64_t userId) = 0;
    virtual QResult muteAudio() = 0;
    virtual QResult unmuteAudio() = 0;
    virtual QResult muteVideo() = 0;
    virtual QResult unmuteVideo() = 0;
 
    virtual QResult startScreen() = 0;
    virtual QResult startScreen(RtcRenderSink *sink) = 0;
    virtual QResult startScreen(RtcRenderSink *sink, const ScreenConfig &config) = 0;
    virtual QResult updateScreenConfig(const ScreenConfig &config) = 0;
    virtual QResult stopScreen() = 0;
    virtual QResult muteScreen() = 0;
    virtual QResult unmuteScreen() = 0;
    virtual QResult subscribeScreen(uint64_t userId, void *window) = 0;
    virtual QResult subscribeScreen(uint64_t userId, RtcRenderSink *sink) = 0;
    virtual QResult unsubscribeScreen(uint64_t userId) = 0;
 
    virtual QResult callout(const char *phoneNo, bool bindToUser) = 0;
    virtual QResult dropCall(const char *phoneNo) = 0;
 
    /* Update screen absolute scaling ratio. The default focus is center point of view. */
    virtual QResult updateScreenScalingRatio(uint64_t userId, ScreenScalingRatio ratio) = 0;
    /* Update screen relative scaling ratio. */
    virtual QResult updateScreenScalingRatioWithFocus(uint64_t userId, float ratio, int x, int y) = 0;
    /* Update screen relative moving distance. */
    virtual QResult updateScreenMovingDistance(uint64_t userId, int dx, int dy) = 0;
 
    virtual QResult startAudioDump(const char *filePath, int64_t maxFileSize = -1) = 0;
    virtual QResult stopAudioDump() = 0;
    virtual QResult setParameters(const char *param) = 0;
 
    virtual AudioDeviceManager* getAudioDeviceManager() = 0;
 
    virtual VideoDeviceManager* getVideoDeviceManager() = 0;
 
    virtual NetworkManager* getNetworkManager() = 0;
 
    virtual ScreenSourceManager* getScreenSourceManager() = 0;
 
    virtual AudioMixingManager* getAudioMixingManager() = 0;
 
    virtual VideoStreamManager* getVideoStreamManager() = 0;
 
    virtual VideoRenderManager* getVideoRenderManager() = 0;
 
    virtual AnnotationManager* getAnnotationManager() = 0;
 
    virtual RtcGroupManager* getGroupManager() = 0;
 
    virtual RtcMessage* getMessageService() = 0;
 
    virtual RemoteController* getRemoteController() = 0;
 
    virtual PanoRecording* getRecordingService() = 0;
 
    virtual RtcWhiteboard* getWhiteboardEngine() = 0;
 
    virtual QResult switchWhiteboardEngine(const char *whiteboardId) = 0;
 
    virtual QResult setMediaStatsObserver(MediaStatsObserver *observer) = 0;
 
    virtual QResult setScreenCaptureObserver(ScreenCaptureObserver *observer) = 0;
 
    virtual QResult setAudioIndication(AudioIndication *indication, uint32_t intervalMs = 200) = 0;
 
    virtual QResult setMediaProcessor(MediaProcessorType type, void * processor,  void * param = nullptr) = 0;
 
    virtual QResult snapshotVideo(const char *outputDir, uint64_t userId, SnapshotVideoOption option) = 0;
 
    virtual DeviceRating queryDeviceRating() = 0;
 
    virtual QResult setOption(OptionType option, void * param, uint32_t size) = 0;
 
    virtual QResult sendFeedback(const FeedbackInfo &info) = 0;
 
    virtual QResult sendAudioControlMessage(const PanoData & data) = 0;
 
    virtual void destroy() = 0;
 
 
    class Callback
    {
    public:
        virtual void onChannelJoinConfirm(QResult result) {}
        virtual void onChannelLeaveIndication(QResult result) {}
        virtual void onChannelCountDown(uint32_t remain) {}
        virtual void onUserJoinIndication(uint64_t userId, const char *userName) {}
        virtual void onUserLeaveIndication(uint64_t userId, UserLeaveReason reason) {}
        virtual void onUserAudioStart(uint64_t userId) {}
        virtual void onUserAudioStop(uint64_t userId) {}
        virtual void onUserAudioSubscribe(uint64_t userId, MediaSubscribeResult result) {}
        virtual void onUserVideoStart(uint64_t userId, VideoProfileType maxProfile) {}
        virtual void onUserVideoStop(uint64_t userId) {}
        virtual void onUserVideoSubscribe(uint64_t userId, MediaSubscribeResult result) {}
        virtual void onUserAudioMute(uint64_t userId) {}
        virtual void onUserAudioUnmute(uint64_t userId) {}
        virtual void onUserVideoMute(uint64_t userId) {}
        virtual void onUserVideoUnmute(uint64_t userId) {}
 
        virtual void onUserScreenStart(uint64_t userId) {}
        virtual void onUserScreenStop(uint64_t userId) {}
        virtual void onUserScreenSubscribe(uint64_t userId, MediaSubscribeResult result) {}
        virtual void onUserScreenMute(uint64_t userId) {}
        virtual void onUserScreenUnmute(uint64_t userId) {}
 
        virtual void onWhiteboardAvailable() {}
        virtual void onWhiteboardUnavailable() {}
        virtual void onWhiteboardStart() {}
        virtual void onWhiteboardStop() {}
        virtual void onWhiteboardStart(const char *whiteboardId) {}
        virtual void onWhiteboardStop(const char *whiteboardId) {}
 
        virtual void onFirstAudioDataReceived(uint64_t userId) {}
        virtual void onFirstVideoDataReceived(uint64_t userId) {}
        virtual void onFirstScreenDataReceived(uint64_t userId) {}
        
        virtual void onFirstVideoFrameRendered(uint64_t userId) {}
        virtual void onFirstScreenFrameRendered(uint64_t userId) {}
 
        virtual void onAudioDeviceStateChanged(const char deviceID[kMaxDeviceIDLength],
                                               AudioDeviceType deviceType,
                                               AudioDeviceState deviceState) {}
        virtual void onAudioDefaultDeviceChanged(const char deviceID[kMaxDeviceIDLength],
                                                 AudioDeviceType deviceType) {}
        virtual void onVideoDeviceStateChanged(const char deviceID[kMaxDeviceIDLength],
                                               VideoDeviceType deviceType,
                                               VideoDeviceState deviceState) {}
        virtual void onVideoCaptureStateChanged(const char deviceID[kMaxDeviceIDLength],
                                                VideoCaptureState state) {}
 
        virtual void onChannelFailover(FailoverState state) {}
 
        virtual void onActiveSpeakerListUpdated(const uint64_t *userIds, size_t count) {}
 
        virtual void onAudioMixingStateChanged(int64_t taskId, AudioMixingState state) {}
 
        virtual void onVideoSnapshotCompleted(bool succeed, uint64_t userId, const char *filename) {}
 
        virtual void onNetworkQuality(uint64_t userId, QualityRating quality) {}
 
        virtual void onAudioStartResult(QResult result) {}
        virtual void onVideoStartResult(QResult result) {}
        virtual void onScreenStartResult(QResult result) {}
        virtual void onScreenCaptureStateChanged(ScreenCaptureState state, QResult reason) {}
        virtual void onSoundCardShareStartResult(QResult result) {}
        virtual void onSoundCardMonitorStartResult(QResult result) {}
        virtual void onUserAudioControlMessageReceived(uint64_t userId, const PanoData & data) {}
        virtual void onUserAudioCallTypeChanged(uint64_t userId, AudioCallType type) {}
        virtual void onCalloutResult(const char *phoneNo, QResult result) {}
 
        virtual ~Callback() = default;
    };
 
protected:
    virtual ~RtcEngine() {}
};
 
PANORTC_NS_END
 
 
#ifdef __cplusplus
extern "C" {
#endif
    PANORTC_API panortc::RtcEngine* createPanoRtcEngine();
    PANORTC_API panortc::RtcEngine* createPanoRtcEngineWithConfig(const panortc::RtcEngine::Configuration &config);
    PANORTC_API void setPanoLogLevel(panortc::LogLevel level);
 
    PANORTC_API const char* getPanoSdkVersion();
 
    PANORTC_API void initPanoGlobalConfigs(const char* configs);
 
#ifdef __cplusplus
}
#endif