In realtime collaboration, a client will merely act as a listener or trigger for events upon data creation/modification/deletion updating the current user or sending updates to other users.

1. Create a JavaScript file and name it main.js.
2. Instantiate WebViewer on a DOM element, making sure to wrap this code and any further code inside $(document).ready(). Initial document can be any PDF or XOD file.

$(document).ready(function() {
  WebViewer({
    path: "lib",
    initialDoc: "MY_INITIAL_DOC.pdf",
    documentId: "unique-id-for-this-document"
  }, document.getElementById('viewer'))
    .then(function(instance) {
      // do something...
    });
});

3. Create the server.

var server = new Server();

4. Bind a callback function to DocumentViewer.documentLoaded event.

var docViewer = instance.docViewer;
var annotManager = instance.annotManager;

docViewer.on('documentLoaded', function() {
  // Code in later steps will come here...
});

5. Inside the documentLoaded callback, bind another callback function to server's onAuthStateChanged event that is defined in server.js. A firebase.User object will be passed as a parameter.

   1. If the user is not logged in we'll call the sign-in method that we defined in server.js.
   2. If the user is logged in, we'll store their uid in the authorId variable, which will be used for client-side annotation permission checks.
   3. We call server.checkAuthor with parameters authorId, openReturningUserPopup function and openNewUserPopup function. These functions will be discussed in next steps.
   4. Then, we will send author information to the server and bind callback functions to annotation events. Details of the callback functions will be discussed in next steps.

var authorId = null;

server.bind('onAuthStateChanged', function(user) {
  // User is logged in
  if (user) {
    // Using uid property from Firebase Database as an author id
    // It is also used as a reference for server-side permission
    authorId = user.uid;
    // Check if user exists, and call appropriate callback functions
    server.checkAuthor(authorId, openReturningAuthorPopup, openNewAuthorPopup);
    // Bind server-side data events to callback functions
    // When loaded for the first time, onAnnotationCreated event will be triggered for all database entries
    server.bind('onAnnotationCreated', onAnnotationCreated);
    server.bind('onAnnotationUpdated', onAnnotationUpdated);
    server.bind('onAnnotationDeleted', onAnnotationDeleted);
  }
  // User is not logged in
  else {
    // Login
    server.signInAnonymously();
  }
});

6. Define callback functions for annotationCreated, annotationUpdated and server.annotationDeleted events. A data object will be passed as a parameter. For more information, refer to firebase.database.DataSnapshot.

   1. openReturningAuthorPopup is a callback function triggered when author data is found in the database. It will receive authorName as a parameter, and open a popup with the authorName as a visual feedback.
   2. openNewAuthorPopup is a callback function triggered when author data is not found. Then we will open a popup for a new author to setup an author name.
   3. updateAuthor is a function which will set author name in both client and server using annotationManager.setCurrentUser and server.updateAuthor, respectively.

function openReturningAuthorPopup(authorName) {
  // The author name will be used for both WebViewer and annotations in PDF
  annotManager.setCurrentUser(authorName);
  // Open popup for the returning author
  window.alert(`Welcome back ${authorName}`);
}

function openNewAuthorPopup() {
  // Open prompt for a new author
  var name = window.prompt('Welcome! Tell us your name :)');
  if (name) {
    updateAuthor(name);
  }
}

function updateAuthor(authorName) {
  // The author name will be used for both WebViewer and annotations in PDF
  annotManager.setCurrentUser(authorName);
  // Create/update author information in the server
  server.updateAuthor(authorId, { authorName });
}

7. Define callback functions for annotationCreated, annotationUpdated and server.annotationDeleted events. A data object will be passed as a parameter. For more information, refer to firebase.database.DataSnapshot.

   1. onAnnotationCreated and onAnnotationUpdated have the exact same behavior in this guide. They will use annotManager.importAnnotCommand to update the viewer with the xfdf change.
   2. We also set a custom field authorId for the updated annotation to control client-side permission of the created/updated annotation.
   3. onAnnotationDelete creates a delete command string from the annotation's id and is simply able to call importAnnotCommand on it.

function onAnnotationCreated(data) {
  // data.val() returns the value of server data in any type. In this case, it
  // would be an object with properties authorId and xfdf.
  var annotation = annotManager.importAnnotCommand(data.val().xfdf)[0];
  annotation.authorId = data.val().authorId;
  annotManager.redrawAnnotation(annotation);
  myWebViewer.getInstance().fireEvent('updateAnnotationPermission', [annotation]);
}

function onAnnotationUpdated(data) {
  // Import the annotation based on xfdf command
  var annotation = annotManager.importAnnotCommand(data.val().xfdf)[0];
  // Set a custom field authorId to be used in client-side permission check
  annotation.authorId = data.val().authorId;
  annotManager.redrawAnnotation(annotation);
}

function onAnnotationDeleted(data) {
  // data.key would return annotationId since our server method is designed as
  // annotationsRef.child(annotationId).set(annotationData)
  var command = '<delete><id>' + data.key + '</id></delete>';
  annotManager.importAnnotCommand(command);
}

8. After server callback functions are bound, we'll also bind a function to annotManager.annotationChanged event.

   1. First parameter, e, has a property imported that is set to true by default for annotations internal to the document and annotations added by importAnnotCommand or importAnnotations.

      This is key since we know that any annotationChanged event that wasn't imported was triggered on the client. So the annotations were added/modified/deleted by the current user.
   2. Then we iterate through the annotations that are changed, which is passed as the second parameter.
   3. Third parameter, type, defines which action it was. In this guide, we'll have the same behavior for both add and modify action types.
   4. When annotations are added and modified, we will call server.createAnnotation or server.updateAnnotation which needs four variables: annotationId, authorId, parentAuthorId and xfdf.
   5. annotationId can be retrieved from annotation.Id.
   6. authorId was saved as a reference when user logged in.
   7. parentAuthorId refers to the parent annotation's author id, if any. This will be used to distinguish replies, and will be referenced in server-side permission. Thus, we retrieve authorId of the parent annotation by using annotation.InReplyTo, which returns the annotation id of the parent annotation.
   8. xfdf can be retrieved using annotationManager.getAnnotCommand. It will get an XML string specifying the added, modified and deleted annotations, which can be used to import the annotation using (annotationManager.importAnnotCommand)[/api/web/CoreControls.AnnotationManager.html#importAnnotCommand] in server data callback functions.

9. Lastly, we will overwrite the client-side permission checking function using annotManager.setPermissionCheckCallback. The default is set to compare the authorName. Instead, we will compare authorId created from the server.

annotManager.setPermissionCheckCallback(function(author, annotation) {
  return annotation.authorId === authorId;
});