ZoomSDKAudioRawDataHelper.java

Go to the documentation of this file.

package us.zoom.sdk;
 
import java.lang.ref.WeakReference;
import java.nio.ByteBuffer;
 
import us.zoom.common.crossplatform.cmmlib.BuildConfig;
import us.zoom.core.helper.ZMLog;
import us.zoom.internal.ErrorCodeMapping;
import us.zoom.internal.RTCConference;
import us.zoom.internal.event.RTCConferenceEventUI;
import us.zoom.internal.event.RTCVideoRawDataDelegate;
import us.zoom.internal.helper.SDKMeetingInterfaceHelper;
import us.zoom.internal.impl.ZoomSDKAudioRawDataSender;
import us.zoom.internal.jni.helper.ZoomMeetingSDKBridgeHelper;
import us.zoom.internal.sdkcore.delegate.jni.MSDKCoreMeetingServiceHelperDelegateJNI;

public class ZoomSDKAudioRawDataHelper implements IZoomSDKAudioRawDataHelper {
 
    private static final String TAG = "ZoomSDKAudioRawDataHelper";
 
    private static class AudioSlot {
        WeakReference<IZoomSDKAudioRawDataDelegate> weakReference;
        RTCConferenceEventUI receiver;
        RTCConferenceEventUI.SimpleRTCConferenceEventUIListener listener;
        ZoomSDKSessionSource source;
    }
 
    private final AudioSlot currentSlot = new AudioSlot();
    private final AudioSlot mainSlot = new AudioSlot();
    private boolean meetingListenerRegistered;
 
    private IZoomSDKVirtualAudioMicEvent virtualAudioMic;
 
    private RTCVideoRawDataDelegate rtcAudioRawDataDelegate;
 
    MSDKCoreMeetingServiceHelperDelegateJNI.SimpleMSDKCoreMeetingServiceHelperDelegate mMSDKCoreMeetingServiceListener =
            new MSDKCoreMeetingServiceHelperDelegateJNI.SimpleMSDKCoreMeetingServiceHelperDelegate() {
        @Override
        public void onCoreConfLeaveComplete(int ret) {
            onConfLeave();
        }
 
        @Override
        public void onMeetingSilentModeChanged(int ret) {
            if (SDKMeetingInterfaceHelper.isInSlientMode()) {
                unSubscribe(ZoomSDKSessionSource.SessionSource_CurrentSession);
                unSubscribe(ZoomSDKSessionSource.SessionSource_MainSession);
            }
        }
    };
 
    private final MeetingServiceListener meetingStatusListener = new MeetingServiceListener() {
        @Override
        public void onMeetingStatusChanged(MeetingStatus meetingStatus, int errorCode, int internalErrorCode) {
            if (meetingStatus == MeetingStatus.MEETING_STATUS_JOIN_BACKSTAGE) {
                rebindCurrentSession();
            } else if (meetingStatus == MeetingStatus.MEETING_STATUS_LEAVE_BACKSTAGE) {
                unSubscribe(ZoomSDKSessionSource.SessionSource_MainSession);
                rebindCurrentSession();
            }
        }
 
        @Override
        public void onMeetingParameterNotification(MeetingParameter meetingParameter) {
        }
    };
 
    private void onConfLeave() {
        unSubscribe(ZoomSDKSessionSource.SessionSource_CurrentSession);
        unSubscribe(ZoomSDKSessionSource.SessionSource_MainSession);
        MSDKCoreMeetingServiceHelperDelegateJNI.getInstance().removeListener(mMSDKCoreMeetingServiceListener);
        MeetingService meetingService = ZoomSDK.getInstance().getMeetingService();
        if (meetingService != null) {
            meetingService.removeListener(meetingStatusListener);
        }
        meetingListenerRegistered = false;
        virtualAudioMic=null;
    }
 
    RTCVideoRawDataDelegate.SimpleRTCVideoRawDataListener audioRawdataListener = new RTCVideoRawDataDelegate.SimpleRTCVideoRawDataListener() {
 
        public void onUninitialize() {
            if (null != virtualAudioMic) {
                virtualAudioMic.onMicUninitialized();
            }
        }
 
        public void onDeviceInitialize(long nativeHandle) {
            if (null != virtualAudioMic) {
                IZoomSDKAudioRawDataSender sender = new ZoomSDKAudioRawDataSender(nativeHandle);
                virtualAudioMic.onMicInitialize(sender);
            }
        }
 
        public void onStartSendData() {
            if (null != virtualAudioMic) {
                virtualAudioMic.onMicStartSend();
            }
        }
 
        public void onStopSendData() {
            if (null != virtualAudioMic) {
                virtualAudioMic.onMicStopSend();
            }
        }
 
        public void onDeviceUninitialize() {
            if (null != virtualAudioMic) {
                virtualAudioMic.onMicUninitialized();
            }
        }
    };
 
    public ZoomSDKAudioRawDataHelper() {
        currentSlot.source = ZoomSDKSessionSource.SessionSource_CurrentSession;
        mainSlot.source = ZoomSDKSessionSource.SessionSource_MainSession;
    }
 
    @Override
    public MobileRTCRawDataError subscribe(IZoomSDKAudioRawDataDelegate delegate) {
        return subscribe(delegate, ZoomSDKSessionSource.SessionSource_CurrentSession);
    }
 
    @Override
    public MobileRTCRawDataError subscribe(IZoomSDKAudioRawDataDelegate delegate, ZoomSDKSessionSource sources) {
        if (SDKMeetingInterfaceHelper.isInSlientMode()) {
            return MobileRTCRawDataError.MobileRTCRawData_WrongUsage;
        }
        if (null == delegate || !isValidSource(sources)) {
            return MobileRTCRawDataError.MobileRTCRawData_WrongUsage;
        }
        if (sources == ZoomSDKSessionSource.SessionSource_MainSession && !isLocalInWebinarBackstage()) {
            return MobileRTCRawDataError.MobileRTCRawData_WrongUsage;
        }
        AudioSlot slot = getSlot(sources);
        if (slot == null || slot.weakReference != null) {
            return MobileRTCRawDataError.MobileRTCRawData_WrongUsage;
        }
        if (isDelegateInUse(delegate)) {
            return MobileRTCRawDataError.MobileRTCRawData_WrongUsage;
        }
        if (null == RTCConference.getInstance()) {
            return MobileRTCRawDataError.MobileRTCRawData_Uninitialized;
        }
 
        ensureMeetingListener();
        slot.receiver = RTCConferenceEventUI.createIndependentReceiver();
        slot.listener = createSlotListener(slot);
        slot.receiver.addListener(slot.listener);
        slot.weakReference = new WeakReference<>(delegate);
        int ret = RTCConference.getInstance().getAudioRawDataHelper().start(
                slot.receiver.getNativeHandle(), sources.getValue());
        MobileRTCRawDataError error= ErrorCodeMapping.mapping(ret);
        if (error != MobileRTCRawDataError.MobileRTCRawData_Success) {
            slot.receiver.removeListener(slot.listener);
            slot.receiver = null;
            slot.listener = null;
            slot.weakReference = null;
        }
        ZoomMeetingSDKBridgeHelper.getInstance().trackingMSDKInteractEvent(TAG, "subscribe", error.ordinal());
        return error;
    }
 
    @Override
    public MobileRTCRawDataError unSubscribe() {
        return unSubscribe(ZoomSDKSessionSource.SessionSource_CurrentSession);
    }
 
    @Override
    public MobileRTCRawDataError unSubscribe(ZoomSDKSessionSource sources) {
        if (!isValidSource(sources)) {
            return MobileRTCRawDataError.MobileRTCRawData_WrongUsage;
        }
        if (null == RTCConference.getInstance()) {
            return MobileRTCRawDataError.MobileRTCRawData_Uninitialized;
        }
        AudioSlot slot = getSlot(sources);
        if (slot == null) {
            return MobileRTCRawDataError.MobileRTCRawData_WrongUsage;
        }
        if (slot.receiver != null && slot.listener != null) {
            slot.receiver.removeListener(slot.listener);
        }
        slot.weakReference = null;
        slot.listener = null;
        slot.receiver = null;
        int ret = RTCConference.getInstance().getAudioRawDataHelper().stop(sources.getValue());
        MobileRTCRawDataError error= ErrorCodeMapping.mapping(ret);
        ZoomMeetingSDKBridgeHelper.getInstance().trackingMSDKInteractEvent(TAG, "unSubscribe", error.ordinal());
        return error;
    }
 
    @Override
    public MobileRTCRawDataError setExternalAudioSource(IZoomSDKVirtualAudioMicEvent audioMic) {
        if (null == RTCConference.getInstance()) {
            return MobileRTCRawDataError.MobileRTCRawData_Uninitialized;
        }
 
        if (SDKMeetingInterfaceHelper.isInSlientMode()) {
            return MobileRTCRawDataError.MobileRTCRawData_WrongUsage;
        }
        if (this.virtualAudioMic == audioMic) {
            return MobileRTCRawDataError.MobileRTCRawData_Invalid_Param;
        }
        this.virtualAudioMic = audioMic;
 
        int result = 0;
        if (null == audioMic) {
            result = RTCConference.getInstance().getAudioRawDataHelper().setVirtualAudioMic(0);
            rtcAudioRawDataDelegate = null;
        } else {
            rtcAudioRawDataDelegate = new RTCVideoRawDataDelegate(audioRawdataListener);
            result = RTCConference.getInstance().getAudioRawDataHelper().setVirtualAudioMic(rtcAudioRawDataDelegate.getRecevHandle());
        }
        if (result != 0) {
            this.virtualAudioMic = null;
        }
        MobileRTCRawDataError error= ErrorCodeMapping.mapping(result);
        ZoomMeetingSDKBridgeHelper.getInstance().trackingMSDKInteractEvent(TAG, "setExternalAudioSource", error.ordinal());
        return error;
    }
 
    private boolean isValidSource(ZoomSDKSessionSource sources) {
        return sources == ZoomSDKSessionSource.SessionSource_CurrentSession
                || sources == ZoomSDKSessionSource.SessionSource_MainSession;
    }
 
    private boolean isLocalInWebinarBackstage() {
        InMeetingService inMeetingService = ZoomSDK.getInstance().getInMeetingService();
        return inMeetingService != null
                && inMeetingService.getMeetingType() == MeetingType.MEETING_TYPE_BACKSTAGE;
    }
 
    private AudioSlot getSlot(ZoomSDKSessionSource sources) {
        if (sources == ZoomSDKSessionSource.SessionSource_CurrentSession) {
            return currentSlot;
        }
        if (sources == ZoomSDKSessionSource.SessionSource_MainSession) {
            return mainSlot;
        }
        return null;
    }
 
    private boolean isDelegateInUse(IZoomSDKAudioRawDataDelegate delegate) {
        IZoomSDKAudioRawDataDelegate current = currentSlot.weakReference != null ? currentSlot.weakReference.get() : null;
        IZoomSDKAudioRawDataDelegate main = mainSlot.weakReference != null ? mainSlot.weakReference.get() : null;
        return delegate == current || delegate == main;
    }
 
    private void ensureMeetingListener() {
        if (meetingListenerRegistered) {
            return;
        }
        MeetingService meetingService = ZoomSDK.getInstance().getMeetingService();
        if (meetingService != null) {
            meetingService.addListener(meetingStatusListener);
            meetingListenerRegistered = true;
        }
        MSDKCoreMeetingServiceHelperDelegateJNI.getInstance().addListener(mMSDKCoreMeetingServiceListener);
    }
 
    private void rebindCurrentSession() {
        if (currentSlot.weakReference == null || currentSlot.receiver == null) {
            return;
        }
        IZoomSDKAudioRawDataDelegate delegate = currentSlot.weakReference.get();
        if (delegate == null || RTCConference.getInstance() == null) {
            return;
        }
        RTCConference.getInstance().getAudioRawDataHelper().stop(
                ZoomSDKSessionSource.SessionSource_CurrentSession.getValue());
        RTCConference.getInstance().getAudioRawDataHelper().start(
                currentSlot.receiver.getNativeHandle(),
                ZoomSDKSessionSource.SessionSource_CurrentSession.getValue());
    }
 
    private RTCConferenceEventUI.SimpleRTCConferenceEventUIListener createSlotListener(final AudioSlot slot) {
        return new RTCConferenceEventUI.SimpleRTCConferenceEventUIListener() {
            @Override
            public void onMixedAudioRawDataReceived(ByteBuffer buffer, int bufferLen, int sampleRate,int channel,long timeStamp, long nativeHandle) {
                dispatchMixed(slot, buffer, bufferLen, sampleRate, channel, timeStamp, nativeHandle);
            }
 
            @Override
            public void onOneWayAudioRawDataReceivedImpl(ByteBuffer buffer, int bufferLen, int sampleRate, int channel, int userId,long timeStamp, long nativeHandle) {
                dispatchOneWay(slot, buffer, bufferLen, sampleRate, channel, userId, timeStamp, nativeHandle);
            }
 
            @Override
            public void onShareAudioRawDataReceived(ByteBuffer buffer, int bufferLen, int sampleRate, int channel,long timeStamp, long userId, long nativeHandle) {
                dispatchShare(slot, buffer, bufferLen, sampleRate, channel, timeStamp, userId, nativeHandle);
            }
        };
    }
 
    private void dispatchMixed(AudioSlot slot, ByteBuffer buffer, int bufferLen, int sampleRate, int channel, long timeStamp, long nativeHandle) {
        if (null == slot.weakReference) {
            return;
        }
        IZoomSDKAudioRawDataDelegate dataDelegate = slot.weakReference.get();
        if (null != dataDelegate) {
            ZoomSDKAudioRawData rawData = new ZoomSDKAudioRawData(buffer, bufferLen, sampleRate,channel,timeStamp, nativeHandle);
            dataDelegate.onMixedAudioRawDataReceived(rawData);
        } else if (BuildConfig.LOG_ENABLE) {
            ZMLog.d(TAG, "onMixedAudioRawDataReceived dataDelegate is null");
        }
    }
 
    private void dispatchOneWay(AudioSlot slot, ByteBuffer buffer, int bufferLen, int sampleRate, int channel, int userId, long timeStamp, long nativeHandle) {
        if (null == slot.weakReference) {
            return;
        }
        IZoomSDKAudioRawDataDelegate dataDelegate = slot.weakReference.get();
        if (null != dataDelegate) {
            ZoomSDKAudioRawData rawData = new ZoomSDKAudioRawData(buffer, bufferLen, sampleRate,channel,timeStamp,nativeHandle);
            dataDelegate.onOneWayAudioRawDataReceived(rawData, userId);
        } else if (BuildConfig.LOG_ENABLE) {
            ZMLog.d(TAG, "onOneWayAudioRawDataReceivedImpl dataDelegate is null");
        }
    }
 
    private void dispatchShare(AudioSlot slot, ByteBuffer buffer, int bufferLen, int sampleRate, int channel, long timeStamp, long userId, long nativeHandle) {
        if (null == slot.weakReference) {
            return;
        }
        IZoomSDKAudioRawDataDelegate dataDelegate = slot.weakReference.get();
        if (null != dataDelegate) {
            ZoomSDKAudioRawData rawData = new ZoomSDKAudioRawData(buffer, bufferLen, sampleRate,channel,timeStamp, nativeHandle);
            dataDelegate.onShareAudioRawDataReceived(rawData, userId);
        } else if (BuildConfig.LOG_ENABLE) {
            ZMLog.d(TAG, "onShareAudioRawDataReceived dataDelegate is null");
        }
    }
}