IAgoraService.h

//  Agora SDK
//
//  Copyright (c) 2018 Agora.io. All rights reserved.
//
 
#pragma once  // NOLINT(build/header_guard)
 
#include "IAgoraLog.h"
#include "AgoraBase.h"
#include "AgoraOptional.h"
#include <api/cpp/aosl_ares_class.h>
 
namespace agora {
class ILocalDataChannel;
class IRemoteDataChannel;
struct DataChannelConfig;
 
namespace rtc {
class IRtcConnection;
class IRtmpConnection;
class ILocalUser;
class IMediaDeviceManager;
class INGAudioDeviceManager;
class INGVideoDeviceManager;
struct TConnectionInfo;
struct RtcConnectionConfiguration;
struct RtmpConnectionConfiguration;
class ILocalAudioTrack;
class IMediaPlayerSource;
class IMediaStreamingSource;
class ICameraCapturer;
class IScreenCapturer;
class IScreenCapturer2;
class IAudioPcmDataSender;
class IAudioEncodedFrameSender;
class IVideoFrameSender;
class IVideoEncodedImageSender;
class IVideoSourceNode;
class IVideoMixerSource;
class IVideoFrameTransceiver;
class ILocalVideoTrack;
class IMediaNodeFactory;
class IRecordingDeviceSource;
class IRemoteAudioMixerSource;
class IRtmpStreamingService;
class IMediaPacketSender;
class IMediaRelayService;
class IAudioDeviceManager;
class IAudioDeviceManagerObserver;
 
class IMediaExtensionObserver;
class IExtensionProvider;
class IFileUploaderService;
class IConfigCenter;
struct AudioEncoderConfiguration {
  AUDIO_PROFILE_TYPE audioProfile;
 
  AudioEncoderConfiguration() : audioProfile(AUDIO_PROFILE_DEFAULT) {}
};
 
}  // namespace rtc
 
namespace rtm {
class IRtmService;
}
 
namespace base {
class IServiceObserver;
 
struct AgoraServiceConfiguration {
  bool enableAudioProcessor;
  bool enableAudioDevice;
  bool enableVideo;
  void* context;
  const char* appId;
 
  unsigned int areaCode;
 
  agora::CHANNEL_PROFILE_TYPE channelProfile;
 
  const char* license;
 
  rtc::AUDIO_SCENARIO_TYPE audioScenario;
  commons::LogConfig logConfig;
  bool useStringUid;
  IServiceObserver* serviceObserver;
 
  Optional<rtc::THREAD_PRIORITY_TYPE> threadPriority __deprecated;
  bool useExternalEglContext;
 
  bool domainLimit;
 
  AgoraServiceConfiguration() : enableAudioProcessor(true),
                                enableAudioDevice(true),
                                enableVideo(false),
                                context(NULL),
                                appId(NULL),
                                areaCode(rtc::AREA_CODE_GLOB),
                                channelProfile(agora::CHANNEL_PROFILE_LIVE_BROADCASTING),
                                license(NULL),
                                audioScenario(rtc::AUDIO_SCENARIO_DEFAULT),
                                useStringUid(false),
                                serviceObserver(NULL),
                                useExternalEglContext(false),
                                domainLimit(false){}
};
struct AudioSessionConfiguration {
  Optional<bool> playbackAndRecord;
  Optional<bool> chatMode;
  Optional<bool> defaultToSpeaker;
  Optional<bool> overrideSpeaker;
  Optional<bool> allowMixWithOthers;
  Optional<bool> allowDuckOthers;
  Optional<bool> allowBluetooth;
  Optional<bool> allowBluetoothA2DP;
  Optional<double> sampleRate;
  Optional<double> ioBufferDuration;
  Optional<int> inputNumberOfChannels;
  Optional<int> outputNumberOfChannels;
 
#if defined(WEBRTC_IOS)
 
  Optional<int> category;
#endif
 
  void SetAll(const AudioSessionConfiguration& change) {
    SetFrom(&playbackAndRecord, change.playbackAndRecord);
    SetFrom(&chatMode, change.chatMode);
    SetFrom(&defaultToSpeaker, change.defaultToSpeaker);
    SetFrom(&overrideSpeaker, change.overrideSpeaker);
    SetFrom(&allowMixWithOthers, change.allowMixWithOthers);
    SetFrom(&allowDuckOthers, change.allowDuckOthers);
    SetFrom(&allowBluetooth, change.allowBluetooth);
    SetFrom(&allowBluetoothA2DP, change.allowBluetoothA2DP);
    SetFrom(&sampleRate, change.sampleRate);
    SetFrom(&ioBufferDuration, change.ioBufferDuration);
    SetFrom(&inputNumberOfChannels, change.inputNumberOfChannels);
    SetFrom(&outputNumberOfChannels, change.outputNumberOfChannels);
#if defined(WEBRTC_IOS)
    SetFrom(&category, change.category);
#endif
  }
 
  bool operator==(const AudioSessionConfiguration& o) const {
    return playbackAndRecord == o.playbackAndRecord && chatMode == o.chatMode &&
           defaultToSpeaker == o.defaultToSpeaker && overrideSpeaker == o.overrideSpeaker &&
           allowMixWithOthers == o.allowMixWithOthers && allowDuckOthers == o.allowDuckOthers &&
           allowBluetooth == o.allowBluetooth && allowBluetoothA2DP == o.allowBluetoothA2DP && sampleRate == o.sampleRate &&
           ioBufferDuration == o.ioBufferDuration &&
           inputNumberOfChannels == o.inputNumberOfChannels &&
#if defined(WEBRTC_IOS)
           outputNumberOfChannels == o.outputNumberOfChannels &&
           category == o.category;
#else
           outputNumberOfChannels == o.outputNumberOfChannels;
#endif
  }
  bool operator!=(const AudioSessionConfiguration& o) const { return !(*this == o); }
 
 private:
  template <typename T>
  static void SetFrom(Optional<T>* s, const Optional<T>& o) {
    if (o) {
      *s = o;
    }
  }
};
enum TMixMode {
  MIX_ENABLED,
  MIX_DISABLED,
};
 
class IServiceObserver {
public:
  virtual ~IServiceObserver() {}
 
  virtual void onPermissionError(agora::rtc::PERMISSION_TYPE permissionType) {}
  virtual void onAudioDeviceError(ERROR_CODE_TYPE error, const char* description) {}
  virtual void onFetchConfigResult(int code, rtc::CONFIG_FETCH_TYPE configType, const char* configContent) {}
 
#if defined(__ANDROID__)
 
  virtual void onPermissionGranted(agora::rtc::PERMISSION_TYPE permissionType) {}
#endif
 
  virtual void onLocalUserRegistered(rtc::uid_t uid, const char* userAccount) {}
 
};
 
class IAgoraService {
 public:
  virtual int initialize(const AgoraServiceConfiguration& config) = 0;
 
  virtual int atExit(aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual int release() = 0;
 
  virtual int setAudioSessionPreset(agora::rtc::AUDIO_SCENARIO_TYPE scenario, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual int setAudioSessionConfiguration(const AudioSessionConfiguration& config, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual int getAudioSessionConfiguration(AudioSessionConfiguration* config) = 0;
 
  virtual int setLogFile(const char* filePath, unsigned int fileSize, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
  virtual int setLogFilter(unsigned int filters, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual agora_refptr<rtc::IRtcConnection> createRtcConnection(
      const rtc::RtcConnectionConfiguration& cfg) = 0;
 
  virtual agora_refptr<rtc::IRtmpConnection> createRtmpConnection(
      const rtc::RtmpConnectionConfiguration& cfg) = 0;
 
  virtual agora_refptr<rtc::ILocalAudioTrack> createLocalAudioTrack() = 0;
 
  virtual agora_refptr<rtc::ILocalAudioTrack> createLocalMixedAudioTrack() = 0;
 
  virtual agora_refptr<rtc::ILocalAudioTrack> createCustomAudioTrack(
      agora_refptr<rtc::IAudioPcmDataSender> audioSource) = 0;
 
  virtual agora_refptr<rtc::ILocalAudioTrack> createDirectCustomAudioTrack(
      agora_refptr<rtc::IAudioPcmDataSender> audioSource) = 0;
 
  virtual agora_refptr<rtc::ILocalAudioTrack> createCustomAudioTrack(
      agora_refptr<rtc::IAudioPcmDataSender> audioSource, bool enableAec) = 0;
 
  virtual agora_refptr<rtc::ILocalAudioTrack> createCustomAudioTrack(
      agora_refptr<rtc::IRemoteAudioMixerSource> audioSource) = 0;
 
  virtual agora_refptr<rtc::ILocalAudioTrack> createCustomAudioTrack(
      agora_refptr<rtc::IAudioEncodedFrameSender> audioSource, TMixMode mixMode) = 0;
 
  virtual agora_refptr<rtc::ILocalAudioTrack> createCustomAudioTrack(
      agora_refptr<rtc::IMediaPacketSender> source) = 0;
 
  virtual agora_refptr<rtc::ILocalAudioTrack> createMediaPlayerAudioTrack(
      agora_refptr<rtc::IMediaPlayerSource> audioSource) = 0;
 
  virtual agora_refptr<rtc::ILocalAudioTrack> createMediaStreamingAudioTrack(
      agora_refptr<rtc::IMediaStreamingSource> streamingSource) = 0;
 
  virtual agora_refptr<rtc::ILocalAudioTrack> createRecordingDeviceAudioTrack(
      agora_refptr<rtc::IRecordingDeviceSource> audioSource, bool enableAec, bool overlap) = 0;
 
  virtual agora_refptr<rtc::INGAudioDeviceManager> createAudioDeviceManager() = 0;
 
 
  virtual agora_refptr<rtc::INGVideoDeviceManager> createVideoDeviceManager() = 0;
 
  virtual agora_refptr<rtc::IMediaNodeFactory> createMediaNodeFactory() = 0;
 
  virtual agora_refptr<rtc::ILocalVideoTrack> createCameraVideoTrack(
      agora_refptr<rtc::ICameraCapturer> videoSource, const char* id = OPTIONAL_NULLPTR) = 0;
 
  virtual agora_refptr<rtc::ILocalVideoTrack> createMixedVideoTrack(agora_refptr<rtc::IVideoMixerSource> videoSource,
                                                                    const char* id = OPTIONAL_NULLPTR) = 0;
 
  virtual agora_refptr<rtc::ILocalVideoTrack> createTranscodedVideoTrack(agora_refptr<rtc::IVideoFrameTransceiver> transceiver,
                                                                         const char* id = OPTIONAL_NULLPTR) = 0;
 
 
  virtual agora_refptr<rtc::ILocalVideoTrack> createCustomVideoTrack(
      agora_refptr<rtc::IVideoFrameSender> videoSource, const char* id = OPTIONAL_NULLPTR) = 0;
 
  virtual agora_refptr<rtc::ILocalVideoTrack> createCustomVideoTrack(
      agora_refptr<rtc::IVideoEncodedImageSender> videoSource,
      const rtc::SenderOptions& options,
      const char* id = OPTIONAL_NULLPTR) = 0;
 
#if defined(__ANDROID__) || (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE)
 
  virtual agora_refptr<rtc::ILocalVideoTrack> createScreenCaptureVideoTrack(
      agora_refptr<rtc::IScreenCapturer2> screen) = 0;
 
  virtual agora_refptr<rtc::ILocalAudioTrack> createScreenCaptureAudioTrack(
    agora_refptr<rtc::IScreenCapturer2> screen) = 0;
#else
 
  virtual agora_refptr<rtc::ILocalVideoTrack> createScreenCaptureVideoTrack(
      agora_refptr<rtc::IScreenCapturer> screen, const char* id = OPTIONAL_NULLPTR) = 0;
#endif
 
 
  virtual agora_refptr<rtc::ILocalVideoTrack> createCustomVideoTrack(
      agora_refptr<rtc::IMediaPacketSender> source, const char* id = OPTIONAL_NULLPTR) = 0;
 
  virtual agora_refptr<rtc::ILocalVideoTrack> createMediaPlayerVideoTrack(
      agora_refptr<rtc::IMediaPlayerSource> videoSource, const char* id = OPTIONAL_NULLPTR) = 0;
 
  virtual agora_refptr<rtc::ILocalVideoTrack> createMediaStreamingVideoTrack(
      agora_refptr<rtc::IMediaStreamingSource> streamingSource, const char* id = OPTIONAL_NULLPTR) = 0;
 
 
  virtual agora_refptr<rtc::IRtmpStreamingService> createRtmpStreamingService(
      agora_refptr<rtc::IRtcConnection> rtcConnection, const char* appId) = 0;
 
  virtual agora_refptr<rtc::IMediaRelayService> createMediaRelayService(
      agora_refptr<rtc::IRtcConnection> rtcConnection, const char* appId) = 0;
 
  virtual agora_refptr<rtc::IFileUploaderService> createFileUploadService(
      agora_refptr<rtc::IRtcConnection> rtcConnection, const char* appId) = 0;
 
  virtual rtm::IRtmService* createRtmService() = 0;
 
  virtual int addExtensionObserver(agora::agora_refptr<agora::rtc::IMediaExtensionObserver> observer, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual int removeExtensionObserver(agora::agora_refptr<agora::rtc::IMediaExtensionObserver> observer, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual agora_refptr<rtc::IAudioDeviceManager> createAudioDeviceManagerComponent(
      rtc::IAudioDeviceManagerObserver *observer) = 0;
 
  virtual agora_refptr<ILocalDataChannel> createLocalDataChannel(const DataChannelConfig& config) = 0;
 
  virtual const char* getExtensionId(const char* provider_name, const char* extension_name) = 0;
 
#if defined (_WIN32) || defined(__linux__) || defined(__ANDROID__)
 
  virtual int loadExtensionProvider(const char* path, bool unload_after_use = false) = 0;
#endif
 
  virtual int enableExtension(
      const char* provider_name, const char* extension_name, const char* track_id = NULL,
      bool auto_enable_on_track = false, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
  virtual int disableExtension(
      const char* provider_name, const char* extension_name, const char* track_id = NULL, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual agora_refptr<base::IAgoraParameter> getAgoraParameter() = 0;
 
  virtual agora_refptr<rtc::IConfigCenter> getConfigCenter() = 0;
 
  virtual int32_t setLogWriter(agora::commons::ILogWriter* logWriter) = 0;
  virtual agora::commons::ILogWriter* releaseLogWriter() = 0;
      
 protected:
  virtual ~IAgoraService() {}
};
 
}  // namespace base
}  // namespace agora
 
AGORA_API agora::base::IAgoraService* AGORA_CALL createAgoraService();