NGIAgoraRtcConnection.h

//
//  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"
#include "time_utils.h"
#include <api/cpp/aosl_ares_class.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;
 
  int proxyType;
 
  util::AString connectionIp;
 
  TConnectionInfo() : id(-1), state(CONNECTION_STATE_DISCONNECTED), internalUid(0), proxyType(0) {}
};
 
struct TConnectSettings {
  const char* token;
  const char* channelId;
  user_id_t userId;
  /*Reserved for future use*/
  const char* info;
  /*
  App can provide a app defined start time to trace some events like connect cost , first video, etc.
  */
  agora::Optional<int64_t> appDefinedStartTimeMs;
};
 
struct RtcConnectionConfiguration {
  bool autoSubscribeAudio;
  bool autoSubscribeVideo;
  bool enableAudioRecordingOrPlayout;
  int maxSendBitrate;
  int minPort;
  int maxPort;
  CLIENT_ROLE_TYPE clientRoleType;
  CHANNEL_PROFILE_TYPE  channelProfile;
 
  bool audioRecvEncodedFrame;
 
  bool audioRecvMediaPacket;
 
  bool videoRecvMediaPacket;
 
  bool isInteractiveAudience;
 
  bool isDataChannelOnly;
 
  CHANNEL_TYPE channelType;
 
  RtcConnectionConfiguration()
      : autoSubscribeAudio(true),
        autoSubscribeVideo(true),
        enableAudioRecordingOrPlayout(true),
        maxSendBitrate(-1),
        minPort(0),
        maxPort(0),
        clientRoleType(CLIENT_ROLE_AUDIENCE),
        channelProfile(CHANNEL_PROFILE_LIVE_BROADCASTING),
        audioRecvEncodedFrame(false),
        audioRecvMediaPacket(false),
        videoRecvMediaPacket(false),
        isInteractiveAudience(false),
        isDataChannelOnly(false),
        channelType(CHANNEL_TYPE_STANDARD) {}
};
 
class IRtcConnection : public RefCountInterface {
 protected:
  ~IRtcConnection() {}
 
 public:
  virtual int connect(const char* token, const char* channelId,  const char* info, user_id_t userId, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual int connect(const TConnectSettings& settings, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual int disconnect(aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual int startLastmileProbeTest(const LastmileProbeConfig& config, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual int stopLastmileProbeTest(aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual int renewToken(const char* token, aosl_ref_t ares = AOSL_REF_INVALID) = 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, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual int unregisterObserver(IRtcConnectionObserver* observer) = 0;
 
  virtual int registerNetworkObserver(INetworkObserver* observer, void(*safeDeleter)(INetworkObserver*) = NULL, aosl_ref_t ares = AOSL_REF_INVALID) = 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 createDataStream(int* streamId, bool reliable, bool ordered, bool sync) = 0;
 
  virtual int sendStreamMessage(int streamId, const char* data, size_t length, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual int sendRdtMessage(user_id_t userId, RdtStreamType type, const char *data, size_t length, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual int sendMediaControlMessage(user_id_t userId, const char* data, size_t length, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual int enableEncryption(bool enabled, const EncryptionConfig& config, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual int sendCustomReportMessage(const char* id, const char* category, const char* event, const char* label, int value, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
  virtual int getUserInfoByUserAccount(const char* userAccount, rtc::UserInfo* userInfo) = 0;
  virtual int getUserInfoByUid(uid_t uid, rtc::UserInfo* userInfo) = 0;
 
  virtual int enableMultipath(bool enable, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual int setUplinkMultipathMode(MultipathMode mode, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual int setDownlinkMultipathMode(MultipathMode mode, aosl_ref_t ares = AOSL_REF_INVALID) = 0;
 
  virtual int setPreferMultipathType(MultipathType type, aosl_ref_t ares = AOSL_REF_INVALID) = 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 onRenewTokenResult(const char* token, RENEW_TOKEN_ERROR_CODE code) = 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, const ClientRoleOptions& newRoleOptions) {
    (void)oldRole;
    (void)newRole;
    (void)newRoleOptions;
  }
 
  virtual void onChangeRoleFailure(CLIENT_ROLE_CHANGE_FAILED_REASON reason, CLIENT_ROLE_TYPE currentRole) {
    (void)reason;
    (void)currentRole;
  }
 
  virtual void onLicenseValidationFailure(LICENSE_ERROR_TYPE error) {
    (void)error;
  }
 
  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 onContentInspectResult(media::CONTENT_INSPECT_RESULT result) { (void)result; }
  virtual void onSnapshotTaken(user_id_t userId, const char* filePath, int width, int height, int errCode) {
    (void)userId;
    (void)filePath;
    (void)width;
    (void)height;
    (void)errCode;
  }
  virtual void onError(ERROR_CODE_TYPE error, const char* msg) {
    (void)error;
    (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;
  }
 
  virtual void onSetRtmFlagResult(int code) {
    (void)code;
  }
 
  virtual void onMultipathStats(const MultipathStats& stats) {
    (void)stats;
  }
};
 
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