IAgoraRecordingEngine.h

Go to the documentation of this file.

           #ifndef _IAGORA_RECORDINGENGINE_H_
        

           #define _IAGORA_RECORDINGENGINE_H_
        

           #include "IAgoraLinuxSdkCommon.h"
        


           namespace agora {
        

           namespace recording {
        

           class IRecordingEngineEventHandler
          {
        


           public:
        

            virtual
          ~IRecordingEngineEventHandler() {}
        


            virtual void
          onError(int error,
          agora::linuxsdk::STAT_CODE_TYPE
          stat_code) = 0;
        


            virtual void
          onWarning(int warn) = 0;
        


            virtual void
          onJoinChannelSuccess(const char * channelId,
          uid_t
          uid) = 0;
        


            virtual void
          onLeaveChannel(agora::linuxsdk::LEAVE_PATH_CODE
          code) = 0;
        


            virtual void
          onUserJoined(uid_t
          uid,
          agora::linuxsdk::UserJoinInfos
          &infos) = 0;
        


            virtual void
          onRemoteVideoStreamStateChanged(uid_t
          uid,
          linuxsdk::RemoteStreamState
          state,
          linuxsdk::RemoteStreamStateChangedReason
          reason) = 0;
        


            virtual void
          onRemoteAudioStreamStateChanged(uid_t
          uid,
          linuxsdk::RemoteStreamState
          state,
          linuxsdk::RemoteStreamStateChangedReason
          reason) = 0;
        


            virtual void
          onUserOffline(uid_t
          uid,
          agora::linuxsdk::USER_OFFLINE_REASON_TYPE
          reason) = 0;
        


            virtual void
          audioFrameReceived(unsigned int uid,
          const
          agora::linuxsdk::AudioFrame
          *frame) const = 0;
        


            virtual void
          videoFrameReceived(unsigned int uid,
          const
          agora::linuxsdk::VideoFrame
          *frame) const = 0;
        


            virtual void
          onActiveSpeaker(uid_t
          uid) = 0;
        


            virtual void
          onAudioVolumeIndication(const
          agora::linuxsdk::AudioVolumeInfo* speakers, unsigned
          int speakerNum) = 0;
        


            virtual void
          onFirstRemoteVideoDecoded(uid_t
          uid, int width,
          int height, int elapsed)
          = 0;
        


            virtual void
          onFirstRemoteAudioFrame(uid_t
          uid, int elapsed) = 0;
        


            virtual void
          onReceivingStreamStatusChanged(bool receivingAudio,
          bool receivingVideo) = 0;
        


            virtual void
          onConnectionLost() = 0;
        


            virtual void
          onConnectionInterrupted() = 0;
        


            virtual void
          onRejoinChannelSuccess(const char* channelId,
          uid_t
          uid) = 0;
        


            virtual void
          onConnectionStateChanged(agora::linuxsdk::ConnectionStateType
          state,
          agora::linuxsdk::ConnectionChangedReasonType
          reason) = 0;
        


            virtual void
          onRemoteVideoStats(agora::linuxsdk::uid_t
          uid, const
          agora::linuxsdk::RemoteVideoStats& stats) = 0;
        


            virtual void
          onRemoteAudioStats(agora::linuxsdk::uid_t
          uid, const
          agora::linuxsdk::RemoteAudioStats& stats) = 0;
        


            virtual void
          onRecordingStats(const
          agora::linuxsdk::RecordingStats& stats) = 0;
        


            virtual void
          onLocalUserRegistered(uid_t
          uid, const char*
          userAccount) = 0;
        


            virtual void
          onUserInfoUpdated(uid_t
          uid, const
          agora::linuxsdk::UserInfo& info) = 0;
        
};


           typedef struct RecordingConfig
          {
        

            bool
          isAudioOnly;
        

            bool
          isVideoOnly;
        

            bool
          isMixingEnabled;
        

            bool
          autoSubscribe;
        

            bool
          enableCloudProxy;
        

           
          agora::linuxsdk::MIXED_AV_CODEC_TYPE
          mixedVideoAudio;
        

            const char *
          mixResolution;
        

            const char *
          decryptionMode;
        

            const char *
          secret;
        

            const char *
          appliteDir;
        

            const char *
          recordFileRootDir;
        

            const char *
          cfgFilePath;
        

           
          agora::linuxsdk::VIDEO_FORMAT_TYPE
          decodeVideo;
        

           
          agora::linuxsdk::AUDIO_FORMAT_TYPE
          decodeAudio;
        

            int
          lowUdpPort;
        

            int
          highUdpPort;
        

            int
          idleLimitSec;
        

            int
          captureInterval;
        

            int
          audioIndicationInterval;
        

           
          agora::linuxsdk::CHANNEL_PROFILE_TYPE
          channelProfile;
        

           
          agora::linuxsdk::REMOTE_VIDEO_STREAM_TYPE
          streamType;
        

           
          agora::linuxsdk::TRIGGER_MODE_TYPE
          triggerMode;
        

           
          agora::linuxsdk::LANGUAGE_TYPE
          lang;
        

            int
          proxyType;
        

            const char *
          proxyServer;
        

           
          agora::linuxsdk::AUDIO_PROFILE_TYPE
          audioProfile;
        

            const char *
          defaultVideoBg;
        

            const char *
          defaultUserBg;
        

            const char *
          subscribeVideoUids;
        

            const char *
          subscribeAudioUids;
        


            bool
          enableIntraRequest;
        


            bool
          enableH265Support;
        



           
          RecordingConfig():isAudioOnly(false),
        

           
          isVideoOnly(false),
        

           
          isMixingEnabled(false),
        

           
          autoSubscribe(true),
        

           
          enableCloudProxy(false),
        

           
          mixedVideoAudio(agora::linuxsdk::MIXED_AV_DEFAULT),
        

           
          mixResolution(NULL),
        

           
          decryptionMode(NULL),
        

           
          secret(NULL),
        

           
          appliteDir(NULL),
        

           
          recordFileRootDir(NULL),
        

           
          cfgFilePath(NULL),
        

           
          decodeVideo(agora::linuxsdk::VIDEO_FORMAT_DEFAULT_TYPE),
        

           
          decodeAudio(agora::linuxsdk::AUDIO_FORMAT_DEFAULT_TYPE),
        

           
          lowUdpPort(0),
        

           
          highUdpPort(0),
        

           
          idleLimitSec(300),
        

           
          captureInterval(5),
        

           
          audioIndicationInterval(0),
        

           
          channelProfile(agora::linuxsdk::CHANNEL_PROFILE_COMMUNICATION),
        

           
          streamType(agora::linuxsdk::REMOTE_VIDEO_STREAM_HIGH),
        

           
          triggerMode(agora::linuxsdk::AUTOMATICALLY_MODE),
        

           
          lang(agora::linuxsdk::CPP_LANG),
        

           
          proxyType(1),
        

           
          proxyServer(NULL),
        

           
          audioProfile(agora::linuxsdk::AUDIO_PROFILE_DEFAULT),
        

           
          defaultVideoBg(NULL),
        

           
          defaultUserBg(NULL),
        

           
          subscribeVideoUids(NULL),
        

           
          subscribeAudioUids(NULL),
        

           
          enableIntraRequest(true),
        

           
          enableH265Support(false)
        
 {}


            virtual
          ~RecordingConfig() {}
        

           }
          RecordingConfig;
        


           typedef struct RecordingEngineProperties
          {
        

            char*
          storageDir;
        

           
          RecordingEngineProperties():
          storageDir(NULL)
        
 {}

           }RecordingEngineProperties;
        


           class IRecordingEngine
          {
        

           public:
        


            static
          IRecordingEngine*
          createAgoraRecordingEngine(const char * appId,
          IRecordingEngineEventHandler
          *eventHandler);
        


            virtual
          ~IRecordingEngine() {}
        


            virtual int
          joinChannel(const char * channelKey,
          const char *channelId,
          uid_t
          uid, const
          RecordingConfig
          &config) = 0;
        


            virtual int
          joinChannelWithUserAccount(const char* token,
          const char* channelId,
          const char*userAccount,
          const
          RecordingConfig& config) = 0;
        


            virtual int
          getUserInfoByUserAccount(const char* userAccount,
          agora::linuxsdk::UserInfo* userinfo) = 0;
        


            virtual int
          getUserInfoByUid(uid_t
          uid,
          agora::linuxsdk::UserInfo* userInfo) = 0;
        


            virtual int
          setVideoMixingLayout(const
          agora::linuxsdk::VideoMixingLayout
          &layout) = 0;
        


            virtual int
          stoppedOnError() = 0;
        


            virtual int
          leaveChannel() = 0;
        


            virtual int
          release() = 0;
        


            virtual const
          RecordingEngineProperties*
          getProperties() = 0;
        


            virtual int
          startService() = 0;
        


            virtual int
          stopService() = 0;
        


            virtual int
          setUserBackground(uid_t
          uid, const char* img_path) =
          0;
        


            virtual int
          setLogLevel(agora::linuxsdk::agora_log_level
          level) = 0;
        


            virtual int
          updateSubscribeVideoUids(uid_t
          *uids, uint32_t num) = 0;
        


            virtual int
          updateSubscribeAudioUids(uid_t
          *uids, uint32_t num) = 0;
        


            virtual int
          updateWatermarkConfigs(uint32_t wm_num,
          linuxsdk::WatermarkConfig* config) = 0;
        
};

}
}


           #endif