NGIAgoraRtcConnection.h

Go to the documentation of this file.

//
//  Agora SDK
//
//  Created by Sting Feng in 2018-01.
//  Copyright (c) 2018 Agora.io. All rights reserved.
//
 
#pragma once  // NOLINT(build/header_guard)
 
#include "AgoraBase.h"
 
namespace agora {
namespace rtc {
class IAudioEncodedFrameSender;
class IRtcConnectionObserver;
class INetworkObserver;
class IRtcConnection;
class IVideoEncodedImageSender;
class ILocalUser;
 
struct TConnectionInfo {
  conn_id_t id;
  util::AString channelId;
  CONNECTION_STATE_TYPE state;
  util::AString localUserId;
 
  uid_t internalUid;
  TConnectionInfo() : id(-1), state(CONNECTION_STATE_DISCONNECTED), internalUid(0) {}
};
 
struct AudioSubscriptionOptions {
  AudioSubscriptionOptions() :
    packetOnly(false),
    bytesPerSample(TWO_BYTES_PER_SAMPLE),
    numberOfChannels(0),
    sampleRateHz(0) {
  }
 
  AudioSubscriptionOptions(const AudioSubscriptionOptions &rhs) :
      packetOnly(rhs.packetOnly),
      bytesPerSample(rhs.bytesPerSample),
      numberOfChannels(rhs.numberOfChannels),
      sampleRateHz(rhs.sampleRateHz) {
  }
 
  AudioSubscriptionOptions& operator=(const AudioSubscriptionOptions& rhs)
  {
    if (this == &rhs) {
      return *this;
    }
 
    packetOnly = rhs.packetOnly;
    bytesPerSample = rhs.bytesPerSample;
    numberOfChannels = rhs.numberOfChannels;
    sampleRateHz = rhs.sampleRateHz;
    return *this;
  }
  bool packetOnly;
  size_t bytesPerSample;
  size_t numberOfChannels;
  uint32_t sampleRateHz;
};
 
struct RtcConnectionConfiguration {
  bool autoSubscribeAudio;
  bool autoSubscribeVideo;
  bool enableAudioRecordingOrPlayout;
  int maxSendBitrate;
  int minPort;
  int maxPort;
  AudioSubscriptionOptions audioSubscriptionOptions;
  CLIENT_ROLE_TYPE clientRoleType;
  CHANNEL_PROFILE_TYPE  channelProfile;
 
  bool audioRecvMediaPacket;
 
  bool videoRecvMediaPacket;
 
  RtcConnectionConfiguration()
      : autoSubscribeAudio(true),
        autoSubscribeVideo(true),
        enableAudioRecordingOrPlayout(true),
        maxSendBitrate(-1),
        minPort(0),
        maxPort(0),
        clientRoleType(CLIENT_ROLE_AUDIENCE),
        channelProfile(CHANNEL_PROFILE_LIVE_BROADCASTING),
        audioRecvMediaPacket(false),
        videoRecvMediaPacket(false) {}
};
 
class IRtcConnection : public RefCountInterface {
 protected:
  ~IRtcConnection() {}
 
 public:
  virtual int connect(const char* token, const char* channelId, user_id_t userId) = 0;
 
  virtual int disconnect() = 0;
 
  virtual int startLastmileProbeTest(const LastmileProbeConfig& config) = 0;
 
  virtual int stopLastmileProbeTest() = 0;
 
  virtual int renewToken(const char* token) = 0;
 
  virtual TConnectionInfo getConnectionInfo() = 0;
 
  virtual ILocalUser* getLocalUser() = 0;
 
  virtual int getRemoteUsers(UserList& users) = 0;
 
  virtual int getUserInfo(user_id_t userId, agora::UserInfo& userInfo) = 0;
 
  virtual int registerObserver(IRtcConnectionObserver* observer, void(*safeDeleter)(IRtcConnectionObserver*) = NULL) = 0;
 
  virtual int unregisterObserver(IRtcConnectionObserver* observer) = 0;
 
  virtual int registerNetworkObserver(INetworkObserver* observer, void(*safeDeleter)(INetworkObserver*) = NULL) = 0;
 
  virtual int unregisterNetworkObserver(INetworkObserver* observer) = 0;
 
  virtual conn_id_t getConnId() = 0;
 
  virtual RtcStats getTransportStats() = 0;
 
  virtual agora::base::IAgoraParameter* getAgoraParameter() = 0;
 
  virtual int enableEncryption(bool enabled, const EncryptionConfig& config) = 0;
 
  virtual int getUserInfoByUserAccount(const char* userAccount, rtc::UserInfo* userInfo) = 0;
  virtual int getUserInfoByUid(uid_t uid, rtc::UserInfo* userInfo) = 0;
};
 
class IRtcConnectionObserver {
 public:
  virtual ~IRtcConnectionObserver() {}
 
  virtual void onConnected(const TConnectionInfo& connectionInfo, CONNECTION_CHANGED_REASON_TYPE reason) = 0;
 
  virtual void onDisconnected(const TConnectionInfo& connectionInfo, CONNECTION_CHANGED_REASON_TYPE reason) = 0;
 
  virtual void onConnecting(const TConnectionInfo& connectionInfo, CONNECTION_CHANGED_REASON_TYPE reason) = 0;
 
  virtual void onReconnecting(const TConnectionInfo& connectionInfo, CONNECTION_CHANGED_REASON_TYPE reason) = 0;
 
  // This should be deleted. onConnected is enough.
  virtual void onReconnected(const TConnectionInfo& connectionInfo, CONNECTION_CHANGED_REASON_TYPE reason) = 0;
 
  virtual void onConnectionLost(const TConnectionInfo& connectionInfo) = 0;
 
  virtual void onLastmileQuality(const QUALITY_TYPE quality) = 0;
 
  virtual void onLastmileProbeResult(const LastmileProbeResult& result) = 0;
 
  virtual void onTokenPrivilegeWillExpire(const char* token) = 0;
 
  virtual void onTokenPrivilegeDidExpire() = 0;
 
  virtual void onConnectionFailure(const TConnectionInfo& connectionInfo,
                                   CONNECTION_CHANGED_REASON_TYPE reason) = 0;
 
  virtual void onUserJoined(user_id_t userId) = 0;
 
  virtual void onUserLeft(user_id_t userId, USER_OFFLINE_REASON_TYPE reason) = 0;
 
  virtual void onTransportStats(const RtcStats& stats) = 0;
 
  virtual void onChangeRoleSuccess(CLIENT_ROLE_TYPE oldRole, CLIENT_ROLE_TYPE newRole) {
    (void)oldRole;
    (void)newRole;
  }
 
  virtual void onChangeRoleFailure() {}
 
  virtual void onUserNetworkQuality(user_id_t userId, QUALITY_TYPE txQuality,
                                    QUALITY_TYPE rxQuality) {
    (void)userId;
    (void)txQuality;
    (void)rxQuality;
  }
 
  virtual void onNetworkTypeChanged(NETWORK_TYPE type) {
    (void)type;
  }
 
  virtual void onApiCallExecuted(int err, const char* api, const char* result) {
    (void)err;
    (void)api;
    (void)result;
  }
 
  virtual void onContentInspectResult(media::CONTENT_INSPECT_RESULT result) { (void)result; }
  virtual void onSnapshotTaken(const char* channel, uid_t uid, const char* filePath, int width, int height, int errCode) {
    (void)channel;
    (void)uid;
    (void)filePath;
    (void)width;
    (void)height;
    (void)errCode;
  }
  virtual void onError(ERROR_CODE_TYPE error, const char* msg) {
    (void)error;
    (void)msg;
  }
 
  virtual void onWarning(WARN_CODE_TYPE warning, const char* msg) {
    (void)warning;
    (void)msg;
  }
 
  virtual void onChannelMediaRelayStateChanged(int state, int code) = 0;
 
  virtual void onLocalUserRegistered(uid_t uid, const char* userAccount) {
    (void)uid;
    (void)userAccount;
  }
 
  virtual void onUserAccountUpdated(uid_t uid, const char* userAccount){
    (void)uid;
    (void)userAccount;
  }
 
  virtual void onStreamMessageError(user_id_t userId, int streamId, int code, int missed,
                                    int cached) {
    (void)userId;
    (void)streamId;
    (void)code;
    (void)missed;
    (void)cached;
  }
 
  virtual void onEncryptionError(ENCRYPTION_ERROR_TYPE errorType) {
    (void)errorType;
  }
 
  virtual void onUploadLogResult(const char* requestId, bool success, UPLOAD_ERROR_REASON reason) {
    (void)requestId;
    (void)success;
    (void)reason;
  }
};
 
class INetworkObserver {
 public:
  virtual ~INetworkObserver() {}
 
 public:
  virtual void onUplinkNetworkInfoUpdated(const UplinkNetworkInfo& info) {
    (void)info;
  }
 
  virtual void onDownlinkNetworkInfoUpdated(const DownlinkNetworkInfo& info) {
    (void)info;
  }
};
 
}  // namespace rtc
}  // namespace agora