Manage in-meeting annotation

var customizedAnnotation: ZoomSDKCustomizedAnnotation? = nil
var shareElement: ZoomSDKShareElement? = nil // shareElement is needed to annotate on the remote user's screen share. Or to annotation on your own share, keep this nil.

// In your ViewController, you need to add the ZoomSDKASControllerDelegate to receive share-related callbacks and also ZoomSDKCustomizedAnnotationCtrlDelegate to receive its annotation callback
if let annotationShareController = ZoomSDK.shared().getMeetingService()?.getASController(), let customizedAnnotationCtr = annotationShareController.getCustomizedAnnotationCtr() {
    annotationShareController.delegate = self
    customizedAnnotationCtr.delegate = self

   /*
    To annotate on the local user's screen sharing:
    1. customizedAnnotation must be nil
    2. shareElement must be nil OR create a shareElement with sharingID = 0
   */

    if customizedAnnotationCtr.createCustomizedAnnotation(&customizedAnnotation, shareElement: &shareElement) == ZoomSDKError_Success, let customizedAnnotation = customizedAnnotation {
        customizedAnnotation.delegate = self
    }

    /*
     OR
     To annotate on a remote user's screen share, you must have first already created the ZoomSDKShareElement that you are subscribing to. The steps are similar to how screen sharing works:
     1. Identify the remote user's screen share through its shareSourceID. This can be obtained in the onSharingStatusChanged(_ shareInfo: ZoomSDKSharingSourceInfo)'s callback and using the shareInfo.shareSourceID
     2. Create a ZoomSDKShareElement based on the subscribed screen CGRect size, sharingID = shareSourceID, viewMode and etc. Then, add the ZoomSDKShareElement shareView to your own view.
     4. Continue with the steps below for annotation
     */

    if let shareElement = shareElement {
        if customizedAnnotationCtr.createCustomizedAnnotation(&customizedAnnotation, shareElement: shareElement) == ZoomSDKError_Success, let customizedAnnotation = customizedAnnotation {
            customizedAnnotation.delegate = self
        }
    }
}

// Conform your ViewController to the ZoomSDKCustomizedAnnotationCtrlDelegate and ZoomSDKCustomizedAnnotationDelegate protocol. Conform to the ZoomSDKASControllerDelegate if you also want to receive share-related callbacks.
extension ViewController: ZoomSDKCustomizedAnnotationCtrlDelegate, ZoomSDKCustomizedAnnotationDelegate {
    func onAnnotationSupportPropertyChanged(forCustom isSupportAnnotation: Bool, shareSourceID: UInt32) {
        if isSupportAnnotation {
            // Annotations are enabled
        }
        // currentShareID = shareSourceID
    }

    func onAnnotationCleanUp(_ annotation: ZoomSDKCustomizedAnnotation) {

    }

    func onAnnotationStatusChanged(_ element: ZoomSDKShareElement?, status: AnnotationStatus) {

    }

    func onAnnotationToolChanged(_ tool: AnnotationToolType) {

    }
}

// To determine if annotations can be performed manually
if let customizedAnnotationCtr = ZoomSDK.shared().getMeetingService()?.getASController().getCustomizedAnnotationCtr() {
    var canDoAnno = ObjCBool(true)
    if let customizedAnnotation = customizedAnnotation, customizedAnnotationCtr.canDo(customizedAnnotation, canAnnotate: &canDoAnno) == ZoomSDKError_Success, canDoAnno.boolValue {
        // Annotations can be performed
    }
}

// In your ViewController.h, you need to conform it to the ZoomSDKASControllerDelegate protocol
@interface ViewController : NSWindowController <ZoomSDKASControllerDelegate, ZoomSDKCustomizedAnnotationDelegate, ZoomSDKCustomizedAnnotationCtrlDelegate> {

}

// In your ViewController.m, you need to add the relevant delegates callbacks first to receive the callback later
ZoomSDKCustomizedAnnotation *customizedAnnotation = nil;
ZoomSDKShareElement  = nil; // shareElement is needed to annotate on remote user's screen share. Or to annotation on your own share, keep this nil.

ZoomSDKASController *annotationShareController =
    [[[ZoomSDK sharedSDK] getMeetingService] getASController];
if (annotationShareController) {
    ZoomSDKCustomizedAnnotationCtr *customizedAnnotationCtr =
        [annotationShareController getCustomizedAnnotationCtr];
    if (customizedAnnotationCtr) {
        annotationShareController.delegate = self;
        customizedAnnotationCtr.delegate = self;

        // To annotate on the local user's screen sharing - customizedAnnotation and shareElement must be nil
        ZoomSDKError error =
            [customizedAnnotationCtr createCustomizedAnnotation:&customizedAnnotation
                                                   ShareElement:shareElement];
        if (error == ZoomSDKError_Success && customizedAnnotation) {
            customizedAnnotation.delegate = self;
        }

        /*
         OR
         To annotate on a remote user's screen share, you must have first already created the ZoomSDKShareElement that you are subscribing to. The steps are similar to how screen sharing works:
         1. Identify the remote user's screen share through its shareSourceID. This can be obtained in the onSharingStatusChanged(_ shareInfo: ZoomSDKSharingSourceInfo)'s callback and using the shareInfo.shareSourceID
         2. Create a ZoomSDKShareElement based on the subscribed screen CGRect size, sharingID = shareSourceID, viewMode and etc. Then, add the ZoomSDKShareElement shareView to your own view.
         4. Continue with the steps below for annotation
         */
        if (shareElement != nil) {
            ZoomSDKError error =
                [customizedAnnotationCtr createCustomizedAnnotation:&customizedAnnotation
                                                       ShareElement:shareElement];
            if (error == ZoomSDKError_Success && customizedAnnotation) {
                customizedAnnotation.delegate = self;
            }
        }
    }
}

- (void)onAnnotationSupportPropertyChangedForCustom:(BOOL)isSupportAnnotation shareSourceID:(unsigned int)shareSourceID {
    if (isSupportAnnotation) {
        // Annotations are enabled
    }
    // currentShareID = shareSourceID;
}

- (void)onAnnotationCleanUp:(ZoomSDKCustomizedAnnotation *)annotation {

}

- (void)onAnnotationStatusChanged:(ZoomSDKShareElement *)element Status:(AnnotationStatus)status {

}

- (void)onAnnotationToolChanged:(AnnotationToolType)tool {

}

// To determine if annotations can be performed manually
ZoomSDKCustomizedAnnotationCtr *customizedAnnotationCtr =
    [[[[ZoomSDK sharedSDK] getMeetingService] getASController] getCustomizedAnnotationCtr];
if (customizedAnnotationCtr) {
    BOOL canDoAnno = NO;
    if (customizedAnnotation && [customizedAnnotationCtr canDoAnnotation:customizedAnnotation canAnnotate:&canDoAnno] == ZoomSDKError_Success && canDoAnno) {
        // Annotations can be performed
    }
}

var canDisableAnnotation = ObjCBool(false)
if customizedAnnotationCtr.canDisableViewerAnnotation(customizedAnnotation, canDisabled: &canDisableAnnotation) == ZoomSDKError_Success && canDisableAnnotation.boolValue {
    var isAnnotationLocked = ObjCBool(true)
    if customizedAnnotationCtr.isViewerAnnotationLocked(customizedAnnotation, isLocked: &isAnnotationLocked) == ZoomSDKError_Success && isAnnotationLocked.boolValue {
        // Depending on the isAnnotationLocked's Bool value, then disable/enable viewer annotation
        customizedAnnotationCtr.disableViewerAnnotation(customizedAnnotation, disable: false) // Or true
    }
}

BOOL canDisableAnnotation = NO;
if ([annotationShareController canDisableViewerAnnotation:ScreenType_First canDisabled:&canDisableAnnotation] == ZoomSDKError_Success && canDisableAnnotation) {
    BOOL isAnnotationLocked;
    if ([annotationShareController isViewerAnnotationLocked:ScreenType_First isLocked:&isAnnotationLocked] == ZoomSDKError_Success && isAnnotationLocked) {
        [annotationShareController disableViewerAnnotation:ScreenType_First disable:NO]; // Or YES
    }
}

if annotationShareController.startAnnotation(ScreenType_First) == ZoomSDKError_Success {
    // You can begin using the annotation tool
}

annotationShareController.stopAnnotation(ScreenType_First)

if ([annotationShareController startAnnotation:ScreenType_First] == ZoomSDKError_Success) {
    // You can begin using the annotation tool
}

[annotationShareController stopAnnotation:ScreenType_First];

annotationController.setColor(1, green: 1, blue: 1, on: ScreenType_First) // red, green and blue: Float (0 - 255)
annotationController.setTool(AnnotationToolType_Pen, on: ScreenType_First) // type: AnnotationToolType
annotationController.setLineWidth(1, on: ScreenType_First) // lineWidth: Int

[annotationController setColor:1 green:1 blue:1 onScreen:ScreenType_First]; // red, green and blue: Float (0 - 255)
[annotationController setTool:AnnotationToolType_Pen onScreen:ScreenType_First]; // type: AnnotationToolType
[annotationController setLineWidth:1 onScreen:ScreenType_First]; // lineWidth: Int

annotationController.undo(ScreenType_First)
annotationController.redo(ScreenType_First)
annotationController.clear(AnnotationClearType_All, on: ScreenType_First) // AnnotationClearType: All, self, others.

ZoomSDKAnnotationController *annotationController = [annotationShareController getAnnotationController];
[annotationController undo:ScreenType_First];
[annotationController redo:ScreenType_First];
[annotationController clear:AnnotationClearType_All onScreen:ScreenType_First];