Upgrade guide 3.0.0+

ZegoExpressEngine.getEngine().setDebugVerbose(true, ZegoLanguage.ENGLISH);

[[ZegoExpressEngine sharedEngine] setDebugVerbose:YES language:ZegoLanguageEnglish];

ZegoExpressSDK::getEngine()->setDebugVerbose(true, ZEGO_LANGUAGE_ENGLISH);

ZegoExpressEngine.shared().setDebugVerbose(true, language: .english)

// Note: Do not enable this feature in the online version. Use it only during the development phase.
// Note: Do not enable this feature in the online version. Use it only during the development phase."
ZegoExpressEngine.getEngine().enableDebugAssistant(true);

// Note: Do not enable this feature in the online version. Use it only during the development phase.
// Note: Do not enable this feature in the online version. Use it only during the development phase."
[[ZegoExpressEngine sharedEngine] enableDebugAssistant:YES];

// Note: Do not enable this feature in the online version. Use it only during the development phase.
// Note: Do not enable this feature in the online version. Use it only during the development phase."
ZegoExpressSDK::getEngine()->enableDebugAssistant(true);

// Note: Do not enable this feature in the online version. Use it only during the development phase.
// Note: Do not enable this feature in the online version. Use it only during the development phase."
ZegoExpressEngine.shared().enableDebugAssistant(true);

ZegoExpressEngine.createEngine(profile, null);

ZegoUser user = new ZegoUser("user1");
ZegoExpressEngine.getEngine().loginRoom("first_room", user);
ZegoExpressEngine.getEngine().loginMultiRoom("second_room", null);

[ZegoExpressEngine createEngineWithProfile:profile eventHandler:nil];

ZegoUser *user = [ZegoUser userWithUserID:@"user1"];
[[ZegoExpressEngine sharedEngine] loginRoom:@"first_room" user:user];
[[ZegoExpressEngine sharedEngine] loginMultiRoom:@"second_room" config:nil];

ZegoExpressSDK::createEngine(profile, nullptr);

auto user = ZegoUser("user1", "user1");
ZegoExpressSDK::getEngine()->loginRoom("first_room", user);
ZegoExpressSDK::getEngine()->loginMultiRoom("second_room");

ZegoExpressEngine.createEngine(with: profile, eventHandler: nil)

let user = ZegoUser(userID: "user1")
ZegoExpressEngine.shared().loginRoom("first_room", user: user)
ZegoExpressEngine.shared().loginMultiRoom("second_room", config: nil)

// It must be set before [`createEngine`] is called to take effect. Otherwise, it will fail.
// It must be set before [`createEngine`] is called to take effect. Otherwise, it will fail.
ZegoExpressEngine.setRoomMode(ZegoRoomMode.MULTI_ROOM);

ZegoExpressEngine.createEngine(profile, null);

ZegoUser user = new ZegoUser("user1");
ZegoExpressEngine.getEngine().loginRoom("first_room", user);
ZegoExpressEngine.getEngine().loginRoom("second_room", user);

// It must be set before [`createEngine`] is called to take effect. Otherwise, it will fail.
// It must be set before [`createEngine`] is called to take effect. Otherwise, it will fail.
[ZegoExpressEngine setRoomMode:ZegoRoomModeMultiRoom];

[ZegoExpressEngine createEngineWithProfile:profile eventHandler:nil];

ZegoUser *user = [ZegoUser userWithUserID:@"user1"];
[[ZegoExpressEngine sharedEngine] loginRoom:@"first_room" user:user];
[[ZegoExpressEngine sharedEngine] loginRoom:@"second_room" user:user];

// It must be set before [`createEngine`] is called to take effect. Otherwise, it will fail.
// It must be set before [`createEngine`] is called to take effect. Otherwise, it will fail.
ZegoExpressSDK::setRoomMode(ZEGO_ROOM_MODE_MULTI_ROOM);

ZegoExpressSDK::createEngine(profile, nullptr);

auto user = ZegoUser("user1", "user1");
ZegoExpressSDK::getEngine()->loginRoom("first_room", user);
ZegoExpressSDK::getEngine()->loginRoom("second_room", user);

// It must be set before [`createEngine`] is called to take effect. Otherwise, it will fail.
// It must be set before [`createEngine`] is called to take effect. Otherwise, it will fail.
ZegoExpressEngine.setRoomMode(.multiRoom)

ZegoExpressEngine.createEngine(with: profile, eventHandler: nil)

let user = ZegoUser(userID: "user1")
ZegoExpressEngine.shared().loginRoom("first_room", user: user)
ZegoExpressEngine.shared().loginRoom("second_room", user: user)

ZegoExpressEngine.getEngine().setPlayStreamVideoLayer("stream1", ZegoPlayerVideoLayer.AUTO);

[[ZegoExpressEngine sharedEngine] setPlayStreamVideoLayer:ZegoPlayerVideoLayerAuto streamID:@"stream1"];

ZegoExpressSDK::getEngine()->setPlayStreamVideoLayer("stream1", ZEGO_PLAYER_VIDEO_LAYER_AUTO);

ZegoExpressEngine.shared().setPlayStreamVideoLayer(.auto, streamID: "stream1")

ZegoExpressEngine.getEngine().setPlayStreamVideoType("stream1", ZegoVideoStreamType.DEFAULT);

[[ZegoExpressEngine sharedEngine] setPlayStreamVideoType:ZegoVideoStreamTypeDefault streamID:@"stream1"];

ZegoExpressSDK::getEngine()->setPlayStreamVideoType("stream1", ZEGO_VIDEO_STREAM_TYPE_DEFAULT);

ZegoExpressEngine.shared().setPlayStreamVideoType(.default, streamID: "stream1")

int bitmask = ZegoAudioDataCallbackBitMask.CAPTURED.value() | ZegoAudioDataCallbackBitMask.PLAYER.value();
ZegoAudioFrameParam param = new ZegoAudioFrameParam();
param.sampleRate = ZegoAudioSampleRate.ZEGO_AUDIO_SAMPLE_RATE_48K;
param.channel = ZegoAudioChannel.MONO;

// Start
ZegoExpressEngine.getEngine().setAudioDataHandler(handler);
ZegoExpressEngine.getEngine().enableAudioDataCallback(true, bitmask, param);

// Stop
ZegoExpressEngine.getEngine().setAudioDataHandler(null);
ZegoExpressEngine.getEngine().enableAudioDataCallback(false, bitmask, param);

int bitmask = ZegoAudioDataCallbackBitMaskCaptured | ZegoAudioDataCallbackBitMaskPlayer;
ZegoAudioFrameParam *param = [[ZegoAudioFrameParam alloc] init];
param.sampleRate = ZegoAudioSampleRate48K;
param.channel = ZegoAudioChannelMono;

// Start
[[ZegoExpressEngine sharedEngine] setAudioDataHandler:self];
[[ZegoExpressEngine sharedEngine] enableAudioDataCallback:YES callbackBitMask:bitmask param:param];

// Stop
[[ZegoExpressEngine sharedEngine] setAudioDataHandler:nil];
[[ZegoExpressEngine sharedEngine] enableAudioDataCallback:NO callbackBitMask:bitmask param:param];

auto bitmask = ZEGO_AUDIO_DATA_CALLBACK_BIT_MASK_CAPTURED | ZEGO_AUDIO_DATA_CALLBACK_BIT_MASK_PLAYER;
auto param = ZegoAudioFrameParam();
param.sampleRate = ZEGO_AUDIO_SAMPLE_RATE_48K;
param.channel = ZEGO_AUDIO_CHANNEL_MONO;

// Start
ZegoExpressSDK::getEngine()->setAudioDataHandler(handler);
ZegoExpressSDK::getEngine()->enableAudioDataCallback(true, bitmask, param);

// Stop
ZegoExpressSDK::getEngine()->setAudioDataHandler(nullptr);
ZegoExpressSDK::getEngine()->enableAudioDataCallback(false, bitmask, param);

let param = ZegoAudioFrameParam()
param.sampleRate = .rate48K
param.channel = .mono

// Start
ZegoExpressEngine.shared().setAudioDataHandler(self)
ZegoExpressEngine.shared().enableAudioDataCallback(true, callbackBitMask: [.captured, .player], param: param)

// Stop
ZegoExpressEngine.shared().setAudioDataHandler(nil)
ZegoExpressEngine.shared().enableAudioDataCallback(false, callbackBitMask: [.captured, .player], param: param)

int bitmask = ZegoAudioDataCallbackBitMask.CAPTURED.value() | ZegoAudioDataCallbackBitMask.PLAYER.value();
ZegoAudioFrameParam param = new ZegoAudioFrameParam();
param.sampleRate = ZegoAudioSampleRate.ZEGO_AUDIO_SAMPLE_RATE_48K;
param.channel = ZegoAudioChannel.MONO;

// Start
ZegoExpressEngine.getEngine().setAudioDataHandler(handler);
ZegoExpressEngine.getEngine().startAudioDataObserver(bitmask, param);

// Stop
ZegoExpressEngine.getEngine().setAudioDataHandler(null);
ZegoExpressEngine.getEngine().stopAudioDataObserver();

int bitmask = ZegoAudioDataCallbackBitMaskCaptured | ZegoAudioDataCallbackBitMaskPlayer;
ZegoAudioFrameParam *param = [[ZegoAudioFrameParam alloc] init];
param.sampleRate = ZegoAudioSampleRate48K;
param.channel = ZegoAudioChannelMono;

// Start
[[ZegoExpressEngine sharedEngine] setAudioDataHandler:self];
[[ZegoExpressEngine sharedEngine] startAudioDataObserver:bitmask param:param];

// Stop
[[ZegoExpressEngine sharedEngine] setAudioDataHandler:nil];
[[ZegoExpressEngine sharedEngine] stopAudioDataObserver];

auto bitmask = ZEGO_AUDIO_DATA_CALLBACK_BIT_MASK_CAPTURED | ZEGO_AUDIO_DATA_CALLBACK_BIT_MASK_PLAYER;
auto param = ZegoAudioFrameParam();
param.sampleRate = ZEGO_AUDIO_SAMPLE_RATE_48K;
param.channel = ZEGO_AUDIO_CHANNEL_MONO;

// Start
ZegoExpressSDK::getEngine()->setAudioDataHandler(handler);
ZegoExpressSDK::getEngine()->startAudioDataObserver(bitmask, param);

// Stop
ZegoExpressSDK::getEngine()->setAudioDataHandler(nullptr);
ZegoExpressSDK::getEngine()->stopAudioDataObserver();

let param = ZegoAudioFrameParam()
param.sampleRate = .rate48K
param.channel = .mono

// Start
ZegoExpressEngine.shared().setAudioDataHandler(self)
ZegoExpressEngine.shared().startAudioDataObserver([.captured, .player], param: param)

// Stop
ZegoExpressEngine.shared().setAudioDataHandler(nil)
ZegoExpressEngine.shared().stopAudioDataObserver()

ZegoReverbParam param = new ZegoReverbParam(ZegoReverbPreset.BASEMENT);
ZegoExpressEngine.getEngine().setReverbParam(param);

ZegoReverbParam *param = [ZegoReverbParam paramWithPreset:ZegoReverbPresetBasement];
[[ZegoExpressEngine sharedEngine] setReverbParam:param];

auto param = ZegoReverbParam(ZEGO_REVERB_PRESET_BASEMENT);
ZegoExpressSDK::getEngine()->setReverbParam(param);

let param = ZegoReverbParam(preset: .basement)
ZegoExpressEngine.shared().setReverbParam(param)

ZegoExpressEngine.getEngine().setReverbPreset(ZegoReverbPreset.BASEMENT);

ZegoReverbAdvancedParam param = new ZegoReverbAdvancedParam();
ZegoExpressEngine.getEngine().setReverbAdvancedParam(param);

[[ZegoExpressEngine sharedEngine] setReverbPreset:ZegoReverbPresetBasement];

ZegoReverbAdvancedParam *param = [[ZegoReverbAdvancedParam alloc] init];
[[ZegoExpressEngine sharedEngine] setReverbAdvancedParam:param];

ZegoExpressSDK::getEngine()->setReverbPreset(ZEGO_REVERB_PRESET_BASEMENT);

auto param = ZegoReverbAdvancedParam();
ZegoExpressSDK::getEngine()->setReverbAdvancedParam(param);

ZegoExpressEngine.shared().setReverbPreset(.basement)

let param = ZegoReverbAdvancedParam()
ZegoExpressEngine.shared().setReverbAdvancedParam(param)

ZegoExpressEngine.getEngine().setBuiltInSpeakerOn(true);

[[ZegoExpressEngine sharedEngine] setBuiltInSpeakerOn:YES];

ZegoExpressSDK::getEngine()->setBuiltInSpeakerOn(true);

ZegoExpressEngine.shared().setBuiltInSpeakerOn(true)

ZegoExpressEngine.getEngine().setAudioRouteToSpeaker(true);

[[ZegoExpressEngine sharedEngine] setAudioRouteToSpeaker:YES];

ZegoExpressSDK::getEngine()->setAudioRouteToSpeaker(true);

ZegoExpressEngine.shared().setAudioRouteToSpeaker(true)

@Override
public void onRoomStreamUpdate(String roomID, ZegoUpdateType updateType, ArrayList<ZegoStream> streamList) {
    super.onRoomStreamUpdate(roomID, updateType, streamList);
    // Handle room streams
    // Handling flow changes in the room
}

- (void)onRoomStreamUpdate:(ZegoUpdateType)updateType streamList:(NSArray<ZegoStream *> *)streamList roomID:(NSString *)roomID {
    // Handle room streams
    // Handling flow changes in the room
}

// Handle room streams
// Handling flow changes in the room
void onRoomStreamUpdate(const std::string& roomID, ZegoUpdateType updateType, const std::vector<ZegoStream>& streamList) override;

func onRoomStreamUpdate(_ updateType: ZegoUpdateType, streamList: [ZegoStream], roomID: String) {
    // Handle room streams
    // Handling flow changes in the room
}

@Override
public void onRoomStreamUpdate(String roomID, ZegoUpdateType updateType, ArrayList<ZegoStream> streamList, JSONObject extendedData) {
    super.onRoomStreamUpdate(roomID, updateType, streamList, extendedData);
    // Handle room streams
    // Handling flow changes in the room
}

- (void)onRoomStreamUpdate:(ZegoUpdateType)updateType streamList:(NSArray<ZegoStream *> *)streamList extendedData:(NSDictionary *)extendedData roomID:(NSString *)roomID {
    // Handle room streams
    // Handling flow changes in the room
}

// Handle room streams
// Handling flow changes in the room
void onRoomStreamUpdate(const std::string& roomID, ZegoUpdateType updateType, const std::vector<ZegoStream>& streamList, const std::string& extendData) override;

func onRoomStreamUpdate(_ updateType: ZegoUpdateType, streamList: [ZegoStream], extendedData: [AnyHashable : Any]?, roomID: String) {
    // Handle room streams
    // Handling flow changes in the room
}

@Override
public void onDeviceError(int errorCode, String deviceName) {
    super.onDeviceError(errorCode, deviceName);
    // Handle device error
    // Handling device errors
}

- (void)onDeviceError:(int)errorCode deviceName:(NSString *)deviceName {
    // Handle device error
    // Handling device errors
}

// Handle device error
// Handling device errors
void onDeviceError(int errorCode, const std::string& deviceName) override;

func onDeviceError(_ errorCode: Int32, deviceName: String) {
    // Handle device error
    // Handling device errors
}

@Override
public void onLocalDeviceExceptionOccurred(ZegoDeviceExceptionType exceptionType, ZegoDeviceType deviceType, String deviceID) {
    super.onLocalDeviceExceptionOccurred(exceptionType, deviceType, deviceID);
    // Handle device error
    // Handling device errors
}

- (void)onLocalDeviceExceptionOccurred:(ZegoDeviceExceptionType)exceptionType deviceType:(ZegoDeviceType)deviceType deviceID:(NSString *)deviceID {
    // Handle device error
    // Handling device errors
}

// Handle device error
// Handling device errors
void onLocalDeviceExceptionOccurred(ZegoDeviceExceptionType exceptionType, ZegoDeviceType deviceType, const std::string &deviceID) override;

func onLocalDeviceExceptionOccurred(_ exceptionType: ZegoDeviceExceptionType, deviceType: ZegoDeviceType, deviceID: String) {
    // Handle device error
    // Handling device errors
}

@Override
public void onNetworkQuality(String streamID, int txQuality, int rxQuality) {
    super.onNetworkQuality(streamID, txQuality, rxQuality);
    // Handle network quality
    // Handling network quality
}

- (void)onNetworkQuality:(NSString *)streamID txQuality:(int)txQuality rxQuality:(int)rxQuality {
    // Handle network quality
    // Handling network quality
}

// Handle network quality
// Handling network quality
void onNetworkQuality(const char *streamID, int txQuality, int rxQuality) override;

func onNetworkQuality(_ streamID: String, txQuality: Int32, rxQuality: Int32) {
    // Handle network quality
    // Handling network quality
}

@Override
public void onNetworkQuality(String userID, ZegoStreamQualityLevel upstreamQuality, ZegoStreamQualityLevel downstreamQuality) {
    super.onNetworkQuality(userID, upstreamQuality, downstreamQuality);
    // Handle network quality
    // Handling network quality
}

- (void)onNetworkQuality:(NSString *)userID upstreamQuality:(ZegoStreamQualityLevel)upstreamQuality downstreamQuality:(ZegoStreamQualityLevel)downstreamQuality {
    // Handle network quality
    // Handling network quality
}

// Handle network quality
// Handling network quality
void onNetworkQuality(const std::string &userID, ZegoStreamQualityLevel upstreamQuality, ZegoStreamQualityLevel downstreamQuality) override;

func onNetworkQuality(_ userID: String, upstreamQuality: ZegoStreamQualityLevel, downstreamQuality: ZegoStreamQualityLevel) {
    // Handle network quality
    // Handling network quality
}

ZegoExpressEngine.getEngine().setCustomAudioProcessHandler(new IZegoCustomAudioProcessHandler() {
    @Override
    public void onProcessCapturedAudioData(ByteBuffer data, int dataLength, ZegoAudioFrameParam param) {
        super.onProcessCapturedAudioData(data, dataLength, param);
        // Handle captured audio data
        // Handle locally captured audio data
    }

    @Override
    public void onProcessRemoteAudioData(ByteBuffer data, int dataLength, ZegoAudioFrameParam param, String streamID) {
        super.onProcessRemoteAudioData(data, dataLength, param, streamID);
        // Handle remote audio data
        // Handle remote audio play streams
    }

    @Override
    public void onProcessPlaybackAudioData(ByteBuffer data, int dataLength, ZegoAudioFrameParam param) {
        super.onProcessPlaybackAudioData(data, dataLength, param);
        // Handle playback audio data
        // Handle playback audio data
    }
});

- (void)onProcessCapturedAudioData:(unsigned char *)data dataLength:(unsigned int)dataLength param:(ZegoAudioFrameParam *)param {
    // Handle captured audio data
    // Handle locally captured audio data
}

- (void)onProcessRemoteAudioData:(unsigned char *)data dataLength:(unsigned int)dataLength param:(ZegoAudioFrameParam *)param streamID:(NSString *)streamID {
    // Handle remote audio data
    // Handle remote audio stream play
}

- (void)onProcessPlaybackAudioData:(unsigned char *)data dataLength:(unsigned int)dataLength param:(ZegoAudioFrameParam *)param {
    // Handle playback audio data
    // Handle playback audio data
}

// Handle captured audio data
// Handle locally captured audio data
void onProcessCapturedAudioData(unsigned char *data, unsigned int dataLength, ZegoAudioFrameParam *param) override;

// Handle remote audio data
// Handle remote audio stream play
void onProcessRemoteAudioData(unsigned char *data, unsigned int dataLength, ZegoAudioFrameParam *param, const std::string &streamID) override;

// Handle playback audio data
// Handle playback audio data
void onProcessPlaybackAudioData(unsigned char *data, unsigned int dataLength, ZegoAudioFrameParam *param) override;

func onProcessCapturedAudioData(_ data: UnsafeMutablePointer<UInt8>, dataLength: UInt32, param: ZegoAudioFrameParam) {
    // Handle captured audio data
    // Handle locally captured audio data
}

func onProcessRemoteAudioData(_ data: UnsafeMutablePointer<UInt8>, dataLength: UInt32, param: ZegoAudioFrameParam, streamID: String) {
    // Handle remote audio data
    // Handle remote audio stream play
}

func onProcessPlaybackAudioData(_ data: UnsafeMutablePointer<UInt8>, dataLength: UInt32, param: ZegoAudioFrameParam) {
    // Handle playback audio data
    // Handle playback audio data
}

ZegoExpressEngine.getEngine().setCustomAudioProcessHandler(new IZegoCustomAudioProcessHandler() {
    @Override
    public void onProcessCapturedAudioData(ByteBuffer data, int dataLength, ZegoAudioFrameParam param, double timestamp) {
        super.onProcessCapturedAudioData(data, dataLength, param, timestamp);
        // Handle captured audio data
        // Handle locally captured audio data
    }

    @Override
    public void onProcessRemoteAudioData(ByteBuffer data, int dataLength, ZegoAudioFrameParam param, String streamID, double timestamp) {
        super.onProcessRemoteAudioData(data, dataLength, param, streamID, timestamp);
        // Handle remote audio data
        // Handle remote audio stream play
    }

    @Override
    public void onProcessPlaybackAudioData(ByteBuffer data, int dataLength, ZegoAudioFrameParam param, double timestamp) {
        super.onProcessPlaybackAudioData(data, dataLength, param, timestamp);
        // Handle playback audio data
        // Handle playback audio data
    }
});

- (void)onProcessCapturedAudioData:(unsigned char *)data dataLength:(unsigned int)dataLength param:(ZegoAudioFrameParam *)param timestamp:(double)timestamp {
    // Handle captured audio data
    // Handle locally captured audio data
}

- (void)onProcessRemoteAudioData:(unsigned char *)data dataLength:(unsigned int)dataLength param:(ZegoAudioFrameParam *)param streamID:(NSString *)streamID timestamp:(double)timestamp {
    // Handle remote audio data
    // Handle remote audio stream play
}

- (void)onProcessPlaybackAudioData:(unsigned char *)data dataLength:(unsigned int)dataLength param:(ZegoAudioFrameParam *)param timestamp:(double)timestamp {
    // Handle playback audio data
    // Handle playback audio data
}

// Handle captured audio data
// Handle locally captured audio data
void onProcessCapturedAudioData(unsigned char *data, unsigned int dataLength, ZegoAudioFrameParam *param, double timestamp) override;

// Handle remote audio data
// Handle remote audio stream play
void onProcessRemoteAudioData(unsigned char *data, unsigned int dataLength, ZegoAudioFrameParam *param, const std::string &streamID, double timestamp) override;

// Handle playback audio data
// Handle playback audio data
void onProcessPlaybackAudioData(unsigned char *data, unsigned int dataLength, ZegoAudioFrameParam *param, double timestamp) override;

func onProcessCapturedAudioData(_ data: UnsafeMutablePointer<UInt8>, dataLength: UInt32, param: ZegoAudioFrameParam, timestamp: Double) {
    // Handle captured audio data
    // Handle locally captured audio data
}

func onProcessRemoteAudioData(_ data: UnsafeMutablePointer<UInt8>, dataLength: UInt32, param: ZegoAudioFrameParam, streamID: String, timestamp: Double) {
    // Handle remote audio data
    // Handle remote audio stream play
}

func onProcessRemoteAudioData(_ data: UnsafeMutablePointer<UInt8>, dataLength: UInt32, param: ZegoAudioFrameParam, streamID: String, timestamp: Double) {
    // Handle playback audio data
    // Handle playback audio data
}