MobileRTCVideoView.java

Go to the documentation of this file.

package us.zoom.sdk;
 
import android.app.Activity;
import android.content.Context;
import android.content.ContextWrapper;
import android.graphics.Rect;
import android.os.Build;
import android.os.Bundle;
import android.util.AttributeSet;
import android.util.Log;
import android.view.GestureDetector;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.widget.FrameLayout;
import android.widget.RelativeLayout;
 
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentActivity;
 
import com.zipow.videobox.mainboard.Mainboard;
import com.zipow.videobox.mainboard.ZmMainBoardMgr;
import com.zipow.videobox.mainboard.module.ZmSdkMainBoard;
import com.zipow.videobox.sdk.SDKConstants;
import com.zipow.videobox.sdk.SDKMainHandler;
import com.zipow.videobox.sdk.SDKShareInView;
import com.zipow.videobox.sdk.SDKVideoRenderer;
import com.zipow.videobox.sdk.SDKVideoView;
import com.zipow.videobox.utils.ZmUtils;
import com.zipow.videobox.view.video.VideoRenderer;
 
import javax.microedition.khronos.opengles.GL10;
 
import kotlin.Unit;
import kotlin.jvm.functions.Function1;
import us.zoom.business.common.ZmBusinessModuleMgr;
import us.zoom.common.crossplatform.cmmlib.BuildConfig;
import us.zoom.core.helper.ZMLog;
import us.zoom.internal.impl.InMeetingShareControllerImpl;
import us.zoom.docs.bridge.tocpp.IConfZoomDocs;
import us.zoom.docs.conf.cplusenum.WebViewInstanceTag;
import us.zoom.docs.service.StaticInnerService;
import us.zoom.docs.ui.share.ZoomDocsShareFragment;
import us.zoom.hybrid.safeweb.core.WebHelper;
import us.zoom.internal.impl.InMeetingWhiteboardControllerImpl;
import us.zoom.internal.jni.bean.CmmDocsCollaborationSource;
import us.zoom.internal.jni.helper.ZoomMeetingSDKBridgeHelper;
import us.zoom.internal.jni.helper.ZoomMeetingSDKDocsHelper;
import us.zoom.internal.view.SDKWBViewerFragment;
import us.zoom.libtools.fragmentmanager.ISafeTransaction;
import us.zoom.libtools.fragmentmanager.SafeTransactionKt;
import us.zoom.libtools.storage.PreferenceUtil;
import us.zoom.libtools.utils.ZmDeviceUtils;
import us.zoom.internal.SDKCustomizedMeetingUIHelper;
import us.zoom.internal.SDKDisclaimerDialogManager;
import us.zoom.internal.impl.MobileRTCVideoViewManagerImpl;
import us.zoom.libtools.utils.ZmStringUtils;
import us.zoom.unite.cplusenum.UnifyWebViewAppType;
import us.zoom.unite.logic.UniteBaseLogic;
import us.zoom.videomeetings.R;

public class MobileRTCVideoView extends RelativeLayout implements SDKVideoView.Listener, GestureDetector.OnGestureListener, GestureDetector.OnDoubleTapListener {
 
    private final static String TAG = MobileRTCVideoView.class.getSimpleName();
 
    @Nullable
    private Activity activity;
 
    @Nullable
    private MobileRTCVideoViewManagerImpl mVideoViewMgr;
    private MobileRTCVideoRender mVideoRender;
 
    private ViewGroup mView;
    private SDKVideoView mVideoView;
    private SDKShareInView mShareView;
    private GestureDetector mGestureDetector;
 
    @Nullable
    private FrameLayout mFragmentContainer;
 
    private InMeetingWhiteboardControllerImpl inMeetingWhiteboardController;
 
    public MobileRTCVideoView(Context context) {
        this(context, null);
    }
 
    public MobileRTCVideoView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init(context);
    }
 
    public MobileRTCVideoView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init(context);
    }
 
    private void init(Context context) {
        mView = (ViewGroup)LayoutInflater.from(context).inflate(R.layout.zm_videoview_sdk, null, false);
        mVideoView = (SDKVideoView) mView.findViewById(R.id.videoContainer);
        mShareView = (SDKShareInView)mView.findViewById(R.id.zm_sdk_viewingShare);
        mFragmentContainer = (FrameLayout) mView.findViewById(R.id.wbFragmentContainer);
        mGestureDetector = new GestureDetector(context, this);
        mGestureDetector.setOnDoubleTapListener(this);
        mGestureDetector.setIsLongpressEnabled(false);
        initVideoView(context);
        mVideoViewMgr = new MobileRTCVideoViewManagerImpl(this, mVideoRender, mShareView);
        InMeetingService inMeetingService = ZoomSDK.getInstance().getInMeetingService();
        if (inMeetingService != null) {
            InMeetingWhiteboardController wbController =  inMeetingService.getInMeetingWhiteboardController();
            if (wbController instanceof InMeetingWhiteboardControllerImpl) {
                inMeetingWhiteboardController = (InMeetingWhiteboardControllerImpl) wbController;
            }
        }
        this.addView(mView);
        initActivity(context);
    }
 
    private void initVideoView(Context context) {
        if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB)
            mVideoView.setPreserveEGLContextOnPause(true);
        mVideoRender = new MobileRTCVideoRender(mVideoView, mVideoView.hashCode());
        mVideoView.setRenderer(mVideoRender);
        mVideoView.setListener(this);
    }

    public void setGestureDetectorEnabled(boolean isEnabled) {
        if(!isInEditMode() && isEnabled) {
            mVideoView.setGestureDetector(mGestureDetector);
        } else {
            mVideoView.setGestureDetector(null);
        }
    }

    public void setZOrderMediaOverlay(boolean isMediaOverlay) {
        ZoomMeetingSDKBridgeHelper.getInstance().trackingMSDKInteractEvent(TAG, "setZOrderMediaOverlay", MobileRTCSDKError.SDKERR_SUCCESS.ordinal());
        mVideoView.setZOrderMediaOverlay(isMediaOverlay);
    }

    public void setZOrderOnTop(boolean onTop) {
        ZoomMeetingSDKBridgeHelper.getInstance().trackingMSDKInteractEvent(TAG, "setZOrderOnTop", MobileRTCSDKError.SDKERR_SUCCESS.ordinal());
        mVideoView.setZOrderOnTop(onTop);
    }

    public synchronized MobileRTCVideoViewManager getVideoViewManager() {
        if(!SDKCustomizedMeetingUIHelper.isSdkEnableCustomizedUI()|| !SDKCustomizedMeetingUIHelper.isSdkUsingCustomizedMeetingUI()) {
            return null;
        }
 
        Mainboard mainboard = ZmMainBoardMgr.getMainboard();
        if(mainboard != null && !((ZmSdkMainBoard)mainboard.getSdkMainBoard()).isSDKConfAppCreated()) {
            return null;
        }
 
        return mVideoViewMgr;
    }
 
    protected synchronized MobileRTCVideoViewManager getVideoViewMgr() {
        if(SDKCustomizedMeetingUIHelper.isSdkEnableCustomizedUI() && SDKCustomizedMeetingUIHelper.isSdkUsingCustomizedMeetingUI()) {
            return null;
        }
        Mainboard mainboard = ZmMainBoardMgr.getMainboard();
        if(mainboard != null && !((ZmSdkMainBoard)mainboard.getSdkMainBoard()).isSDKConfAppCreated()) {
            return null;
        }
 
        return mVideoViewMgr;
    }

    public void onPause() {
        mVideoView.onPause();
        mVideoRender.stopRequestRender();
    }

    public void onResume() {
        mVideoView.onResume();
        mVideoRender.requestRenderContinuously();
    }
 
    //=============================================================================
    // implements GestureDetector.OnGestureListener begin  
    @Override
    public boolean onDown(MotionEvent e) {
        return true;
    }
 
    @Override
    public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
                           float velocityY) {
        if(mVideoViewMgr != null) {
            mVideoViewMgr.onFling(e1, e2, velocityX, velocityY);
        }
        return true;
    }
 
    @Override
    public void onLongPress(MotionEvent e) {
    }
 
    @Override
    public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX,
                            float distanceY) {
        if(mVideoViewMgr != null) {
            mVideoViewMgr.onScroll(e1, e2, distanceX, distanceY);
        }
        return true;
    }
 
    @Override
    public void onShowPress(MotionEvent e) {
 
    }
 
    @Override
    public boolean onSingleTapUp(MotionEvent e) {
        return true;
    }
    //=============================================================================
 
    //=============================================================================
    // implements GestureDetector.OnDoubleTapListener begin
    @Override
    public boolean onDoubleTap(MotionEvent e) {
        if(mVideoViewMgr != null) {
            mVideoViewMgr.onDoubleTap(e);
        }
        return true;
    }
 
    @Override
    public boolean onDoubleTapEvent(MotionEvent e) {
        return true;
    }
 
    @Override
    public boolean onSingleTapConfirmed(MotionEvent e) {
        return true;
    }
 
    protected boolean isVisibleToUser() {
        if(!isShown()) {
            return false;
        }
 
        Rect rect = new Rect();
        if (getGlobalVisibleRect(rect)) {
            if (rect.width() * rect.height() >= getMeasuredWidth() * getMeasuredHeight()/2) {
                return true;
            }
        }
        return false;
    }
 
    @Override
    public void beforeGLContextDestroyed() {
        mVideoRender.beforeGLContextDestroyed();
    }
 
    @Override
    public void surfaceCreated() {
        Log.i(TAG, "surfaceCreated group index =" + mVideoRender.getGroupIndex());
    }
 
    @Override
    public void surfaceDestroyed() {
        Log.i(TAG, "surfaceDestroyed group index =" + mVideoRender.getGroupIndex());
        mVideoViewMgr.onDestroy();
        mVideoViewMgr.onSurfaceDestroyed();
    }
 
    public class MobileRTCVideoRender extends SDKVideoRenderer{
 
        private static final int RENDERER_FPS = 25;
        private static final int RENDERER_FPS_LOW_PERFORMANCE = 15;
 
        private int mGroupIndex;
 
        long lastIdleTaskTime = 0;
 
        public MobileRTCVideoRender(SDKVideoView glView, int groupIndex) {
            super(glView, groupIndex);
            mGroupIndex = groupIndex;
        }
 
        @Override
        public void onDrawFrame(GL10 gl, VideoRenderer renderer) {
            long curTime = System.currentTimeMillis();
            if(curTime < lastIdleTaskTime || curTime - lastIdleTaskTime > 500) {
                lastIdleTaskTime = curTime;
                SDKMainHandler.getInstance().post(new Runnable() {
                    @Override
                    public void run() {
                        mVideoViewMgr.onIdle(isVisibleToUser());
                    }
                });
            }
        }
 
        public float getProperFPS() {
            float fps = RENDERER_FPS;
            if(ZmDeviceUtils.getCPUKernalNumbers() < 2 && ZmDeviceUtils.getCPUKernelFrequency(0, ZmDeviceUtils.FLAG_MAX_FREQUENCY) < 1400000) {
                fps = RENDERER_FPS_LOW_PERFORMANCE;
            }
            return fps;
        }
 
        @Override
        protected void onGLSurfaceCreated() {
        }
 
        @Override
        protected void onGLSurfaceChanged(final int width, final int height) {
            Log.i(TAG, "onGLSurfaceChanged group index =" + mGroupIndex + ", width=" + width + ", height=" + height);
 
            if(!isInitialized()) {
                initialize();
            }
 
            SDKMainHandler.getInstance().post(new Runnable() {
                @Override
                public void run() {
                    mVideoViewMgr.onGLSurfaceChanged(width, height);
                }
            });
        }
 
        @Override
        protected void onGLSurfaceDestroyed() {
            //callback from glthread
            release(false);
 
            SDKMainHandler.getInstance().post(new Runnable() {
                @Override
                public void run() {
                    mVideoViewMgr.onSurfaceDestroyed();
                }
            });
        }
 
        public int getGroupIndex() {
            return mGroupIndex;
        }
    }
    private void initActivity(Context context){
        InMeetingService inMeetingService= ZoomSDK.getInstance().getInMeetingService();
        if(null!=inMeetingService){
            InMeetingShareController  shareController=  inMeetingService.getInMeetingShareController();
            if(null!=shareController&&shareController instanceof InMeetingShareControllerImpl){
                InMeetingShareControllerImpl  shareControllerImpl=(InMeetingShareControllerImpl)shareController;
                shareControllerImpl.setFragmentActivity(context);
            }
        }
    }
 
    @Override
    protected void onAttachedToWindow() {
        super.onAttachedToWindow();
        Context context = getContext();
        SDKDisclaimerDialogManager.getInstance().setDisclaimerDialogContext(context);
        initActivity(context);
        if (context instanceof Activity) {
            activity = (Activity) context;
            ZmUtils.detectGPUInfo((Activity) context);
        } else {
            if(context instanceof ContextWrapper){
                context=((ContextWrapper)context).getBaseContext();
                if (context instanceof Activity) {
                    activity = (Activity) context;
                    ZmUtils.detectGPUInfo((Activity) context);
                }
            }
        }
    }
 
    @Override
    protected void onDetachedFromWindow() {
        super.onDetachedFromWindow();
        activity = null;
    }
 
    private static final String WB_TAG = TAG + "Whiteboard";
 
    public MobileRTCSDKError addWhiteBoardFragment() {
        boolean enableWBInView = PreferenceUtil.readBooleanValue(SDKConstants.SDK_ENABLE_SWITCH_WB_WITH_NORMAL_SHARE, false);
        if (!enableWBInView) {
            if (BuildConfig.LOG_ENABLE) {
                ZMLog.e(TAG, "addWBFragment fail for not enable the feature");
            }
            ZoomMeetingSDKBridgeHelper.getInstance().trackingMSDKInteractEvent(TAG, "addWhiteBoardFragment", MobileRTCSDKError.SDKERR_WRONG_USAGE.ordinal());
            return MobileRTCSDKError.SDKERR_WRONG_USAGE;
        }
 
        if (mFragmentContainer == null) {
            if (BuildConfig.LOG_ENABLE) {
                ZMLog.e(TAG, "add WB Fragment fail for mFragmentContainer is null");
            }
            ZoomMeetingSDKBridgeHelper.getInstance().trackingMSDKInteractEvent(TAG, "addWhiteBoardFragment", MobileRTCSDKError.SDKERR_OTHER_ERROR.ordinal());
            return MobileRTCSDKError.SDKERR_OTHER_ERROR;
        }
 
        if (!(activity instanceof FragmentActivity)) {
            if (BuildConfig.LOG_ENABLE) {
                ZMLog.e(TAG, "addWBFragment fail for basic Activity");
            }
            ZoomMeetingSDKBridgeHelper.getInstance().trackingMSDKInteractEvent(TAG, "addWhiteBoardFragment", MobileRTCSDKError.SDKERR_WRONG_USAGE.ordinal());
            return MobileRTCSDKError.SDKERR_WRONG_USAGE;
        }
 
        Fragment fragment = ((FragmentActivity) activity).getSupportFragmentManager().findFragmentByTag(WB_TAG);
        if (fragment != null) {
            if (BuildConfig.LOG_ENABLE) {
                ZMLog.e(TAG, "addWBFragment fail for already add the fragment");
            }
            ZoomMeetingSDKBridgeHelper.getInstance().trackingMSDKInteractEvent(TAG, "addWhiteBoardFragment", MobileRTCSDKError.SDKERR_WRONG_USAGE.ordinal());
            return MobileRTCSDKError.SDKERR_WRONG_USAGE;
        }
 
        if (inMeetingWhiteboardController == null) {
            if (BuildConfig.LOG_ENABLE) {
                ZMLog.e(TAG, "addWBFragment fail for null inMeetingWhiteboardController");
            }
            ZoomMeetingSDKBridgeHelper.getInstance().trackingMSDKInteractEvent(TAG, "addWhiteBoardFragment", MobileRTCSDKError.SDKERR_WRONG_USAGE.ordinal());
            return MobileRTCSDKError.SDKERR_WRONG_USAGE;
        }
 
        inMeetingWhiteboardController.observer((FragmentActivity) activity);
 
        fragment = new SDKWBViewerFragment((FragmentActivity) activity);
        Fragment finalFragment = fragment;
        SafeTransactionKt.startSafeTransaction((FragmentActivity) activity, new Function1<ISafeTransaction, Unit>() {
            @Override
            public Unit invoke(ISafeTransaction iSafeTransaction) {
                iSafeTransaction.add(R.id.wbFragmentContainer, finalFragment, WB_TAG);
                return Unit.INSTANCE;
            }
        });
        ZoomMeetingSDKBridgeHelper.getInstance().trackingMSDKInteractEvent(TAG, "addWhiteBoardFragment", MobileRTCSDKError.SDKERR_SUCCESS.ordinal());
        mFragmentContainer.setVisibility(View.VISIBLE);
        return MobileRTCSDKError.SDKERR_SUCCESS;
    }
 
    public MobileRTCSDKError removeWhiteboardFragment() {
        boolean enableWBInView = PreferenceUtil.readBooleanValue(SDKConstants.SDK_ENABLE_SWITCH_WB_WITH_NORMAL_SHARE, false);
        if (!enableWBInView) {
            if (BuildConfig.LOG_ENABLE) {
                ZMLog.e(TAG, "removeWBFragment fail for not enable the feature");
            }
            return MobileRTCSDKError.SDKERR_WRONG_USAGE;
        }
 
        if (inMeetingWhiteboardController == null) {
            if (BuildConfig.LOG_ENABLE) {
                ZMLog.e(TAG, "remove WB Fragment fail for inMeetingWhiteboardController is null");
            }
            return MobileRTCSDKError.SDKERR_WRONG_USAGE;
        }
 
        if (mFragmentContainer == null) {
            if (BuildConfig.LOG_ENABLE) {
                ZMLog.e(TAG, "remove WB Fragment fail for mFragmentContainer is null");
            }
            return MobileRTCSDKError.SDKERR_OTHER_ERROR;
        }
 
        if (!(activity instanceof FragmentActivity)) {
            if (BuildConfig.LOG_ENABLE) {
                ZMLog.e(TAG, "removeWBFragment fail for basic Activity");
            }
            ZoomMeetingSDKBridgeHelper.getInstance().trackingMSDKInteractEvent(TAG, "removeWhiteboardFragment", MobileRTCSDKError.SDKERR_WRONG_USAGE.ordinal());
            return MobileRTCSDKError.SDKERR_WRONG_USAGE;
        }
 
        Fragment fragment = ((FragmentActivity) activity).getSupportFragmentManager().findFragmentByTag(WB_TAG);
        if (fragment == null) {
            if (BuildConfig.LOG_ENABLE) {
                ZMLog.e(TAG, "removeWBFragment fail for can not find the fragment");
            }
            return MobileRTCSDKError.SDKERR_WRONG_USAGE;
        }
 
        inMeetingWhiteboardController.removeObserver((FragmentActivity) activity, false);
 
        SafeTransactionKt.startSafeTransaction((FragmentActivity) activity, new Function1<ISafeTransaction, Unit>() {
            @Override
            public Unit invoke(ISafeTransaction iSafeTransaction) {
                iSafeTransaction.remove(fragment);
                return Unit.INSTANCE;
            }
        });
 
        ZoomMeetingSDKBridgeHelper.getInstance().trackingMSDKInteractEvent(TAG, "removeWhiteboardFragment", MobileRTCSDKError.SDKERR_SUCCESS.ordinal());
        mFragmentContainer.setVisibility(View.GONE);
        return MobileRTCSDKError.SDKERR_SUCCESS;
    }
 
    private static final String DOC_TAG = TAG + "doc";
 
    public MobileRTCSDKError addDocFragment(long shareSourceID) {
        if (mFragmentContainer == null) {
            if (BuildConfig.LOG_ENABLE) {
                ZMLog.e(TAG, "add doc Fragment fail for mFragmentContainer is null");
            }
            return MobileRTCSDKError.SDKERR_OTHER_ERROR;
        }
 
        if (!(activity instanceof FragmentActivity)) {
            if (BuildConfig.LOG_ENABLE) {
                ZMLog.e(TAG, "addDocFragment fail for basic Activity");
            }
            return MobileRTCSDKError.SDKERR_WRONG_USAGE;
        }
 
        Fragment fragment = ((FragmentActivity) activity).getSupportFragmentManager().findFragmentByTag(DOC_TAG);
        if (fragment != null) {
            if (BuildConfig.LOG_ENABLE) {
                ZMLog.e(TAG, "addDocFragment fail for already add the fragment");
            }
            return MobileRTCSDKError.SDKERR_WRONG_USAGE;
        }
 
        Bundle bundle = getBundle(shareSourceID);
        if (bundle == null) {
            if (BuildConfig.LOG_ENABLE) {
                ZMLog.e(TAG, "addDocFragment fail for null bundle");
            }
            return MobileRTCSDKError.SDKERR_OTHER_ERROR;
        }
 
        IConfZoomDocs docs = StaticInnerService.getConfDocs();
        if (docs == null) {
            if (BuildConfig.LOG_ENABLE) {
                ZMLog.e(TAG, "addDocFragment fail for null docs");
            }
            return MobileRTCSDKError.SDKERR_OTHER_ERROR;
        }
        docs.setShareSourceId(shareSourceID);
 
        fragment = ZoomDocsShareFragment.get(bundle);
        Fragment finalFragment = fragment;
        SafeTransactionKt.startSafeTransaction((FragmentActivity) activity, new Function1<ISafeTransaction, Unit>() {
            @Override
            public Unit invoke(ISafeTransaction iSafeTransaction) {
                iSafeTransaction.add(R.id.wbFragmentContainer, finalFragment, DOC_TAG);
                return Unit.INSTANCE;
            }
        });
 
        mFragmentContainer.setVisibility(View.VISIBLE);
        return MobileRTCSDKError.SDKERR_SUCCESS;
    }
 
    private @Nullable Bundle getBundle(long shareSourceID) {
        CmmDocsCollaborationSource docsCollaborationSource = ZoomMeetingSDKDocsHelper.getInstance().getDocsCollaborationSource(shareSourceID);
        if (docsCollaborationSource == null) {
            return null;
        }
        Bundle bundle = new Bundle();
        String url = ZmStringUtils.isEmptyOrNull(docsCollaborationSource.url) ? WebHelper.WEB_BLANK : docsCollaborationSource.url;
        bundle.putString(StaticInnerService.Consts.KEY_ARGS_URL, url);
        bundle.putInt(UniteBaseLogic.UniteBundleWrapper.MODULE_TYPE, UnifyWebViewAppType.UnifyWebViewAppType_ZoomDocs);
        bundle.putInt(StaticInnerService.Consts.KEY_WEBVIEW_INSTANCE_TAG, WebViewInstanceTag.kInstEditor);
        bundle.putInt(StaticInnerService.Consts.KEY_ARGS_PROCESS, ZmBusinessModuleMgr.PROCESS_TYPE_CONF);
        return bundle;
    }
 
    public MobileRTCSDKError removeDocFragment() {
        if (mFragmentContainer == null) {
            if (BuildConfig.LOG_ENABLE) {
                ZMLog.e(TAG, "removeDocFragment fail for mFragmentContainer is null");
            }
            return MobileRTCSDKError.SDKERR_OTHER_ERROR;
        }
 
        if (!(activity instanceof FragmentActivity)) {
            if (BuildConfig.LOG_ENABLE) {
                ZMLog.e(TAG, "removeDocFragment fail for basic Activity");
            }
            return MobileRTCSDKError.SDKERR_WRONG_USAGE;
        }
 
        Fragment fragment = ((FragmentActivity) activity).getSupportFragmentManager().findFragmentByTag(DOC_TAG);
        if (fragment == null) {
            if (BuildConfig.LOG_ENABLE) {
                ZMLog.e(TAG, "removeDocFragment fail for can not find the fragment");
            }
            return MobileRTCSDKError.SDKERR_WRONG_USAGE;
        }
 
        SafeTransactionKt.startSafeTransaction((FragmentActivity) activity, new Function1<ISafeTransaction, Unit>() {
            @Override
            public Unit invoke(ISafeTransaction iSafeTransaction) {
                iSafeTransaction.remove(fragment);
                return Unit.INSTANCE;
            }
        });
 
        mFragmentContainer.setVisibility(View.GONE);
        return MobileRTCSDKError.SDKERR_SUCCESS;
    }
}