ISettingService.h

Go to the documentation of this file.

 
#ifndef ZRC_ISETTINGSERVICE_H
#define ZRC_ISETTINGSERVICE_H
 
#include "ZRCSDKTypes.h"
 
NS_ZRCSDK_BEG
 
class ICalibrationHelper;
 
enum AudioCheckupCommand
{
    AudioCheckupCommandStart = 0,       
    AudioCheckupCommandCancel           
};
 
enum AudioCheckupStatus
{
    AudioCheckupStatusIdle = 0,         
    AudioCheckupStatusScheduled,        
    AudioCheckupStatusStarting,         
    AudioCheckupStatusChecking,         
    AudioCheckupStatusSucceeded,        
    AudioCheckupStatusFailed,           
    AudioCheckupStatusFailedLikely      
};
 
enum AdvancedNoiseSuppressionMode
{
    AdvancedNoiseSuppressionModeNone = -1,      
    AdvancedNoiseSuppressionModeAuto = 0,       
    AdvancedNoiseSuppressionModeHigh,           
    AdvancedNoiseSuppressionModeOff             
};
 
enum MicRecordTestStatus
{
    MicRecordTestStatusNone = 1,            
    MicRecordTestStatusRecording = 2,       
    MicRecordTestStatusPlaying = 3,         
};
 
enum ScreenResolutionStatus
{
    ScreenResolutionStatusOptimizable = 0,      
    ScreenResolutionStatusOptimized = 1         
};
 
enum ScreenSequenceCalibrationAction
{
    ScreenSequenceCalibrationNone = -1,         
    ScreenSequenceCalibrationStart = 0,         
    ScreenSequenceCalibrationIdentify,          
    ScreenSequenceCalibrationConfirm,           
    ScreenSequenceCalibrationCancel,            
    ScreenSequenceCalibrationConfidenceStart,   
    ScreenSequenceCalibrationConfidenceIdentify 
};
 
enum ChannelSignalType
{
    ChannelSignalTypeUnknown = -1,              
    ChannelSignalTypeMono = 0,                  
    ChannelSignalTypeStereoLeft,                
    ChannelSignalTypeStereoRight,               
};
 
enum NetworkType
{
    NetworkTypeUnknown = -1,                
    NetworkTypeWired = 0,                   
    NetworkTypeWifi = 1,                    
    NetworkTypePPP = 2,                     
    NetworkType3G = 3                       
};
 
enum NetworkConnectionType
{
    NetworkConnectionTypeUnknown = -1,          
    NetworkConnectionTypeDirect = 0,            
    NetworkConnectionTypeCloud = 1,             
};
 
enum StatisticalDataStatus
{
    StatisticalDataStatusNone = -1,     
    StatisticalDataStatusNormal = 0,    
    StatisticalDataStatusWarning = 1,   
    StatisticalDataStatusError = 2,     
};
 
enum NetworkAudioDeviceListAction
{
    NetworkAudioDeviceListActionUnknown = -1,         
    NetworkAudioDeviceListActionRefreshList,          
    NetworkAudioDeviceListActionRemoveDevice,         
    NetworkAudioDeviceListActionAddDevice,            
    NetworkAudioDeviceListActionUpdateDevice,         
    NetworkAudioDeviceListActionUseDanteController    
};
 
enum NetworkAudioDeviceState
{
    NetworkAudioDeviceStateNone = 0,        
    NetworkAudioDeviceStateAvailable,       
    NetworkAudioDeviceStateConnecting,      
    NetworkAudioDeviceStateConnected,       
    NetworkAudioDeviceStateDisconnected,    
    NetworkAudioDeviceStateError,           
    NetworkAudioDeviceStateOccupied         
};
 
enum NetworkAdapterUpdateType
{
    NetworkAdapterUpdateTypeNone = -1,  
    NetworkAdapterUpdateTypeDante = 0,  
    NetworkAdapterUpdateTypeNRC = 1,    
};
 
enum SystemAudioEnhancementsMode
{
    SystemAudioEnhancementsModeNone = -1,       
    SystemAudioEnhancementsModeAuto = 0,        
    SystemAudioEnhancementsModeOn,              
    SystemAudioEnhancementsModeOff              
};
 
enum VoiceCommandProvider
{
    VoiceCommandProviderNone = 0,   
    VoiceCommandProviderAlexa,      
    VoiceCommandProviderSensory,    
    VoiceCommandProviderAIC,        
};
 
struct QualityStatisticalAudio
{
    uint32_t              sampleRate = 0xffffffff;  
    std::vector<uint32_t> recSampleRates;           
};
 
struct QualityStatisticalVideo
{
    uint32_t fpsOfRecvMaxVideo = 0xffffffff;        
    uint32_t widthOfMaxRecvVideo = 0xffffffff;      
    uint32_t heightOfMaxRecvVideo = 0xffffffff;     
    uint32_t resolutionOfSend = 0xffffffff;         
    uint64_t fpsOfSend = 0xffffffff;                
};
 
struct QualityStatisticalShare
{
    uint32_t fpsOfRecvShare = 0xffffffff;           
    uint32_t widthOfRecvShare = 0xffffffff;         
    uint32_t heightOfRecvShare = 0xffffffff;        
    uint32_t resolutionOfSend = 0xffffffff;         
    uint64_t fpsOfSend = 0xffffffff;                
};
 
struct QualityStatisticalInfo
{
    QualityStatisticalAudio audioStatisticalInfo;   
    QualityStatisticalVideo videoStatisticalInfo;   
    QualityStatisticalShare shareStatisticalInfo;   
};
 
struct StatisticalNetWorkStatusInfo
{
    uint32_t avgLossRatio = 0xffffffff;             
    uint32_t maxLossRatio = 0xffffffff;             
    uint32_t rtt = 0xffffffff;                      
    uint32_t jitter = 0xffffffff;                   
    uint32_t rate = 0xffffffff;                     
};
 
struct StatisticalMediaInfo
{
    StatisticalNetWorkStatusInfo networkSendingStatus;      
    StatisticalNetWorkStatusInfo networkReceivingStatus;    
    QualityStatisticalInfo       qualityStatisticalInfo;    
};
 
struct StatisticalGPUInfo
{
    std::string           name;                                                 
    std::string           driverVersion;                                        
    int32_t               utilization = 0;                                      
    StatisticalDataStatus utilizationStatus = StatisticalDataStatusNone;        
};
 
struct StatisticalOverallInfo
{
    int32_t               cpuCoreNumber = 0;                
    float                 cpuFrequency = 0.0f;              
    int32_t               cpuZRUsage = 0;                   
    int32_t               cpuOverallUsage = 0;              
    int32_t               memorySize = 0;                   
    int32_t               memoryZRUsage = 0;                
    int32_t               memoryOverallUsage = 0;           
    NetworkType           networkType = NetworkTypeUnknown; 
    std::string           proxy;                            
    NetworkConnectionType netWorkConnectionType = NetworkConnectionTypeUnknown; 
    std::string           dataCenterRegionMessage;          
    std::string           encryption;                       
    int32_t               storageTotalMB = 0;               
    int32_t               storageUsedMB = 0;                
    StatisticalDataStatus storageStatus = StatisticalDataStatusNone; 
    std::vector<StatisticalGPUInfo> gpuInfoList;            
};
 
struct StatisticalPhoneNetworkInfo
{
    uint32_t      packetsNumber = 0;        
    uint32_t      frequency = 0;            
    float         packetLoss = 0.0f;        
    float         packetLossMax = 0.0f;     
    uint32_t      jitter = 0;               
    float         bandwidth = 0.0f;         
    std::string   codec;                    
};
 
struct StatisticalPhonePeerInfo
{
    std::string                 peerNumber;             
    std::string                 localIp;                
    uint32_t                    localPort = 0;          
    std::string                 remoteIp;               
    uint32_t                    remotePort = 0;         
    uint32_t                    networkDelay = 0;       
    StatisticalPhoneNetworkInfo networkSendingStatus;   
    StatisticalPhoneNetworkInfo networkReceivingStatus; 
};
 
struct StatisticalPhoneInfo
{
    std::string                           registerId;               
    std::string                           registerServerIp;         
    uint32_t                              registerServerPort = 0;   
    std::string                           networkSwitch;            
    std::string                           localNetworkInterface;    
    std::vector<StatisticalPhonePeerInfo> phonePeers;               
};
 
struct DiagnosticMsg
{
    std::string field;    
    std::string
        description;    
};
 
struct DiagnosticMsgGroup
{
    std::string                name;    
    std::vector<DiagnosticMsg> msgs;    
};
 
struct DiagnosticInfo
{
    std::vector<DiagnosticMsgGroup> groups;    
};
 
struct StatisticalInfo
{
    StatisticalOverallInfo overallInfo;     
    StatisticalMediaInfo   audioInfo;       
    StatisticalMediaInfo   videoInfo;       
    StatisticalMediaInfo   shareInfo;       
    StatisticalPhoneInfo   phoneInfo;       
};
 
struct AudioCheckupInfo
{
    AudioCheckupStatus status = AudioCheckupStatusIdle;     
    int32_t            intervalAfterScheduled = 0;          
    int32_t            percentageOfCheckup = 0;             
    bool               canRestartZoomRoomsSystem = false;   
    int32_t            intervalAfterFinished = 0;           
    int32_t            aecLevel = -1;                       
    std::string        testTime;                            
};
 
struct RoomProfile
{
    std::string             ID;                 
    std::string             name;               
    bool                    isSelected = false; 
    std::vector<int32_t>    issueDevices;       
};
 
struct RoomProfileList
{
    std::vector<RoomProfile> roomProfileList;   
};
 
struct RoomCapability
{
    bool supportAutoLoginOS = false;            
    bool supportRestartOS = false;              
    bool notSupportDigitalSignage = false;      
    bool notSupportMicAdvancedOption = false;   
};
 
struct AdjustScreensRes
{
    int32_t                         result = 0;                              
    int32_t                         currentScreen = -1;                      
    int32_t                         quantityOfScreens= -1;                   
    ScreenSequenceCalibrationAction action = ScreenSequenceCalibrationNone;  
};
 
struct ScreenInfos
{
    int32_t quantityOfScreens = 1;                      
    int32_t quantityOfCecAdapterAttachedScreens = 0;    
    bool    hasConfidenceMonitor = false;               
    int32_t mainDisplayPosition = 0;                    
};
 
enum CalibrationAction
{
    CalibrationActionPageAdjustCamera,              
    CalibrationActionPageCameraControl,             
    CalibrationActionPageReadyToMove,               
    CalibrationActionEventStartToCalibrate,         
    CalibrationActionEventFinishToCheckResult,      
    CalibrationActionEventAcceptResult,             
    CalibrationActionEventStop,                     
 
    // boundary
    CalibrationActionPageAskNeedSetCameraBoundary,  
    CalibrationActionEventSwitchBoundaryCamera,     
    CalibrationActionEventAdjustBoundary,           
    CalibrationActionPageVerifyBoundary,            
    CalibrationActionPagePreAcceptBoundary,         
    CalibrationActionEventAcceptBoundaryResult,     
    CalibrationActionPagePreviewIDBoundary,         
};
 
struct NetworkAudioChannelInfo
{
    NetworkAudioDeviceState state = NetworkAudioDeviceStateNone;      
    ChannelSignalType       signalType = ChannelSignalTypeUnknown;    
    std::string             deviceId;                                 
    std::string             channelName;                              
};
 
struct NetworkAudioDevice
{
    NetworkAudioDeviceState state = NetworkAudioDeviceStateNone;    
    std::vector<NetworkAudioChannelInfo> channels;                  
    std::string                          ID;                        
    std::string                          name;                      
    bool                                 identifiable = false;      
};
 
struct AudioChannelAndCameraBindInfo
{
    std::string cameraDeviceID;         
    std::string networkDeviceName;      
    std::string networkChannelName;     
    int32_t rxChannelID = 0;            
};
 
struct IntelligentDirectorInfo
{
    bool    supportsDirectorMode = false;                   
    bool    isCalibrationConfigured = false;                
    bool    allowDirectorAndMultiCameraParallel = false;    
    bool    isRegionLimited = false;                        
    int32_t supportedCameraNumber = 3;                      
    int32_t multiCameraParallelNumInDirector = 0;           
    bool    supportSavePresetImage = false;                 
};
 
struct CameraBoundaryConfigurationInfo
{
    bool     supportsBoundary = false;          
    bool     isBoundaryConfigured = false;      
    uint32_t cameraBoundaryCapability = 0;      
    int32_t  cameraBoundaryEnableStatus = -1;   
};
 
struct NetworkAdapterInfo
{
    NetworkAdapterUpdateType updateType = NetworkAdapterUpdateTypeNone; 
    std::string              adapter;                                   
    std::string              ip;                                        
};
 
struct AICVoiceCommandInfo
{
    bool isSessionStarted = false;  
    bool isPlaybackMuted = false;   
};
 
struct VoiceCommandStatus
{
    VoiceCommandProvider provider = VoiceCommandProviderNone;   
    bool                 enable = false;                        
    AICVoiceCommandInfo  aicVoiceCommandInfo;                   
};
 
class ISettingServiceSink
{
public:
    virtual ~ISettingServiceSink() {}
 
    virtual void OnMicrophoneListChanged(const std::vector<Device>& microphones) = 0;
 
    virtual void OnSpeakerListChanged(const std::vector<Device>& speakers) = 0;
 
    virtual void OnCameraListChanged(const std::vector<Device>& cameras) = 0;
 
    virtual void OnUpdateCOMList(const std::vector<Device>& comList) = 0;
 
    virtual void OnCompanionZRDeviceUpdateNotification(const CompanionZRDeviceUpdateNot& noti) = 0;
    
    virtual void OnCurrentMicrophoneChanged(bool exist, const Device& microphone) = 0;
    
    virtual void OnCurrentSpeakerChanged(bool exist, const Device& speaker) = 0;
 
    virtual void OnCurrentCameraChanged(bool exist, const Device& camera) = 0;
 
    virtual void OnCurrentMicrophoneVolumeChanged(float volume) = 0;
 
    virtual void OnCurrentSpeakerVolumeChanged(float volume) = 0;
 
    virtual void OnUpdateHardwareStatus(const HardwareStatus& status) = 0;
 
    virtual void OnUpdatedGenericSettings(const GenericSettings& genericSettings) = 0;
 
    virtual void OnUpdateVoiceCommandStatus(const VoiceCommandStatus& status) = 0;
 
    virtual void OnUpdateRoomProfileList(const RoomProfileList& list) = 0;
 
    virtual void OnUpdateZoomRoomCapability(const RoomCapability& roomCapability) = 0;
 
    virtual void OnCurrentSelectedMicrophoneMuted(bool muted) = 0;
 
    virtual void OnMicrophoneTestingNotification(int32_t volume) = 0;
 
    virtual void OnMicrophoneRecordingNotification(MicRecordTestStatus status) = 0;
 
    virtual void OnSpeakerTestingNotification(int32_t volume, bool isEnabled) = 0;
 
    virtual void OnSpeakerTestingResult(int32_t result, float duration, bool isStopped) = 0;
 
    virtual void OnStatisticalInfoNotification(const StatisticalInfo& info) = 0;
 
    virtual void OnAudioCheckupNotification(const AudioCheckupInfo& info) = 0;
 
    virtual void OnAudioSystemFailureNotification(bool isDismiss) = 0;
 
    virtual void OnScreenInfosNotification(const ScreenInfos& screenInfos) = 0;
 
    virtual void OnAdjustScreensResponse(const AdjustScreensRes& response) = 0;
 
    virtual void OnZoomPresenceScreenSaverNotification(bool running) = 0;
 
    virtual void OnUpdatedOperationTimeStatusNotification(bool shouldDimScreen) = 0;
 
    virtual void OnDirectorCalibrationNotification(const DirectorCalibrationNot& noti) = 0;
 
    virtual void OnIntelligentDirectorInfoNotification(const IntelligentDirectorInfo& info) = 0;
 
    virtual void OnCameraBoundaryConfigurationInfoNotification(const CameraBoundaryConfigurationInfo& info) = 0;
 
    virtual void OnUpdateDiagnosticInfo(const DiagnosticInfo& info) = 0;
 
    virtual void OnChangeWindowsPasswordNotification(int32_t result) = 0;
 
    virtual void OnUpdateNetworkAudioDeviceList(const std::string& virtualDeviceID, NetworkAudioDeviceListAction action,
                                                const std::vector<NetworkAudioDevice>& networkAudioDeviceList, bool isUsedDanteController) = 0;
    
    virtual void OnListAudioChannelAndCameraBindInfoNotification(const std::vector<AudioChannelAndCameraBindInfo>& bindInfoList) = 0;
    
    virtual void OnBindAudioChannelAndCameraNotification(const std::vector<AudioChannelAndCameraBindInfo>& bindInfoList) = 0;
    
    virtual void OnUnbindAudioChannelAndCameraNotification(const std::vector<AudioChannelAndCameraBindInfo>& bindInfoList) = 0;
    
    virtual void OnUnbindAllAudioChannelAndCameraConnectionsNotification(const std::vector<AudioChannelAndCameraBindInfo>& bindInfoList) = 0;
 
    virtual void OnNetworkAdapterUpdateInfo(const std::vector<NetworkAdapterInfo>& networkAdapterInfos) = 0;
 
    virtual void OnUpdateMicStethoscopeModeEnabledStatus(bool isMicStethoscopeModeEnabled) = 0;
 
    virtual void OnUpdateSystemAudioEnhancementsMode(SystemAudioEnhancementsMode mode) = 0;
};
 
class ISettingService
{
public:
    virtual ~ISettingService() {}
 
    virtual ZRCSDKError RegisterSink(ISettingServiceSink* pSink) = 0;
 
    virtual ZRCSDKError DeregisterSink(ISettingServiceSink* pSink) = 0;
 
    virtual ZRCSDKError GetMicrophoneList(std::vector<Device>& microphones) = 0;
 
    virtual ZRCSDKError GetSpeakerList(std::vector<Device>& speakers) = 0;
 
    virtual ZRCSDKError GetCameraList(std::vector<Device>& cameras) = 0;
 
    virtual ZRCSDKError GetCompanionZRList(std::vector<CompanionZRDeviceInfo>& CZRs) = 0;
 
    virtual ZRCSDKError GetNetworkAudioDeviceList(const std::string& virtualDeviceID, std::vector<NetworkAudioDevice>& networkAudioDeviceList) = 0;
 
    virtual ZRCSDKError GetCurrentMicrophone(Device& microphone) = 0;
 
    virtual ZRCSDKError GetCurrentSpeaker(Device& speaker) = 0;
 
    virtual ZRCSDKError GetCurrentCamera(Device& camera) = 0;
 
    virtual ZRCSDKError SetCurrentMicrophone(const Device& microphone) = 0;
 
    virtual ZRCSDKError SetCurrentSpeaker(const Device& speaker) = 0;
 
    virtual ZRCSDKError SetCurrentCamera(const Device& camera) = 0;
 
    virtual ZRCSDKError GetMicrophoneVolume(float& volume) = 0;
 
     virtual ZRCSDKError GetSpeakerVolume(float& volume) = 0;
 
    virtual ZRCSDKError SetMicrophoneVolume(float volume) = 0;
 
    virtual ZRCSDKError SetSpeakerVolume(float volume) = 0;
 
    virtual ZRCSDKError SetSpeakerTempVolumeInMeeting(float volume) = 0;
 
    // microphone
 
    virtual ZRCSDKError TestMicrophone(bool on) = 0;
 
    virtual ZRCSDKError StartTestingMicrophoneVolume() = 0;
 
    virtual ZRCSDKError StopTestingMicrophoneVolume() = 0;
 
    virtual ZRCSDKError ConfirmNumberOfCombinedMicrophone(int32_t number) = 0;
 
    virtual ZRCSDKError IsSupportAcousticEchoCancellation(bool& support) = 0;
 
    virtual ZRCSDKError EnableAcousticEchoCancellation(bool enable) = 0;
 
    virtual ZRCSDKError IsSupportAdvancedNoiseSuppression(bool& support) = 0;
 
    virtual ZRCSDKError GetCurrentAdvancedNoiseSuppressionMode(AdvancedNoiseSuppressionMode& mode) = 0;
 
    virtual ZRCSDKError SelectAdvancedNoiseSuppressionMode(AdvancedNoiseSuppressionMode mode) = 0;
 
    virtual ZRCSDKError EnableMicrophoneHardwareTroubleshooting(bool enable) = 0;
 
    virtual ZRCSDKError AudioCheckup(AudioCheckupCommand command) = 0;
 
    virtual ZRCSDKError IsAudioFramingAvailable(bool& available) = 0;
 
    virtual ZRCSDKError EnableAudioFraming(bool enable) = 0;
 
    virtual ZRCSDKError EnableVoiceCommand(bool enable) = 0;
 
    virtual ZRCSDKError CloseAICVoiceCommandSession() = 0;
 
    virtual ZRCSDKError MuteAICVoiceCommandPlayback(bool mute) = 0;
 
    // speaker
 
    virtual ZRCSDKError StartTestingSpeaker() = 0;
 
    virtual ZRCSDKError StopTestingSpeaker() = 0;
 
    virtual ZRCSDKError IsSpatialAudioAvailable(bool& available) = 0;
 
    virtual ZRCSDKError EnableSpatialAudio(bool enable) = 0;
    
    // camera
 
    virtual ZRCSDKError SelectMultipleCamera(const std::string& deviceID, bool isSelected, const std::string& companionZRID = "") = 0;
 
    virtual ZRCSDKError SelectIntelligentDirectorCamera(const std::string& deviceID, bool isSelected) = 0;
 
    virtual ZRCSDKError CalibrateIntelligentDirectorMode(CalibrationAction actionType, const std::string& deviceID = "", CameraBoundaryAdjustField boundaryAdjustField = CameraBoundaryAdjustFieldUnknown, int32_t boundaryAdjustValue = 0) = 0;
 
    virtual ZRCSDKError SetCameraCOMId(const std::string& deviceID, int32_t comID, const std::string& companionZRID = "") = 0;
 
    virtual ZRCSDKError SetCameraDisplayName(const std::string& deviceID, const std::string& displayName, const std::string& companionZRID = "") = 0;
 
    // General room setting action
 
    virtual ZRCSDKError SelectRoomProfile(const std::string& profileID, const std::string& profileName) = 0;
 
    virtual ZRCSDKError EnableStatisticalInfo(bool enable) = 0;
 
    virtual ZRCSDKError StartAdjustZRScreens() = 0;
 
    virtual ZRCSDKError StartOverAdjustZRScreens() = 0;
 
    virtual ZRCSDKError IdentifyZRConfidenceMonitor(int32_t positionOfConfidenceMonitor) = 0;
 
    virtual ZRCSDKError IdentifyZRScreens(int32_t currentScreen, int32_t positionOfCurrentScreen) = 0;
 
    virtual ZRCSDKError ConfirmAdjustZRScreens() = 0;
 
    virtual ZRCSDKError CancelAdjustZRScreens() = 0;
 
    virtual ZRCSDKError TurnCECScreensOn(bool on) = 0;
 
    virtual ZRCSDKError RefreshDiagnosticInfo() = 0;
 
    virtual ZRCSDKError GetWindowsIoTAccountName(std::string& osAccountName) = 0;
 
    virtual ZRCSDKError ChangeWindowsPassword(const std::string& oldPassword, const std::string& newPassword) = 0;
 
    // virtual audio device
 
    virtual ZRCSDKError ListVirtualAudioDevices(const std::string& virtualDeviceID, VirtualAudioDeviceType deviceType) = 0;
 
    virtual ZRCSDKError SelectVirtualAudioDevice(const std::string& virtualDeviceID, VirtualAudioDeviceType deviceType,
                                                 const std::string& networkDeviceID, const NetworkAudioChannelInfo& channel) = 0;
 
    virtual ZRCSDKError UnselectVirtualAudioDevice(const std::string& virtualDeviceID, VirtualAudioDeviceType deviceType,
                                                   const std::string& networkDeviceID, const NetworkAudioChannelInfo& channel) = 0;
 
    virtual ZRCSDKError IdentifyVirtualAudioDevice(const std::string& virtualDeviceID, VirtualAudioDeviceType deviceType,
                                                   const std::string& networkDeviceID) = 0;
 
    virtual ZRCSDKError UseDanteController(const std::string& virtualDeviceID, VirtualAudioDeviceType deviceType, bool isUsedDanteController) = 0;
 
    virtual ZRCSDKError IsUseDanteController(const std::string& virtualDeviceID, bool& isUseDanteController) = 0;
    
    virtual ZRCSDKError ListAudioChannelAndCameraBindInfo() = 0;
    
    virtual ZRCSDKError BindCameraToAudioChannel(const std::string& cameraDeviceID, int32_t rxChannelID) = 0;
    
    virtual ZRCSDKError UnbindCameraFromAudioChannel(const std::string& cameraDeviceID) = 0;
    
    virtual ZRCSDKError UnbindAudioChannelFromCamera(int32_t rxChannelID) = 0;
    
    virtual ZRCSDKError UnbindAllAudioChannelAndCameraConnections() = 0;
 
    virtual ZRCSDKError RenameCompanionZR(const std::string& czrID, const std::string& displayName) = 0;
 
    virtual ZRCSDKError GetNetWorkAdapterInfo(std::vector<NetworkAdapterInfo>& networkAdapterInfos) = 0;
 
    virtual ZRCSDKError GetCurrentSystemAudioEnhancementsMode(SystemAudioEnhancementsMode& mode) = 0;
 
    virtual ZRCSDKError SelectSystemAudioEnhancementsMode(SystemAudioEnhancementsMode mode) = 0;
    
    virtual ICalibrationHelper* GetCalibrationHelper() = 0;
 
    virtual ZRCSDKError EnableMultiCameraOnlyMode(bool enable) = 0;
};
 
NS_ZRCSDK_END
 
#endif    //ZRC_ISETTINGSERVICE_H