Create a new FlashCom application named CommunicationCenterApp. You can do this by making a new directory with this name inside of the FlashCom server's applications directory.

Create a new file inside of the CommunicationCenterApp directory. Name the file main.asc.

Add the following code to main.asc:

// The application.onConnect(  ) method is invoked each time a new client connects
// to the application. The newClient parameter is a FlashCom-generated reference
// to the new client. The username parameter is a value passed to the method by
// the Flash client.
application.onConnect = function (newClient, username, password) {

  newClient.username = username;
  newClient.password = password;

  // The acceptClient(  ) function accepts the client and assigns methods to the
  // client object according to the user type.
  acceptClient(newClient);
};

// The application.onDisconnect(  ) method is automatically invoked whenever a
// client disconnects from the application.
application.onDisconnect = function (disconnectClient) {

  // If the client who has disconnected was on a call with the administrator,
  // release that connection by setting the callingClient property to null. Also,
  // if the administrator is still online, invoke the incomingCallEnd(  ) method
  // in the administrator client to clean up things on that end.
  if (application.callingClient == disconnectClient) {
    application.callingClient = null;
    if (application.admin != undefined) {
      application.admin.call("incomingCallEnd", null);
    }
  }

  // If the client who has disconnected happens to be the administrator, take
  // care of the necessary loose ends.
  if (application.admin = disconnectClient) {

    // If the administrator was on a call, alert the calling client that the call
    // has ended.
    if (application.callingClient != null) {
      application.callingClient.call("adminEndCall", null);
    }

    // Set callingClient to null and delete the admin property since there are no
    // more active calls and no administrator logged in.
    application.callingClient = null;
    delete application.admin;
  }
};

// When the application first starts, this method is invoked automatically to
// initialize necessary application properties.
application.onAppStart = function (  ) {

  // The callingClient property is assigned a reference to the client object when
  // a client is on a call with the administrator.
  application.callingClient = null;

  // The messages shared object is a remote shared object (RSO) that contains all
  // the messages that have been left for the administrator.
  application.messagesSO = SharedObject.get("messages", true);

  // The messageNum property of the shared object is used to guarantee unique 
  // message numbers. If the property doesn't exist, initialize it to 0.
  if (application.messagesSO.getProperty("messageNum") == undefined) {
    application.messagesSO.setProperty("messageNum", 0);
  }
};

// The acceptClient(  ) function is invoked from 
// the application.onConnect(  ) method.
function acceptClient(newClient) {

  // Make sure a calling client doesn't try to log in with the username "admin".
  if (newClient.username == "admin" && newClient.password != "adminPass") {
    application.rejectConnection(newClient);
    return;
  }

  // Accept all other client connections.
  application.acceptConnection(newClient);

  // Set the methods available to the client objects.
  newClient.recordMessageInfo = recordMessageInfo;
  newClient.getMessageID = getMessageID;
  newClient.placeCall = placeCall;
  newClient.endCall = endCall;

  // If the client is the administrator client, 
  // then take care of a few other tasks.
  if (newClient.username == "admin") {
    // Set the admin property to a reference to the connecting client object.
    application.admin = newClient;

    // Set a few administrator-only client methods.
    newClient.acceptIncomingCall = acceptIncomingCall;
    newClient.sendToLeaveMessage = sendToLeaveMessage;
    newClient.removeMessage = removeMessage;
  }
}

// This function is a method assigned to the administrator client. When this
// method is invoked, the administrator has accepted an incoming call, and the
// acceptCall(  ) method on the calling client is invoked.
function acceptIncomingCall (  ) {
  application.callingClient.call("acceptCall", null);
}

// This function is a method assigned to the administrator client. It is invoked
// when the administrator does not answer an incoming call.
function sendToLeaveMessage (  ) {
  application.callingClient.call("notAvailable", null);
  application.callingClient = null;
}

// The placeCall(  ) function is assigned to clients as a method. This method is
// invoked when a client attempts to call the administrator.
function placeCall (  ) {

  // If the administrator is logged in and if there is not already another call 
  // in place, invoke the onIncomingCall(  ) method on the administrator client to 
  // alert the user that there is an incoming call. Otherwise, alert the calling 
  // client that the administrator is not available for a call right now.
  if (application.admin != undefined && application.callingClient == null) {
    application.admin.call("onIncomingCall", null, this.username);
    application.callingClient = this;
  } else {
    this.call("notAvailable", null);
  }
}

// The endCall(  ) function is a method of all clients, 
// and it ends the current call by invoking methods on 
// both the calling client and the administrator client.
function endCall (  ) {
  application.callingClient("adminEndCall", null);
  application.callingClient = null;
  application.admin.call("incomingCallEnd", null);
}

// The recordMessageInfo(  ) function is a method of the calling clients, and it 
// is invoked when the user records a new message so that the information about
// the message (such as username and time and date) can be stored as well.
function recordMessageInfo(id) {

  // Get the messages array property of the messages shared object. If the
  // property is undefined, create the array.
  var messages = application.messagesSO.getProperty("messages");
  if (messages == undefined) {
    messages = new Array(  );
  }

  // Create an object that contains the message id, username, and the date when
  // the message was recorded. Add this object to the messages array.
  var infoObj = {id: id, username: this.username, dateTime: new Date(  )};
  messages.push(infoObj);

  // Add the updated info back to the shared object and write the data to disk.
  application.messagesSO.setProperty("messages", messages);
  application.messagesSO.flush(  );
}

// The removeMessage(  ) function is a method of the administrator client, and it
// allows the administrator to remove recorded messages.
function removeMessage(streamName) {

  // Use the Stream.get(  ) method to get a reference to the stream on the server.
  var messageStream = Stream.get(streamName);

  // Use the clear(  ) method to delete the stream.
  messageStream.clear(  );

  // Get the messages property of the shared object, and loop through it to find
  // the information for the stream that has been deleted. When the message
  // information is found, delete it with a splice(  ) method. 
  var messages = application.messagesSO.getProperty("messages");
  for (var i = 0; i < messages.length; i++) {
    if ("message" + messages[i].id == streamName) {
      messages.splice(i, 1);
      break;
    }
  }

  // Update the shared object and write it to disk.
  application.messagesSO.setProperty("messages", messages);
  application.messagesSO.flush(  );
}

// The getMessageID(  ) function returns a unique message number.
function getMessageID (  ) {
  // Get the messageNum property from the shared object and increment the value
  // stored in the shared object.
  var messageNum = application.messagesSO.getProperty("messageNum");
  application.messagesSO.setProperty("messageNum", messageNum + 1);
  application.messagesSO.flush(  );
  return messageNum;
}