NGIAgoraLocalUser.h

Go to the documentation of this file.

//
//  Agora SDK
//
//  Created by Zheng Ender in 2018-01.
//  Copyright (c) 2018 Agora.io. All rights reserved.
//
 
#pragma once  // NOLINT(build/header_guard)
 
#include <cstring>
 
#include "AgoraBase.h"
#include "AgoraOptional.h"
 
namespace agora {
namespace media {
class IAudioFrameObserver;
}
 
namespace rtc {
class IAudioEngineWrapper;
 
class ILocalUserObserver;
class ILocalVideoTrack;
class IRemoteVideoTrack;
class IVideoFrameObserver2;
 
struct AudioEncoderConfiguration;
struct VideoEncoderConfiguration;
 
class ILocalAudioTrack;
struct RemoteAudioTrackStats;
class IRemoteAudioTrack;
struct LocalVideoTrackStats;
struct RemoteVideoTrackStats;
class IVideoSinkBase;
class ILocalUser {
 public:
 
  struct ANAStats {
    agora::Optional<uint32_t> bitrate_action_counter;
    agora::Optional<uint32_t> channel_action_counter;
    agora::Optional<uint32_t> dtx_action_counter;
    agora::Optional<uint32_t> fec_action_counter;
    agora::Optional<uint32_t> frame_length_increase_counter;
    agora::Optional<uint32_t> frame_length_decrease_counter;
    agora::Optional<float> uplink_packet_loss_fraction;
  };
 
  struct AudioProcessingStats {
    agora::Optional<double> echo_return_loss;
    //
    agora::Optional<double> echo_return_loss_enhancement;
    agora::Optional<double> divergent_filter_fraction;
 
    agora::Optional<int32_t> delay_median_ms;
    agora::Optional<int32_t> delay_standard_deviation_ms;
 
    agora::Optional<double> residual_echo_likelihood;
    agora::Optional<double> residual_echo_likelihood_recent_max;
 
    agora::Optional<int32_t> delay_ms;
  };
 public:
  virtual ~ILocalUser() {}
 
  virtual void setUserRole(rtc::CLIENT_ROLE_TYPE role) = 0;
 
  virtual CLIENT_ROLE_TYPE getUserRole() = 0;
 
  virtual void setAudienceLatencyLevel(AUDIENCE_LATENCY_LEVEL_TYPE level) = 0;
 
  virtual AUDIENCE_LATENCY_LEVEL_TYPE getAudienceLatencyLevel() = 0;
 
  virtual int setAudioEncoderConfiguration(const rtc::AudioEncoderConfiguration& config) = 0;
 
  virtual int publishAudio(agora_refptr<ILocalAudioTrack> audioTrack) = 0;
 
  virtual int unpublishAudio(agora_refptr<ILocalAudioTrack> audioTrack) = 0;
 
  virtual int publishVideo(agora_refptr<ILocalVideoTrack> videoTrack) = 0;
 
  virtual int unpublishVideo(agora_refptr<ILocalVideoTrack> videoTrack) = 0;
 
  virtual int subscribeAudio(user_id_t userId) = 0;
 
  virtual int subscribeAllAudio() = 0;
 
  virtual int unsubscribeAudio(user_id_t userId) = 0;
 
  virtual int unsubscribeAllAudio() = 0;
 
  virtual int setPlaybackAudioFrameParameters(size_t numberOfChannels,
                                              uint32_t sampleRateHz,
                                              RAW_AUDIO_FRAME_OP_MODE_TYPE mode = RAW_AUDIO_FRAME_OP_MODE_READ_ONLY,
                                              int samplesPerCall = 0) = 0;
  virtual int setRecordingAudioFrameParameters(size_t numberOfChannels,
                                               uint32_t sampleRateHz,
                                               RAW_AUDIO_FRAME_OP_MODE_TYPE mode = RAW_AUDIO_FRAME_OP_MODE_READ_ONLY,
                                               int samplesPerCall = 0) = 0;
  virtual int setMixedAudioFrameParameters(size_t numberOfChannels,
                                           uint32_t sampleRateHz,
                                           int samplesPerCall = 0) = 0;
 
  virtual int setPlaybackAudioFrameBeforeMixingParameters(size_t numberOfChannels,
                                                          uint32_t sampleRateHz) = 0;
 
  virtual int registerAudioFrameObserver(agora::media::IAudioFrameObserverBase * observer) = 0;
  virtual int unregisterAudioFrameObserver(agora::media::IAudioFrameObserverBase * observer) = 0;
 
  virtual int registerVideoEncodedFrameObserver(agora::media::IVideoEncodedFrameObserver* observer) = 0;
  virtual int unregisterVideoEncodedFrameObserver(agora::media::IVideoEncodedFrameObserver* observer) = 0;
 
  virtual int registerVideoFrameObserver(IVideoFrameObserver2* observer) = 0;
  virtual int unregisterVideoFrameObserver(IVideoFrameObserver2* observer) = 0;
 
  virtual int subscribeVideo(user_id_t userId,
                             const rtc::VideoSubscriptionOptions &subscriptionOptions) = 0;
 
  virtual int subscribeAllVideo(const rtc::VideoSubscriptionOptions &subscriptionOptions) = 0;
 
  virtual int unsubscribeVideo(user_id_t userId) = 0;
 
  virtual int unsubscribeAllVideo() = 0;
 
  virtual int registerLocalUserObserver(
      ILocalUserObserver* observer,
      void(*safeDeleter)(ILocalUserObserver*) = NULL) = 0;
 
  virtual int unregisterLocalUserObserver(ILocalUserObserver* observer) = 0;
 
  virtual int sendIntraRequest(user_id_t userId) = 0;
};
 
struct AudioVolumeInformation {
  user_id_t userId;
 
  unsigned int volume;
 
  /*
   * The activity status of remote users
   */
  unsigned int vad;
 
  double voicePitch;
 
  AudioVolumeInformation() : userId(NULL), volume(0), vad(0), voicePitch(0.0) {}
};
 
class ILocalUserObserver {
 public:
  virtual ~ILocalUserObserver() {}
 
  virtual void onAudioTrackPublishSuccess(agora_refptr<ILocalAudioTrack> audioTrack) = 0;
 
 
  virtual void onAudioTrackPublicationFailure(agora_refptr<ILocalAudioTrack> audioTrack,
                                              ERROR_CODE_TYPE error) = 0;
 
  virtual void onLocalAudioTrackStateChanged(agora_refptr<rtc::ILocalAudioTrack> audioTrack,
                                             LOCAL_AUDIO_STREAM_STATE state,
                                             LOCAL_AUDIO_STREAM_ERROR errorCode) = 0;
  virtual void onLocalAudioTrackStatistics(const LocalAudioStats& stats) = 0;
  virtual void onRemoteAudioTrackStatistics(agora_refptr<rtc::IRemoteAudioTrack> audioTrack, const RemoteAudioTrackStats& stats) = 0;
  virtual void onUserAudioTrackSubscribed(user_id_t userId,
                                          agora_refptr<rtc::IRemoteAudioTrack> audioTrack) = 0;
 
  virtual void onUserAudioTrackStateChanged(user_id_t userId,
                                            agora_refptr<rtc::IRemoteAudioTrack> audioTrack,
                                            REMOTE_AUDIO_STATE state,
                                            REMOTE_AUDIO_STATE_REASON reason,
                                            int elapsed) = 0;
 
  virtual void onVideoTrackPublishSuccess(agora_refptr<ILocalVideoTrack> videoTrack) = 0;
 
 
  virtual void onVideoTrackPublicationFailure(agora_refptr<ILocalVideoTrack> videoTrack,
                                              ERROR_CODE_TYPE error) = 0;
 
  virtual void onLocalVideoTrackStateChanged(agora_refptr<rtc::ILocalVideoTrack> videoTrack,
                                             LOCAL_VIDEO_STREAM_STATE state,
                                             LOCAL_VIDEO_STREAM_ERROR errorCode) = 0;
 
  virtual void onLocalVideoTrackStatistics(agora_refptr<rtc::ILocalVideoTrack> videoTrack,
                                           const LocalVideoTrackStats& stats) = 0;
 
  virtual void onUserVideoTrackSubscribed(user_id_t userId, VideoTrackInfo trackInfo,
                                          agora_refptr<rtc::IRemoteVideoTrack> videoTrack) = 0;
 
  virtual void onUserVideoTrackStateChanged(user_id_t userId,
                                            agora_refptr<rtc::IRemoteVideoTrack> videoTrack,
                                            REMOTE_VIDEO_STATE state,
                                            REMOTE_VIDEO_STATE_REASON reason,
                                            int elapsed) = 0;
 
  virtual void onFirstRemoteVideoFrameRendered(user_id_t userId, int width,
                                               int height, int elapsed) = 0;
 
 
  virtual void onRemoteVideoTrackStatistics(agora_refptr<rtc::IRemoteVideoTrack> videoTrack,
                                            const RemoteVideoTrackStats& stats) = 0;
 
  virtual void onAudioVolumeIndication(const AudioVolumeInformation* speakers, unsigned int speakerNumber,
                                       int totalVolume) = 0;
 
  virtual void onActiveSpeaker(user_id_t userId) = 0;
 
  virtual void onAudioSubscribeStateChanged(const char* channel, user_id_t userId, STREAM_SUBSCRIBE_STATE oldState, STREAM_SUBSCRIBE_STATE newState, int elapseSinceLastState) = 0;
 
  virtual void onVideoSubscribeStateChanged(const char* channel, user_id_t userId, STREAM_SUBSCRIBE_STATE oldState, STREAM_SUBSCRIBE_STATE newState, int elapseSinceLastState) = 0;
 
  virtual void onAudioPublishStateChanged(const char* channel, STREAM_PUBLISH_STATE oldState, STREAM_PUBLISH_STATE newState, int elapseSinceLastState) = 0;
 
  virtual void onVideoPublishStateChanged(const char* channel, STREAM_PUBLISH_STATE oldState, STREAM_PUBLISH_STATE newState, int elapseSinceLastState) = 0;
 
  virtual void onFirstRemoteAudioFrame(user_id_t userId, int elapsed) = 0;
 
  virtual void onFirstRemoteAudioDecoded(user_id_t userId, int elapsed) = 0;
 
  virtual void onFirstRemoteVideoFrame(user_id_t userId, int width, int height, int elapsed) = 0;
 
  virtual void onFirstRemoteVideoDecoded(user_id_t userId, int width, int height, int elapsed) = 0;
 
  enum USER_MEDIA_INFO {
    USER_MEDIA_INFO_MUTE_AUDIO = 0,
    USER_MEDIA_INFO_MUTE_VIDEO = 1,
    USER_MEDIA_INFO_ENABLE_VIDEO = 4,
 
    USER_MEDIA_INFO_ENABLE_LOCAL_VIDEO = 8,
  };
 
  virtual void onUserInfoUpdated(user_id_t userId, USER_MEDIA_INFO msg, bool val) {
    (void)userId;
    (void)msg;
    (void)val;
  }
 
  virtual void onIntraRequestReceived() {}
 
  virtual void onStreamMessage(user_id_t userId, int streamId, const char* data, size_t length) {}
  enum REMOTE_USER_STATE {
    PEER_STATE_MUTE_AUDIO = (1 << 0),
    PEER_STATE_MUTE_VIDEO = (1 << 1),
    PEER_STATE_ENABLE_VIDEO = (1 << 4),
    PEER_STATE_ENABLE_LOCAL_VIDEO = (1 << 8),
 
  };
 
  virtual void onUserStateChanged(user_id_t userId, uint32_t state){}
};
 
class IVideoFrameObserver2 {
 public:
  virtual void onFrame(const char* channelId, user_id_t remoteUid, const media::base::VideoFrame* frame) = 0;
 
  virtual ~IVideoFrameObserver2() {}
};
 
}  // namespace rtc
}  // namespace agora