ApsaraVideo Live:Opérations audio courantes

// Set the audio scenario to AliRtcSceneDefaultMode.
mAliRtcEngine.setAudioProfile(AliRtcEngineHighQualityMode, AliRtcSceneDefaultMode);

// Set the audio scenario to AliRtcSceneDefaultMode.
engine.setAudioProfile(AliRtcAudioProfile.engineHighQualityMode, audio_scene: AliRtcAudioScenario.sceneDefaultMode)

this.rtcEngine.setAudioProfile(AliRtcAudioProfile.AliRtcHighQualityMode, AliRtcAudioScenario.AliRtcSceneDefaultMode);

[self.engine setAudioProfile:AliRtcEngineHighQualityMode audio_scene:AliRtcSceneDefaultMode];

mAliRtcEngine->SetAudioProfile(AliEngineHighQualityMode, AliEngineSceneDefaultMode);

// Select an encoding mode with a 48 kHz sample rate, such as AliRtcEngineHighQualityMode.
mAliRtcEngine.setAudioProfile(AliRtcEngineHighQualityMode, AliRtcSceneMusicMode);

// Select an encoding mode with a 48 kHz sample rate, such as AliRtcEngineHighQualityMode.
engine.setAudioProfile(AliRtcAudioProfile.engineHighQualityMode, audio_scene: AliRtcAudioScenario.sceneMusicMode)

this.rtcEngine.setAudioProfile(AliRtcAudioProfile.AliRtcHighQualityMode, AliRtcAudioScenario.AliRtcSceneMusicMode);

[self.engine setAudioProfile:AliRtcEngineHighQualityMode audio_scene:AliRtcSceneMusicMode];

mAliRtcEngine->SetAudioProfile(AliEngineHighQualityMode, AliEngineSceneMusicMode);

// Set the mode to one that supports stereo, such as AliRtcEngineStereoHighQualityMode.
mAliRtcEngine.setAudioProfile(AliRtcEngineStereoHighQualityMode, AliRtcSceneMusicMode);

// Set the mode to one that supports stereo, such as AliRtcEngineStereoHighQualityMode.
engine.setAudioProfile(AliRtcAudioProfile.engineStereoHighQualityMode, audio_scene: AliRtcAudioScenario.sceneMusicMode)

this.rtcEngine.setAudioProfile(AliRtcAudioProfile.AliRtcStereoHighQualityMode, AliRtcAudioScenario.AliRtcSceneMusicMode);

[self.engine setAudioProfile:AliRtcEngineStereoHighQualityMode audio_scene:AliRtcSceneMusicMode];

mAliRtcEngine->SetAudioProfile(AliEngineStereoHighQualityMode, AliEngineSceneMusicMode);

// Mute all audio
mAliRtcEngine.muteLocalMic(true, AliRtcEngine.AliRtcMuteLocalAudioMode.AliRtcMuteAllAudioMode);
// Unmute all audio
mAliRtcEngine.muteLocalMic(false, AliRtcEngine.AliRtcMuteLocalAudioMode.AliRtcMuteAllAudioMode);
// Mute only the microphone
mAliRtcEngine.muteLocalMic(true, AliRtcEngine.AliRtcMuteLocalAudioMode.AliRtcMuteOnlyMicAudioMode);

// Mute all audio
self.rtcEngine?.muteLocalMic(true, mode: .allAudioMode)
// Unmute all audio
self.rtcEngine?.muteLocalMic(false, mode: .allAudioMode)
// Mute only the microphone
self.rtcEngine?.muteLocalMic(true, mode: .onlyMicAudioMode)

// Mute all audio
this.rtcEngine.muteLocalMic(true, AliRtcMuteLocalAudioMode.AliRtcMuteLocalAudioModeMuteAll);
// Unmute all audio
this.rtcEngine.muteLocalMic(false, AliRtcMuteLocalAudioMode.AliRtcMuteLocalAudioModeMuteAll);
// Mute only the microphone
this.rtcEngine.muteLocalMic(true, AliRtcMuteLocalAudioMode.AliRtcMuteLocalAudioModeMuteOnlyMic);

// Mute all audio
[self.engine muteLocalMic:TRUE mode:AliRtcMuteAllAudioMode];
// Unmute all audio
[self.engine muteLocalMic:FALSE mode:AliRtcMuteAllAudioMode];
// Mute only the microphone
[self.engine muteLocalMic:TRUE mode:AliRtcMuteOnlyMicAudioMode];

// Mute all audio
mAliRtcEngine->MuteLocalMic(true, AliEngineMuteLocalAudioModeMuteAll);
// Unmute all audio
mAliRtcEngine->MuteLocalMic(false, AliEngineMuteLocalAudioModeMuteAll);
// Mute only the microphone
mAliRtcEngine->MuteLocalMic(true, AliEngineMuteLocalAudioModeMuteOnlyMic);

// Stop microphone capture.
mAliRtcEngine.stopAudioCapture();
// Resume microphone capture.
mAliRtcEngine.startAudioCapture();

// Stop microphone capture.
self.rtcEngine?.stopAudioCapture()
// Resume microphone capture.
self.rtcEngine?.startAudioCapture()

// Stop microphone capture.
this.rtcEngine.stopAudioCapture();
// Resume microphone capture.
this.rtcEngine.startAudioCapture();

// Stop microphone capture.
[self.engine stopAudioCapture];
// Resume microphone capture.
[self.engine startAudioCapture];

// Stop microphone capture.
mAliRtcEngine->StopAudioCapture();
// Resume microphone capture.
mAliRtcEngine->StartAudioCapture();

rtcEngine.enableEarBack(true);

engine.enableEarBack(true)

this.rtcEngine.enableEarBack(true);

[self.engine enableEarBack:YES];

mAliRtcEngine->EnableEarBack(TRUE);

rtcEngine.setEarBackVolume(60);

rtcEngine?.setEarBackVolume(volume)

this.rtcEngine.setEarBackVolume(value);

[self.engine setEarBackVolume:60];

mAliRtcEngine->SetEarBackVolume(volume);

mAliRtcEngine.enableAudioVolumeIndication(500, 3,1);

// User volume callback and active speaker detection
engine.enableAudioVolumeIndication(500, smooth: 3, reportVad: 1)

// User volume callback and active speaker detection
this.rtcEngine.enableAudioVolumeIndication(1000, 3, 1);

// User volume callback and active speaker detection
[self.engine enableAudioVolumeIndication:500 smooth:3 reportVad:1];

// User volume callback and active speaker detection
mAliRtcEngine->EnableAudioVolumeIndication(500, 3, 1);

private final AliRtcEngine.AliRtcAudioVolumeObserver mAliRtcAudioVolumeObserver = new AliRtcEngine.AliRtcAudioVolumeObserver() {
    // User volume callback
    @Override
    public void onAudioVolume(List<AliRtcEngine.AliRtcAudioVolume> speakers, int totalVolume){
        handler.post(() -> {
            if(!speakers.isEmpty()) {
                for(AliRtcEngine.AliRtcAudioVolume volume : speakers) {
                    if("0".equals(volume.mUserId)) {
                        // Volume of the local user

                    } else if ("1".equals(volume.mUserId)) {
                        // Overall volume of remote users

                    } else {
                        // Volume of a remote user

                    }
                }
            }
        });
    }

    // Active speaker detection callback
    @Override
    public void onActiveSpeaker(String uid){
        // Active speaker
        handler.post(() -> {
            String mag = "onActiveSpeaker uid:" + uid;
            ToastHelper.showToast(AudioBasicUsageActivity.this, mag, Toast.LENGTH_SHORT);
        });
    }
};
// Register the callback
mAliRtcEngine.registerAudioVolumeObserver(mAliRtcAudioVolumeObserver);

func onAudioVolumeCallback(_ array: [AliRtcUserVolumeInfo]?, totalVolume: Int32) {
    // User volume callback
    "onAudioVolumeCallback, totalVolume: \(totalVolume)".printLog()
}

func onActiveSpeaker(_ uid: String) {
    // Active speaker callback
    "onActiveSpeaker, uid: \(uid)".printLog()
}

this.rtcEngineEventListener.onAudioVolumeCallback(
  (volumeInfo : AliRtcUserVolumeInfo[], volumeInfoCount : number, totalVolume : number) => {
    console.info(`Volume callback: volumeInfo=${volumeInfo}, volumeInfoCount=${volumeInfoCount}, totalVolume=${totalVolume}`);
  }
)

this.rtcEngineEventListener.onActiveSpeaker((uid: string) => {
  console.info(`Current active user: uid=${uid}`);
});

- (void)onAudioVolumeCallback:(NSArray <AliRtcUserVolumeInfo *> *)array totalVolume:(int)totalVolume {
    for(AliRtcUserVolumeInfo *info in array) {
        NSString *uid = info.uid;
        NSInteger volume = info.volume;
        dispatch_async(dispatch_get_main_queue(), ^{
            NSArray * volumeArray = [ _audioVolumeLabel.stringValue componentsSeparatedByString:@"\n"];

            if ([uid isEqualToString:@"1"]) { // Volume of remote users
                // Overall volume of remote users
            }else if ([uid isEqualToString:@"0"] ){ // Volume of the local user
                // Display the volume of the local user
            } else {

                // Overall volume of remote users
            }
        });
    }
}

- (void)onActiveSpeaker:(NSString *)uid {
    if ([uid isEqualToString:@"0"]) {
        [self log:[@"Active speaker: Self" UTF8String]];
    } else {
        NSDictionary *dic = [self.engine getUserInfo:uid];
        NSString *name = dic[@"displayName"];
        MyLog(@"Active speaker: %@",name);
    }
}

void CTutorialDlg::OnAudioVolumeCallback(const AliEngineUserVolumeInfo* volumeInfo, int volumeInfoCount, int totalVolume)
{
	CArray<AliEngineUserVolumeInfo*>* pArray = new CArray<AliEngineUserVolumeInfo*>;
	for (int i = 0; i < volumeInfoCount; i++)
	{
		AliEngineUserVolumeInfo* p = new AliEngineUserVolumeInfo;
		p->uid = volumeInfo[i].uid;
		p->volume = volumeInfo[i].volume;
		p->speechState = volumeInfo[i].speechState;
		p->sumVolume = volumeInfo[i].sumVolume;
		pArray->Add(p);
	}
    /* Notify the UI to refresh */
	PostMessage(MM_VOLUME_CALLBACK, (WPARAM)totalVolume, (LPARAM)pArray);
}

void CTutorialDlg::OnActiveSpeaker(const char *uid)
{
	m_strCurSpeaker = CString(uid);
    /* Notify the UI to refresh  */
	PostMessage(MM_ACTIVE_SPEAKER, NULL, NULL);
}