/// Generated by terra, DO NOT MODIFY BY HAND.

#ifndef FAKE_IRTCENGINEEX_INTERNAL_H_
#define FAKE_IRTCENGINEEX_INTERNAL_H_

#include "IAgoraMediaPlayer.h"
#include "IAgoraRtcEngineEx.h"

namespace agora {
namespace rtc {
class FakeIRtcEngineExInternal : public agora::rtc::IRtcEngineEx {
  virtual int queryInterface(rtc::INTERFACE_ID_TYPE iid,
                             void **inter) override {
    return 0;
  }

  virtual void release(bool sync) override {}

  virtual int initialize(agora::rtc::RtcEngineContext const &context) override {
    return 0;
  }

  virtual char const *getVersion(int *build) override { return ""; }

  virtual char const *getErrorDescription(int code) override { return ""; }

  virtual int joinChannel(char const *token, char const *channelId,
                          char const *info, agora::rtc::uid_t uid) override {
    return 0;
  }

  virtual int
  joinChannel(char const *token, char const *channelId, agora::rtc::uid_t uid,
              agora::rtc::ChannelMediaOptions const &options) override {
    return 0;
  }

  virtual int updateChannelMediaOptions(
      agora::rtc::ChannelMediaOptions const &options) override {
    return 0;
  }

  virtual int leaveChannel() override { return 0; }

  virtual int
  leaveChannel(agora::rtc::LeaveChannelOptions const &options) override {
    return 0;
  }

  virtual int renewToken(char const *token) override { return 0; }

  virtual int setChannelProfile(agora::CHANNEL_PROFILE_TYPE profile) override {
    return 0;
  }

  virtual int setClientRole(agora::rtc::CLIENT_ROLE_TYPE role) override {
    return 0;
  }

  virtual int
  setClientRole(agora::rtc::CLIENT_ROLE_TYPE role,
                agora::rtc::ClientRoleOptions const &options) override {
    return 0;
  }

  virtual int startEchoTest() override { return 0; }

  virtual int startEchoTest(int intervalInSeconds) override { return 0; }

  virtual int
  startEchoTest(agora::rtc::EchoTestConfiguration const &config) override {
    return 0;
  }

  virtual int stopEchoTest() override { return 0; }

#if defined(__APPLE__) && TARGET_OS_IOS
  virtual int enableMultiCamera(
      bool enabled,
      agora::rtc::CameraCapturerConfiguration const &config) override {
    return 0;
  }
#endif

  virtual int enableVideo() override { return 0; }

  virtual int disableVideo() override { return 0; }

  virtual int startPreview() override { return 0; }

  virtual int startPreview(agora::rtc::VIDEO_SOURCE_TYPE sourceType) override {
    return 0;
  }

  virtual int stopPreview() override { return 0; }

  virtual int stopPreview(agora::rtc::VIDEO_SOURCE_TYPE sourceType) override {
    return 0;
  }

  virtual int startLastmileProbeTest(
      agora::rtc::LastmileProbeConfig const &config) override {
    return 0;
  }

  virtual int stopLastmileProbeTest() override { return 0; }

  virtual int setVideoEncoderConfiguration(
      agora::rtc::VideoEncoderConfiguration const &config) override {
    return 0;
  }

  virtual int
  setBeautyEffectOptions(bool enabled, agora::rtc::BeautyOptions const &options,
                         agora::media::MEDIA_SOURCE_TYPE type) override {
    return 0;
  }

  virtual int
  setLowlightEnhanceOptions(bool enabled,
                            agora::rtc::LowlightEnhanceOptions const &options,
                            agora::media::MEDIA_SOURCE_TYPE type) override {
    return 0;
  }

  virtual int
  setVideoDenoiserOptions(bool enabled,
                          agora::rtc::VideoDenoiserOptions const &options,
                          agora::media::MEDIA_SOURCE_TYPE type) override {
    return 0;
  }

  virtual int
  setColorEnhanceOptions(bool enabled,
                         agora::rtc::ColorEnhanceOptions const &options,
                         agora::media::MEDIA_SOURCE_TYPE type) override {
    return 0;
  }

  virtual int
  enableVirtualBackground(bool enabled,
                          agora::rtc::VirtualBackgroundSource backgroundSource,
                          agora::rtc::SegmentationProperty segproperty,
                          agora::media::MEDIA_SOURCE_TYPE type) override {
    return 0;
  }

  virtual int enableRemoteSuperResolution(agora::rtc::uid_t userId,
                                          bool enable) override {
    return 0;
  }

  virtual int setupRemoteVideo(agora::rtc::VideoCanvas const &canvas) override {
    return 0;
  }

  virtual int setupLocalVideo(agora::rtc::VideoCanvas const &canvas) override {
    return 0;
  }

  virtual int enableAudio() override { return 0; }

  virtual int disableAudio() override { return 0; }

  virtual int
  setAudioProfile(agora::rtc::AUDIO_PROFILE_TYPE profile,
                  agora::rtc::AUDIO_SCENARIO_TYPE scenario) override {
    return 0;
  }

  virtual int setAudioProfile(agora::rtc::AUDIO_PROFILE_TYPE profile) override {
    return 0;
  }

  virtual int
  setAudioScenario(agora::rtc::AUDIO_SCENARIO_TYPE scenario) override {
    return 0;
  }

  virtual int enableLocalAudio(bool enabled) override { return 0; }

  virtual int muteLocalAudioStream(bool mute) override { return 0; }

  virtual int muteAllRemoteAudioStreams(bool mute) override { return 0; }

  virtual int setDefaultMuteAllRemoteAudioStreams(bool mute) override {
    return 0;
  }

  virtual int muteRemoteAudioStream(agora::rtc::uid_t uid, bool mute) override {
    return 0;
  }

  virtual int muteLocalVideoStream(bool mute) override { return 0; }

  virtual int enableLocalVideo(bool enabled) override { return 0; }

  virtual int muteAllRemoteVideoStreams(bool mute) override { return 0; }

  virtual int setDefaultMuteAllRemoteVideoStreams(bool mute) override {
    return 0;
  }

  virtual int muteRemoteVideoStream(agora::rtc::uid_t uid, bool mute) override {
    return 0;
  }

  virtual int
  setRemoteVideoStreamType(agora::rtc::uid_t uid,
                           agora::rtc::VIDEO_STREAM_TYPE streamType) override {
    return 0;
  }

  virtual int setRemoteVideoSubscriptionOptions(
      agora::rtc::uid_t uid,
      agora::rtc::VideoSubscriptionOptions const &options) override {
    return 0;
  }

  virtual int setRemoteDefaultVideoStreamType(
      agora::rtc::VIDEO_STREAM_TYPE streamType) override {
    return 0;
  }

  virtual int setSubscribeAudioBlocklist(agora::rtc::uid_t *uidList,
                                         int uidNumber) override {
    return 0;
  }

  virtual int setSubscribeAudioAllowlist(agora::rtc::uid_t *uidList,
                                         int uidNumber) override {
    return 0;
  }

  virtual int setSubscribeVideoBlocklist(agora::rtc::uid_t *uidList,
                                         int uidNumber) override {
    return 0;
  }

  virtual int setSubscribeVideoAllowlist(agora::rtc::uid_t *uidList,
                                         int uidNumber) override {
    return 0;
  }

  virtual int enableAudioVolumeIndication(int interval, int smooth,
                                          bool reportVad) override {
    return 0;
  }

  virtual int startAudioRecording(
      char const *filePath,
      agora::rtc::AUDIO_RECORDING_QUALITY_TYPE quality) override {
    return 0;
  }

  virtual int startAudioRecording(
      char const *filePath, int sampleRate,
      agora::rtc::AUDIO_RECORDING_QUALITY_TYPE quality) override {
    return 0;
  }

  virtual int startAudioRecording(
      agora::rtc::AudioRecordingConfiguration const &config) override {
    return 0;
  }

  virtual int registerAudioEncodedFrameObserver(
      agora::rtc::AudioEncodedFrameObserverConfig const &config,
      agora::rtc::IAudioEncodedFrameObserver *observer) override {
    return 0;
  }

  virtual int stopAudioRecording() override { return 0; }

  virtual agora_refptr<agora::rtc::IMediaPlayer> createMediaPlayer() override {
    agora_refptr<agora::rtc::IMediaPlayer> the_return;
    return the_return;
  }

  virtual int destroyMediaPlayer(
      agora_refptr<agora::rtc::IMediaPlayer> media_player) override {
    return 0;
  }

  virtual int startAudioMixing(char const *filePath, bool loopback,
                               int cycle) override {
    return 0;
  }

  virtual int startAudioMixing(char const *filePath, bool loopback, int cycle,
                               int startPos) override {
    return 0;
  }

  virtual int stopAudioMixing() override { return 0; }

  virtual int pauseAudioMixing() override { return 0; }

  virtual int resumeAudioMixing() override { return 0; }

  virtual int selectAudioTrack(int index) override { return 0; }

  virtual int getAudioTrackCount() override { return 0; }

  virtual int adjustAudioMixingVolume(int volume) override { return 0; }

  virtual int adjustAudioMixingPublishVolume(int volume) override { return 0; }

  virtual int getAudioMixingPublishVolume() override { return 0; }

  virtual int adjustAudioMixingPlayoutVolume(int volume) override { return 0; }

  virtual int getAudioMixingPlayoutVolume() override { return 0; }

  virtual int getAudioMixingDuration() override { return 0; }

  virtual int getAudioMixingCurrentPosition() override { return 0; }

  virtual int setAudioMixingPosition(int pos) override { return 0; }

  virtual int
  setAudioMixingDualMonoMode(media::AUDIO_MIXING_DUAL_MONO_MODE mode) override {
    return 0;
  }

  virtual int setAudioMixingPitch(int pitch) override { return 0; }

  virtual int getEffectsVolume() override { return 0; }

  virtual int setEffectsVolume(int volume) override { return 0; }

  virtual int preloadEffect(int soundId, char const *filePath,
                            int startPos) override {
    return 0;
  }

  virtual int playEffect(int soundId, char const *filePath, int loopCount,
                         double pitch, double pan, int gain, bool publish,
                         int startPos) override {
    return 0;
  }

  virtual int playAllEffects(int loopCount, double pitch, double pan, int gain,
                             bool publish) override {
    return 0;
  }

  virtual int getVolumeOfEffect(int soundId) override { return 0; }

  virtual int setVolumeOfEffect(int soundId, int volume) override { return 0; }

  virtual int pauseEffect(int soundId) override { return 0; }

  virtual int pauseAllEffects() override { return 0; }

  virtual int resumeEffect(int soundId) override { return 0; }

  virtual int resumeAllEffects() override { return 0; }

  virtual int stopEffect(int soundId) override { return 0; }

  virtual int stopAllEffects() override { return 0; }

  virtual int unloadEffect(int soundId) override { return 0; }

  virtual int unloadAllEffects() override { return 0; }

  virtual int getEffectDuration(char const *filePath) override { return 0; }

  virtual int setEffectPosition(int soundId, int pos) override { return 0; }

  virtual int getEffectCurrentPosition(int soundId) override { return 0; }

  virtual int enableSoundPositionIndication(bool enabled) override { return 0; }

  virtual int setRemoteVoicePosition(agora::rtc::uid_t uid, double pan,
                                     double gain) override {
    return 0;
  }

  virtual int enableSpatialAudio(bool enabled) override { return 0; }

  virtual int setRemoteUserSpatialAudioParams(
      agora::rtc::uid_t uid, agora::SpatialAudioParams const &params) override {
    return 0;
  }

  virtual int setVoiceBeautifierPreset(
      agora::rtc::VOICE_BEAUTIFIER_PRESET preset) override {
    return 0;
  }

  virtual int
  setAudioEffectPreset(agora::rtc::AUDIO_EFFECT_PRESET preset) override {
    return 0;
  }

  virtual int setVoiceConversionPreset(
      agora::rtc::VOICE_CONVERSION_PRESET preset) override {
    return 0;
  }

  virtual int setAudioEffectParameters(agora::rtc::AUDIO_EFFECT_PRESET preset,
                                       int param1, int param2) override {
    return 0;
  }

  virtual int
  setVoiceBeautifierParameters(agora::rtc::VOICE_BEAUTIFIER_PRESET preset,
                               int param1, int param2) override {
    return 0;
  }

  virtual int
  setVoiceConversionParameters(agora::rtc::VOICE_CONVERSION_PRESET preset,
                               int param1, int param2) override {
    return 0;
  }

  virtual int setLocalVoicePitch(double pitch) override { return 0; }

  virtual int setLocalVoiceEqualization(
      agora::rtc::AUDIO_EQUALIZATION_BAND_FREQUENCY bandFrequency,
      int bandGain) override {
    return 0;
  }

  virtual int setLocalVoiceReverb(agora::rtc::AUDIO_REVERB_TYPE reverbKey,
                                  int value) override {
    return 0;
  }

  virtual int
  setHeadphoneEQPreset(agora::rtc::HEADPHONE_EQUALIZER_PRESET preset) override {
    return 0;
  }

  virtual int setHeadphoneEQParameters(int lowGain, int highGain) override {
    return 0;
  }

  virtual int setLogFile(char const *filePath) override { return 0; }

  virtual int setLogFilter(unsigned int filter) override { return 0; }

  virtual int setLogLevel(commons::LOG_LEVEL level) override { return 0; }

  virtual int setLogFileSize(unsigned int fileSizeInKBytes) override {
    return 0;
  }

  virtual int uploadLogFile(agora::util::AString &requestId) override {
    return 0;
  }

  virtual int
  setLocalRenderMode(media::base::RENDER_MODE_TYPE renderMode,
                     agora::rtc::VIDEO_MIRROR_MODE_TYPE mirrorMode) override {
    return 0;
  }

  virtual int
  setRemoteRenderMode(agora::rtc::uid_t uid,
                      media::base::RENDER_MODE_TYPE renderMode,
                      agora::rtc::VIDEO_MIRROR_MODE_TYPE mirrorMode) override {
    return 0;
  }

  virtual int
  setLocalRenderMode(media::base::RENDER_MODE_TYPE renderMode) override {
    return 0;
  }

  virtual int setLocalVideoMirrorMode(
      agora::rtc::VIDEO_MIRROR_MODE_TYPE mirrorMode) override {
    return 0;
  }

  virtual int enableDualStreamMode(bool enabled) override { return 0; }

  virtual int enableDualStreamMode(
      bool enabled,
      agora::rtc::SimulcastStreamConfig const &streamConfig) override {
    return 0;
  }

  virtual int
  setDualStreamMode(agora::rtc::SIMULCAST_STREAM_MODE mode) override {
    return 0;
  }

  virtual int setDualStreamMode(
      agora::rtc::SIMULCAST_STREAM_MODE mode,
      agora::rtc::SimulcastStreamConfig const &streamConfig) override {
    return 0;
  }

  virtual int enableEchoCancellationExternal(bool enabled,
                                             int audioSourceDelay) override {
    return 0;
  }

  virtual int enableCustomAudioLocalPlayback(int sourceId,
                                             bool enabled) override {
    return 0;
  }

  virtual int startPrimaryCustomAudioTrack(
      agora::rtc::AudioTrackConfig const &config) override {
    return 0;
  }

  virtual int stopPrimaryCustomAudioTrack() override { return 0; }

  virtual int startSecondaryCustomAudioTrack(
      agora::rtc::AudioTrackConfig const &config) override {
    return 0;
  }

  virtual int stopSecondaryCustomAudioTrack() override { return 0; }

  virtual int setRecordingAudioFrameParameters(
      int sampleRate, int channel,
      agora::rtc::RAW_AUDIO_FRAME_OP_MODE_TYPE mode,
      int samplesPerCall) override {
    return 0;
  }

  virtual int
  setPlaybackAudioFrameParameters(int sampleRate, int channel,
                                  agora::rtc::RAW_AUDIO_FRAME_OP_MODE_TYPE mode,
                                  int samplesPerCall) override {
    return 0;
  }

  virtual int setMixedAudioFrameParameters(int sampleRate, int channel,
                                           int samplesPerCall) override {
    return 0;
  }

  virtual int setEarMonitoringAudioFrameParameters(
      int sampleRate, int channel,
      agora::rtc::RAW_AUDIO_FRAME_OP_MODE_TYPE mode,
      int samplesPerCall) override {
    return 0;
  }

  virtual int
  setPlaybackAudioFrameBeforeMixingParameters(int sampleRate,
                                              int channel) override {
    return 0;
  }

  virtual int enableAudioSpectrumMonitor(int intervalInMS) override {
    return 0;
  }

  virtual int disableAudioSpectrumMonitor() override { return 0; }

  virtual int registerAudioSpectrumObserver(
      agora::media::IAudioSpectrumObserver *observer) override {
    return 0;
  }

  virtual int unregisterAudioSpectrumObserver(
      agora::media::IAudioSpectrumObserver *observer) override {
    return 0;
  }

  virtual int adjustRecordingSignalVolume(int volume) override { return 0; }

  virtual int muteRecordingSignal(bool mute) override { return 0; }

  virtual int adjustPlaybackSignalVolume(int volume) override { return 0; }

  virtual int adjustUserPlaybackSignalVolume(unsigned int uid,
                                             int volume) override {
    return 0;
  }

  virtual int setLocalPublishFallbackOption(
      agora::rtc::STREAM_FALLBACK_OPTIONS option) override {
    return 0;
  }

  virtual int setRemoteSubscribeFallbackOption(
      agora::rtc::STREAM_FALLBACK_OPTIONS option) override {
    return 0;
  }

  virtual int enableLoopbackRecording(bool enabled,
                                      char const *deviceName) override {
    return 0;
  }

  virtual int adjustLoopbackSignalVolume(int volume) override { return 0; }

  virtual int getLoopbackRecordingVolume() override { return 0; }

  virtual int enableInEarMonitoring(bool enabled,
                                    int includeAudioFilters) override {
    return 0;
  }

  virtual int setInEarMonitoringVolume(int volume) override { return 0; }

#if defined(_WIN32) || defined(__linux__) || defined(__ANDROID__)
  virtual int loadExtensionProvider(char const *path,
                                    bool unload_after_use) override {
    return 0;
  }
#endif

  virtual int setExtensionProviderProperty(char const *provider,
                                           char const *key,
                                           char const *value) override {
    return 0;
  }

  virtual int enableExtension(char const *provider, char const *extension,
                              bool enable,
                              agora::media::MEDIA_SOURCE_TYPE type) override {
    return 0;
  }

  virtual int
  setExtensionProperty(char const *provider, char const *extension,
                       char const *key, char const *value,
                       agora::media::MEDIA_SOURCE_TYPE type) override {
    return 0;
  }

  virtual int
  getExtensionProperty(char const *provider, char const *extension,
                       char const *key, char *value, int buf_len,
                       agora::media::MEDIA_SOURCE_TYPE type) override {
    return 0;
  }

  virtual int enableExtension(char const *provider, char const *extension,
                              agora::rtc::ExtensionInfo const &extensionInfo,
                              bool enable) override {
    return 0;
  }

  virtual int
  setExtensionProperty(char const *provider, char const *extension,
                       agora::rtc::ExtensionInfo const &extensionInfo,
                       char const *key, char const *value) override {
    return 0;
  }

  virtual int
  getExtensionProperty(char const *provider, char const *extension,
                       agora::rtc::ExtensionInfo const &extensionInfo,
                       char const *key, char *value, int buf_len) override {
    return 0;
  }

  virtual int setCameraCapturerConfiguration(
      agora::rtc::CameraCapturerConfiguration const &config) override {
    return 0;
  }

  virtual agora::rtc::video_track_id_t createCustomVideoTrack() override {
    agora::rtc::video_track_id_t the_return;
    return the_return;
  }

  virtual agora::rtc::video_track_id_t createCustomEncodedVideoTrack(
      agora::rtc::SenderOptions const &sender_option) override {
    agora::rtc::video_track_id_t the_return;
    return the_return;
  }

  virtual int destroyCustomVideoTrack(
      agora::rtc::video_track_id_t video_track_id) override {
    return 0;
  }

  virtual int destroyCustomEncodedVideoTrack(
      agora::rtc::video_track_id_t video_track_id) override {
    return 0;
  }

#if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS)
  virtual int switchCamera() override { return 0; }
#endif

#if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS)
  virtual bool isCameraZoomSupported() override { return 0; }
#endif

#if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS)
  virtual bool isCameraFaceDetectSupported() override { return 0; }
#endif

#if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS)
  virtual bool isCameraTorchSupported() override { return 0; }
#endif

#if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS)
  virtual bool isCameraFocusSupported() override { return 0; }
#endif

#if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS)
  virtual bool isCameraAutoFocusFaceModeSupported() override { return 0; }
#endif

#if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS)
  virtual int setCameraZoomFactor(float factor) override { return 0; }
#endif

#if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS)
  virtual int enableFaceDetection(bool enabled) override { return 0; }
#endif

#if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS)
  virtual float getCameraMaxZoomFactor() override { return 0; }
#endif

#if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS)
  virtual int setCameraFocusPositionInPreview(float positionX,
                                              float positionY) override {
    return 0;
  }
#endif

#if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS)
  virtual int setCameraTorchOn(bool isOn) override { return 0; }
#endif

#if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS)
  virtual int setCameraAutoFocusFaceModeEnabled(bool enabled) override {
    return 0;
  }
#endif

#if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS)
  virtual bool isCameraExposurePositionSupported() override { return 0; }
#endif

#if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS)
  virtual int setCameraExposurePosition(float positionXinView,
                                        float positionYinView) override {
    return 0;
  }
#endif

#if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS)
#if defined(__APPLE__)
  virtual bool isCameraAutoExposureFaceModeSupported() override { return 0; }
#endif
#endif

#if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS)
#if defined(__APPLE__)
  virtual int setCameraAutoExposureFaceModeEnabled(bool enabled) override {
    return 0;
  }
#endif
#endif

#if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS)
  virtual int
  setDefaultAudioRouteToSpeakerphone(bool defaultToSpeaker) override {
    return 0;
  }
#endif

#if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS)
  virtual int setEnableSpeakerphone(bool speakerOn) override { return 0; }
#endif

#if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS)
  virtual bool isSpeakerphoneEnabled() override { return 0; }
#endif

#if defined(_WIN32) ||                                                         \
    (defined(__APPLE__) && TARGET_OS_MAC && !TARGET_OS_IPHONE)
  virtual agora::rtc::IScreenCaptureSourceList *
  getScreenCaptureSources(agora::rtc::SIZE const &thumbSize,
                          agora::rtc::SIZE const &iconSize,
                          bool const includeScreen) override {
    return 0;
  }
#endif

#if (defined(__APPLE__) && TARGET_OS_IOS)
  virtual int setAudioSessionOperationRestriction(
      agora::AUDIO_SESSION_OPERATION_RESTRICTION restriction) override {
    return 0;
  }
#endif

#if defined(_WIN32) ||                                                         \
    (defined(__APPLE__) && !TARGET_OS_IPHONE && TARGET_OS_MAC)
  virtual int startScreenCaptureByDisplayId(
      uint32_t displayId, agora::rtc::Rectangle const &regionRect,
      agora::rtc::ScreenCaptureParameters const &captureParams) override {
    return 0;
  }
#endif

#if defined(_WIN32)
  virtual int startScreenCaptureByScreenRect(
      agora::rtc::Rectangle const &screenRect,
      agora::rtc::Rectangle const &regionRect,
      agora::rtc::ScreenCaptureParameters const &captureParams) override {
    return 0;
  }
#endif

#if defined(__ANDROID__)
  virtual int getAudioDeviceInfo(agora::rtc::DeviceInfo &deviceInfo) override {
    return 0;
  }
#endif

#if defined(_WIN32) ||                                                         \
    (defined(__APPLE__) && TARGET_OS_MAC && !TARGET_OS_IPHONE)
  virtual int startScreenCaptureByWindowId(
      agora::view_t windowId, agora::rtc::Rectangle const &regionRect,
      agora::rtc::ScreenCaptureParameters const &captureParams) override {
    return 0;
  }
#endif

#if defined(_WIN32) ||                                                         \
    (defined(__APPLE__) && TARGET_OS_MAC && !TARGET_OS_IPHONE)
  virtual int setScreenCaptureContentHint(
      agora::rtc::VIDEO_CONTENT_HINT contentHint) override {
    return 0;
  }
#endif

#if defined(_WIN32) ||                                                         \
    (defined(__APPLE__) && TARGET_OS_MAC && !TARGET_OS_IPHONE)
  virtual int setScreenCaptureScenario(
      agora::rtc::SCREEN_SCENARIO_TYPE screenScenario) override {
    return 0;
  }
#endif

#if defined(_WIN32) ||                                                         \
    (defined(__APPLE__) && TARGET_OS_MAC && !TARGET_OS_IPHONE)
  virtual int
  updateScreenCaptureRegion(agora::rtc::Rectangle const &regionRect) override {
    return 0;
  }
#endif

#if defined(_WIN32) ||                                                         \
    (defined(__APPLE__) && TARGET_OS_MAC && !TARGET_OS_IPHONE)
  virtual int updateScreenCaptureParameters(
      agora::rtc::ScreenCaptureParameters const &captureParams) override {
    return 0;
  }
#endif

#if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS)
  virtual int startScreenCapture(
      agora::rtc::ScreenCaptureParameters2 const &captureParams) override {
    return 0;
  }
#endif

#if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS)
  virtual int updateScreenCapture(
      agora::rtc::ScreenCaptureParameters2 const &captureParams) override {
    return 0;
  }
#endif

#if defined(_WIN32) || defined(__APPLE__) || defined(__ANDROID__)
  virtual int stopScreenCapture() override { return 0; }
#endif

  virtual int getCallId(agora::util::AString &callId) override { return 0; }

  virtual int rate(char const *callId, int rating,
                   char const *description) override {
    return 0;
  }

  virtual int complain(char const *callId, char const *description) override {
    return 0;
  }

  virtual int startRtmpStreamWithoutTranscoding(char const *url) override {
    return 0;
  }

  virtual int startRtmpStreamWithTranscoding(
      char const *url,
      agora::rtc::LiveTranscoding const &transcoding) override {
    return 0;
  }

  virtual int updateRtmpTranscoding(
      agora::rtc::LiveTranscoding const &transcoding) override {
    return 0;
  }

  virtual int stopRtmpStream(char const *url) override { return 0; }

  virtual int startLocalVideoTranscoder(
      agora::rtc::LocalTranscoderConfiguration const &config) override {
    return 0;
  }

  virtual int updateLocalTranscoderConfiguration(
      agora::rtc::LocalTranscoderConfiguration const &config) override {
    return 0;
  }

  virtual int stopLocalVideoTranscoder() override { return 0; }

  virtual int startPrimaryCameraCapture(
      agora::rtc::CameraCapturerConfiguration const &config) override {
    return 0;
  }

  virtual int startSecondaryCameraCapture(
      agora::rtc::CameraCapturerConfiguration const &config) override {
    return 0;
  }

  virtual int stopPrimaryCameraCapture() override { return 0; }

  virtual int stopSecondaryCameraCapture() override { return 0; }

  virtual int setCameraDeviceOrientation(
      agora::rtc::VIDEO_SOURCE_TYPE type,
      agora::rtc::VIDEO_ORIENTATION orientation) override {
    return 0;
  }

  virtual int setScreenCaptureOrientation(
      agora::rtc::VIDEO_SOURCE_TYPE type,
      agora::rtc::VIDEO_ORIENTATION orientation) override {
    return 0;
  }

  virtual int startPrimaryScreenCapture(
      agora::rtc::ScreenCaptureConfiguration const &config) override {
    return 0;
  }

  virtual int startSecondaryScreenCapture(
      agora::rtc::ScreenCaptureConfiguration const &config) override {
    return 0;
  }

  virtual int stopPrimaryScreenCapture() override { return 0; }

  virtual int stopSecondaryScreenCapture() override { return 0; }

  virtual agora::rtc::CONNECTION_STATE_TYPE getConnectionState() override {
    return agora::rtc::CONNECTION_STATE_TYPE::CONNECTION_STATE_DISCONNECTED;
  }

  virtual bool registerEventHandler(
      agora::rtc::IRtcEngineEventHandler *eventHandler) override {
    return 0;
  }

  virtual bool unregisterEventHandler(
      agora::rtc::IRtcEngineEventHandler *eventHandler) override {
    return 0;
  }

  virtual int
  setRemoteUserPriority(agora::rtc::uid_t uid,
                        agora::rtc::PRIORITY_TYPE userPriority) override {
    return 0;
  }

  virtual int
  registerPacketObserver(agora::rtc::IPacketObserver *observer) override {
    return 0;
  }

  virtual int setEncryptionMode(char const *encryptionMode) override {
    return 0;
  }

  virtual int setEncryptionSecret(char const *secret) override { return 0; }

  virtual int
  enableEncryption(bool enabled,
                   agora::rtc::EncryptionConfig const &config) override {
    return 0;
  }

  virtual int createDataStream(int *streamId, bool reliable,
                               bool ordered) override {
    return 0;
  }

  virtual int createDataStream(int *streamId,
                               agora::rtc::DataStreamConfig &config) override {
    return 0;
  }

  virtual int sendStreamMessage(int streamId, char const *data,
                                size_t length) override {
    return 0;
  }

  virtual int
  addVideoWatermark(agora::rtc::RtcImage const &watermark) override {
    return 0;
  }

  virtual int
  addVideoWatermark(char const *watermarkUrl,
                    agora::rtc::WatermarkOptions const &options) override {
    return 0;
  }

  virtual int clearVideoWatermarks() override { return 0; }

  virtual int pauseAudio() override { return 0; }

  virtual int resumeAudio() override { return 0; }

  virtual int enableWebSdkInteroperability(bool enabled) override { return 0; }

  virtual int sendCustomReportMessage(char const *id, char const *category,
                                      char const *event, char const *label,
                                      int value) override {
    return 0;
  }

  virtual int registerMediaMetadataObserver(
      agora::rtc::IMetadataObserver *observer,
      IMetadataObserver::METADATA_TYPE type) override {
    return 0;
  }

  virtual int unregisterMediaMetadataObserver(
      agora::rtc::IMetadataObserver *observer,
      IMetadataObserver::METADATA_TYPE type) override {
    return 0;
  }

  virtual int startAudioFrameDump(char const *channel_id,
                                  agora::rtc::uid_t user_id,
                                  char const *location, char const *uuid,
                                  char const *passwd, long duration_ms,
                                  bool auto_upload) override {
    return 0;
  }

  virtual int stopAudioFrameDump(char const *channel_id,
                                 agora::rtc::uid_t user_id,
                                 char const *location) override {
    return 0;
  }

  virtual int registerLocalUserAccount(char const *appId,
                                       char const *userAccount) override {
    return 0;
  }

  virtual int joinChannelWithUserAccount(char const *token,
                                         char const *channelId,
                                         char const *userAccount) override {
    return 0;
  }

  virtual int joinChannelWithUserAccount(
      char const *token, char const *channelId, char const *userAccount,
      agora::rtc::ChannelMediaOptions const &options) override {
    return 0;
  }

  virtual int joinChannelWithUserAccountEx(
      char const *token, char const *channelId, char const *userAccount,
      agora::rtc::ChannelMediaOptions const &options,
      agora::rtc::IRtcEngineEventHandler *eventHandler) override {
    return 0;
  }

  virtual int getUserInfoByUserAccount(char const *userAccount,
                                       rtc::UserInfo *userInfo) override {
    return 0;
  }

  virtual int getUserInfoByUid(agora::rtc::uid_t uid,
                               rtc::UserInfo *userInfo) override {
    return 0;
  }

  virtual int startChannelMediaRelay(
      agora::rtc::ChannelMediaRelayConfiguration const &configuration)
      override {
    return 0;
  }

  virtual int updateChannelMediaRelay(
      agora::rtc::ChannelMediaRelayConfiguration const &configuration)
      override {
    return 0;
  }

  virtual int stopChannelMediaRelay() override { return 0; }

  virtual int pauseAllChannelMediaRelay() override { return 0; }

  virtual int resumeAllChannelMediaRelay() override { return 0; }

  virtual int setDirectCdnStreamingAudioConfiguration(
      agora::rtc::AUDIO_PROFILE_TYPE profile) override {
    return 0;
  }

  virtual int setDirectCdnStreamingVideoConfiguration(
      agora::rtc::VideoEncoderConfiguration const &config) override {
    return 0;
  }

  virtual int startDirectCdnStreaming(
      agora::rtc::IDirectCdnStreamingEventHandler *eventHandler,
      char const *publishUrl,
      agora::rtc::DirectCdnStreamingMediaOptions const &options) override {
    return 0;
  }

  virtual int stopDirectCdnStreaming() override { return 0; }

  virtual int updateDirectCdnStreamingMediaOptions(
      agora::rtc::DirectCdnStreamingMediaOptions const &options) override {
    return 0;
  }

  virtual int startRhythmPlayer(
      char const *sound1, char const *sound2,
      agora::rtc::AgoraRhythmPlayerConfig const &config) override {
    return 0;
  }

  virtual int stopRhythmPlayer() override { return 0; }

  virtual int configRhythmPlayer(
      agora::rtc::AgoraRhythmPlayerConfig const &config) override {
    return 0;
  }

  virtual int takeSnapshot(agora::rtc::uid_t uid,
                           char const *filePath) override {
    return 0;
  }

  virtual int
  enableContentInspect(bool enabled,
                       media::ContentInspectConfig const &config) override {
    return 0;
  }

  virtual int adjustCustomAudioPublishVolume(int32_t sourceId,
                                             int volume) override {
    return 0;
  }

  virtual int adjustCustomAudioPlayoutVolume(int32_t sourceId,
                                             int volume) override {
    return 0;
  }

  virtual int setCloudProxy(agora::rtc::CLOUD_PROXY_TYPE proxyType) override {
    return 0;
  }

  virtual int setLocalAccessPoint(
      agora::rtc::LocalAccessPointConfiguration const &config) override {
    return 0;
  }

  virtual int setAdvancedAudioOptions(agora::rtc::AdvancedAudioOptions &options,
                                      int sourceType) override {
    return 0;
  }

  virtual int setAVSyncSource(char const *channelId,
                              agora::rtc::uid_t uid) override {
    return 0;
  }

  virtual int enableVideoImageSource(
      bool enable, agora::rtc::ImageTrackOptions const &options) override {
    return 0;
  }

  virtual int64_t getCurrentMonotonicTimeInMs() override {
    int64_t the_return;
    return the_return;
  }

  virtual int enableWirelessAccelerate(bool enabled) override { return 0; }

  virtual int getNetworkType() override { return 0; }

  virtual int
  joinChannelEx(char const *token, agora::rtc::RtcConnection const &connection,
                agora::rtc::ChannelMediaOptions const &options,
                agora::rtc::IRtcEngineEventHandler *eventHandler) override {
    return 0;
  }

  virtual int
  leaveChannelEx(agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int
  leaveChannelEx(agora::rtc::RtcConnection const &connection,
                 agora::rtc::LeaveChannelOptions const &options) override {
    return 0;
  }

  virtual int updateChannelMediaOptionsEx(
      agora::rtc::ChannelMediaOptions const &options,
      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int setVideoEncoderConfigurationEx(
      agora::rtc::VideoEncoderConfiguration const &config,
      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int
  setupRemoteVideoEx(agora::rtc::VideoCanvas const &canvas,
                     agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int muteRemoteAudioStreamEx(
      agora::rtc::uid_t uid, bool mute,
      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int muteRemoteVideoStreamEx(
      agora::rtc::uid_t uid, bool mute,
      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int setRemoteVideoStreamTypeEx(
      agora::rtc::uid_t uid, agora::rtc::VIDEO_STREAM_TYPE streamType,
      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int
  muteLocalAudioStreamEx(bool mute,
                         agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int
  muteLocalVideoStreamEx(bool mute,
                         agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int muteAllRemoteAudioStreamsEx(
      bool mute, agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int muteAllRemoteVideoStreamsEx(
      bool mute, agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int setSubscribeAudioBlocklistEx(
      agora::rtc::uid_t *uidList, int uidNumber,
      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int setSubscribeAudioAllowlistEx(
      agora::rtc::uid_t *uidList, int uidNumber,
      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int setSubscribeVideoBlocklistEx(
      agora::rtc::uid_t *uidList, int uidNumber,
      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int setSubscribeVideoAllowlistEx(
      agora::rtc::uid_t *uidList, int uidNumber,
      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int setRemoteVideoSubscriptionOptionsEx(
      agora::rtc::uid_t uid,
      agora::rtc::VideoSubscriptionOptions const &options,
      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int setRemoteVoicePositionEx(
      agora::rtc::uid_t uid, double pan, double gain,
      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int setRemoteUserSpatialAudioParamsEx(
      agora::rtc::uid_t uid, agora::SpatialAudioParams const &params,
      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int
  setRemoteRenderModeEx(agora::rtc::uid_t uid,
                        media::base::RENDER_MODE_TYPE renderMode,
                        agora::rtc::VIDEO_MIRROR_MODE_TYPE mirrorMode,
                        agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int
  enableLoopbackRecordingEx(agora::rtc::RtcConnection const &connection,
                            bool enabled, char const *deviceName) override {
    return 0;
  }

  virtual int adjustUserPlaybackSignalVolumeEx(
      unsigned int uid, int volume,
      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual agora::rtc::CONNECTION_STATE_TYPE
  getConnectionStateEx(agora::rtc::RtcConnection const &connection) override {
    return agora::rtc::CONNECTION_STATE_TYPE::CONNECTION_STATE_DISCONNECTED;
  }

  virtual int
  enableEncryptionEx(agora::rtc::RtcConnection const &connection, bool enabled,
                     agora::rtc::EncryptionConfig const &config) override {
    return 0;
  }

  virtual int
  createDataStreamEx(int *streamId, bool reliable, bool ordered,
                     agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int
  createDataStreamEx(int *streamId, agora::rtc::DataStreamConfig &config,
                     agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int
  sendStreamMessageEx(int streamId, char const *data, size_t length,
                      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int
  addVideoWatermarkEx(char const *watermarkUrl,
                      agora::rtc::WatermarkOptions const &options,
                      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int
  clearVideoWatermarkEx(agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int sendCustomReportMessageEx(
      char const *id, char const *category, char const *event,
      char const *label, int value,
      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int enableAudioVolumeIndicationEx(
      int interval, int smooth, bool reportVad,
      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int startRtmpStreamWithoutTranscodingEx(
      char const *url, agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int startRtmpStreamWithTranscodingEx(
      char const *url, agora::rtc::LiveTranscoding const &transcoding,
      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int updateRtmpTranscodingEx(
      agora::rtc::LiveTranscoding const &transcoding,
      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int
  stopRtmpStreamEx(char const *url,
                   agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int startChannelMediaRelayEx(
      agora::rtc::ChannelMediaRelayConfiguration const &configuration,
      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int updateChannelMediaRelayEx(
      agora::rtc::ChannelMediaRelayConfiguration const &configuration,
      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int stopChannelMediaRelayEx(
      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int pauseAllChannelMediaRelayEx(
      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int resumeAllChannelMediaRelayEx(
      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int getUserInfoByUserAccountEx(
      char const *userAccount, rtc::UserInfo *userInfo,
      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int
  getUserInfoByUidEx(agora::rtc::uid_t uid, rtc::UserInfo *userInfo,
                     agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int setVideoProfileEx(int width, int height, int frameRate,
                                int bitrate) override {
    return 0;
  }

  virtual int
  enableDualStreamModeEx(bool enabled,
                         agora::rtc::SimulcastStreamConfig const &streamConfig,
                         agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int
  setDualStreamModeEx(agora::rtc::SIMULCAST_STREAM_MODE mode,
                      agora::rtc::SimulcastStreamConfig const &streamConfig,
                      agora::rtc::RtcConnection const &connection) override {
    return 0;
  }

  virtual int takeSnapshotEx(agora::rtc::RtcConnection const &connection,
                             agora::rtc::uid_t uid,
                             char const *filePath) override {
    return 0;
  }
};

} // namespace rtc
} // namespace agora

#endif // FAKE_IRTCENGINEEX_INTERNAL_H_
