IAgoraService.h

Go to the documentation of this file.

//  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"
 
namespace agora {
namespace rtc {
class IRtcConnection;
class IRtmpConnection;
class ILocalUser;
struct TConnectionInfo;
struct RtcConnectionConfiguration;
struct RtmpConnectionConfiguration;
class ILocalAudioTrack;
class IAudioPcmDataSender;
class IAudioEncodedFrameSender;
class IVideoFrameSender;
class IVideoEncodedImageSender;
class IVideoSourceNode;
class IVideoMixerSource;
class ILocalVideoTrack;
class IMediaNodeFactory;
 
struct AudioEncoderConfiguration {
  AUDIO_PROFILE_TYPE audioProfile;
  // absl::optional<DtxStatus> dtx;
  // double bitrate_priority = 1.0;
  // absl::optional<int> ptime;
  // FEC parameters
  // Rtx parameters
 
  AudioEncoderConfiguration() : audioProfile(AUDIO_PROFILE_DEFAULT) {}
};
 
}  // namespace rtc
 
namespace signaling {
class ISignalingEngine;
}
 
namespace base {
class IEngineBase;
class IServiceObserver;
 
struct AgoraServiceConfiguration {
  bool enableAudioProcessor;
  bool enableAudioDevice;
  bool enableVideo;
 
  void* context;
 
  const char* appId;
 
  unsigned int areaCode;
 
  agora::CHANNEL_PROFILE_TYPE channelProfile;
  rtc::AUDIO_SCENARIO_TYPE audioScenario;
  commons::LogConfig logConfig;
  bool useStringUid;
 
  IServiceObserver* serviceObserver;
 
  Optional<rtc::THREAD_PRIORITY_TYPE> threadPriority;
  bool useExternalEglContext;
 
  bool domainLimit;
 
  const char* configDir;
  const char* dataDir;
  const char* parameters;
 
  AgoraServiceConfiguration() : enableAudioProcessor(true),
                                enableAudioDevice(true),
                                enableVideo(false),
                                context(NULL),
                                appId(NULL),
                                areaCode(rtc::AREA_CODE_GLOB),
                                channelProfile(agora::CHANNEL_PROFILE_LIVE_BROADCASTING),
                                audioScenario(rtc::AUDIO_SCENARIO_DEFAULT),
                                useStringUid(false),
                                serviceObserver(NULL),
                                useExternalEglContext(false),
                                domainLimit(false),
                                configDir(NULL),
                                dataDir(NULL),
                                parameters(NULL){}
};
 
struct AudioSessionConfiguration {
  Optional<bool> playbackAndRecord;
  Optional<bool> chatMode;
  Optional<bool> defaultToSpeaker;
  Optional<bool> overrideSpeaker;
  Optional<bool> allowMixWithOthers;
  Optional<bool> allowBluetooth;
  Optional<bool> allowBluetoothA2DP;
  Optional<double> sampleRate;
  Optional<double> ioBufferDuration;
  Optional<int> inputNumberOfChannels;
  Optional<int> outputNumberOfChannels;
 
  void SetAll(AudioSessionConfiguration& change) {
    SetFrom(&playbackAndRecord, change.playbackAndRecord);
    SetFrom(&chatMode, change.chatMode);
    SetFrom(&defaultToSpeaker, change.defaultToSpeaker);
    SetFrom(&overrideSpeaker, change.overrideSpeaker);
    SetFrom(&allowMixWithOthers, change.allowMixWithOthers);
    SetFrom(&allowBluetooth, change.allowBluetooth);
    SetFrom(&allowBluetoothA2DP, change.allowBluetoothA2DP);
    SetFrom(&sampleRate, change.sampleRate);
    SetFrom(&ioBufferDuration, change.ioBufferDuration);
    SetFrom(&inputNumberOfChannels, change.inputNumberOfChannels);
    SetFrom(&outputNumberOfChannels, change.outputNumberOfChannels);
  }
 
  bool operator==(const AudioSessionConfiguration& o) const {
    return playbackAndRecord == o.playbackAndRecord && chatMode == o.chatMode &&
           defaultToSpeaker == o.defaultToSpeaker && overrideSpeaker == o.overrideSpeaker &&
           allowMixWithOthers == o.allowMixWithOthers && allowBluetooth == o.allowBluetooth &&
           allowBluetoothA2DP == o.allowBluetoothA2DP && sampleRate == o.sampleRate &&
           ioBufferDuration == o.ioBufferDuration &&
           inputNumberOfChannels == o.inputNumberOfChannels &&
           outputNumberOfChannels == o.outputNumberOfChannels;
  }
  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,
};
 
struct SenderOptions {
  rtc::TCcMode ccMode;
  rtc::VIDEO_CODEC_TYPE codecType;
 
  int targetBitrate;
 
  SenderOptions()
  : ccMode(rtc::CC_ENABLED),
    codecType(rtc::VIDEO_CODEC_H264),
    targetBitrate(6500) {}
};
 
class IServiceObserver {
public:
  virtual ~IServiceObserver() {}
 
  virtual void onPermissionError(agora::rtc::PERMISSION_TYPE permissionType) {}
  virtual void onAudioDeviceError(ERROR_CODE_TYPE error, const char* description) {}
};
 
class IAgoraService {
 public:
  virtual int initialize(const AgoraServiceConfiguration& config) = 0;
 
 
  virtual void 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> 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::IAudioEncodedFrameSender> audioSource, TMixMode mixMode, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual agora_refptr<rtc::IMediaNodeFactory> createMediaNodeFactory() = 0;
 
  virtual agora_refptr<rtc::ILocalVideoTrack> createMixedVideoTrack(agora_refptr<rtc::IVideoMixerSource> videoSource,
                                                                    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;
  virtual agora_refptr<base::IAgoraParameter> getAgoraParameter() = 0;
 
  virtual uint64_t getNtpWallTimeInMs() = 0;
 
 protected:
  virtual ~IAgoraService() {}
};
 
}  // namespace base
}  // namespace agora
 
AGORA_API agora::base::IAgoraService* AGORA_CALL createAgoraService();