webex

Messages are how people communicate in rooms. Each message timestamped and represented in Webex as a distinct block of content. Messages can contain plain text and a single file attachment. See the Message Attachments Guide for a list of supported media types.

new Messages()

Instance Members

▸ listen()

packages/@webex/plugin-attachment-actions/src/attachmentActions.js

Register to listen for incoming attachmentAction events This is an alternate approach to registering for attachmentAction webhooks. The events passed to any registered handlers will be similar to the webhook JSON, but will omit webhook specific fields such as name, secret, url, etc. The attachmentActions.listen() event objects can also include additional fields not available in the webhook's JSON payload, specifically: inputs. To utilize the listen() method, the authorization token used will need to have spark:all and spark:kms scopes enabled. Note that by configuring your application to enable or disable spark:all via its configuration page will also enable or disable spark:kms. See the Sample App for more details.

listen(): Promise

Returns

Promise:

Example

webex.attachmentActions.listen()
  .then(() => {
    console.log('listening to attachmentActions events');
    webex.attachmentActions.on('created', (event) => console.log(`Got an attachmentActions:created event:\n${event}`));
  })
  .catch((e) => console.error(`Unable to register for attachmentAction events: ${e}`));
// Some app logic...
// WHen it is time to cleanup
webex.attachmentActions.stopListening();
webex.attachmentActions.off('created');

▸ listen()

Register to listen for incoming messages events This is an alternate approach to registering for messages webhooks. The events passed to any registered handlers will be similar to the webhook JSON, but will omit webhook specific fields such as name, secret, url, etc. The messages.listen() event objects can also include additional fields not available in the webhook's JSON payload: text, markdown, and files. These fields are available when their details are included in the web socket's activity object. Retrieving other fields, such as the html field, will require a manual request to get the corresponding message object. To utilize the listen() method, the authorization token used will need to have spark:all and spark:kms scopes enabled. Note that by configuring your application to enable or disable spark:all via its configuration page will also enable or disable spark:kms. See the Sample App for more details.

listen(): Promise

Returns

Promise:

Example

webex.messages.listen()
  .then(() => {
    console.log('listening to message events');
    webex.messages.on('created', (event) => console.log(`Got a message:created event:\n${event}`));
    webex.messages.on('deleted', (event) => console.log(`Got a message:deleted event:\n${event}`));
  })
  .catch((e) => console.error(`Unable to register for message events: ${e}`));
// Some app logic...
// When it is time to cleanup
webex.messages.stopListening();
webex.messages.off('created');
webex.messages.off('deleted');

▸ create(message)

Post a new message and/or media content into a room.

create(message: MessageObject): Promise<MessageObject>

Parameters

message (MessageObject)

Returns

Promise<MessageObject>:

Example

webex.rooms.create({title: 'Create Message Example'})
  .then(function(room) {
    return webex.messages.create({
      text: 'Howdy!',
      roomId: room.id
    });
  })
  .then(function(message) {
    var assert = require('assert');
    assert(message.id);
    assert(message.personId);
    assert(message.personEmail);
    assert(message.roomId);
    assert(message.created);
    return 'success';
  });
  // => success

▸ update(message, altMessage)

Put an updated message and/or media content into a room instead of existing message.

update(message: MessageObject, altMessage: MessageObject): Promise<MessageObject>

Parameters

message (MessageObject)

altMessage (MessageObject)

Returns

Promise<MessageObject>:

Example

webex.rooms.create({title: 'Create Message Example'})
  .then(function(room) {
    return webex.messages.create({
      text: 'Howdy!',
      roomId: room.id
    });
  })
  .then(function(m) {
    message = m;
    return webex.messages.update(message,{markdown:`**What up**`});
  })
  .then(function(m) {
    message = m;
    return webex.messages.update(message.id,{roomId:message.roomId,text:'Howdy!'});
  })
  .then(function(message) {
    var assert = require('assert');
    assert(message.id);
    assert(message.personId);
    assert(message.personEmail);
    assert(message.roomId);
    assert(message.created);
    return 'success';
  });
  // => success

▸ get(message)

Returns a single message.

get(message: (RoomObject | string)): Promise<MessageObject>

Parameters

message ((RoomObject | string))

Returns

Promise<MessageObject>:

Example

var message;
webex.rooms.create({title: 'Get Message Example'})
  .then(function(room) {
    return webex.messages.create({
      text: 'Howdy!',
      roomId: room.id
    });
  })
  .then(function(m) {
    message = m;
    return webex.messages.get(message.id);
  })
  .then(function(message2) {
    var assert = require('assert');
    assert.deepEqual(message2, message);
    return 'success';
  });
  // => success

▸ list(options)

Returns a list of messages. In most cases the results will only contain messages posted in rooms that the authenticated user is a member of.

list(options: Object): Promise<Page<MessageObject>>

Parameters

options (Object)

Name	Description
options.roomId `string`
options.max `number`

Returns

Promise<Page<MessageObject>>:

Example

var message1, message2, room;
webex.rooms.create({title: 'List Messages Example'})
  .then(function(r) {
    room = r;
    return webex.messages.create({
      text: 'Howdy!',
      roomId: room.id
    });
  })
  .then(function(m) {
    message1 = m;
    return webex.messages.create({
      text: 'How are you?',
      roomId: room.id
    });
  })
  .then(function(m) {
    message2 = m;
    return webex.messages.list({roomId: room.id});
  })
  .then(function(messages) {
    var assert = require('assert');
    assert.equal(messages.length, 2);
    assert.equal(messages.items[0].id, message2.id);
    assert.equal(messages.items[1].id, message1.id);
    return 'success';
  });
  // => success

▸ remove(message)

Deletes a single message. Deleting a message will notify all members of the room that the authenticated user deleted the message. Generally, users can only delete their own messages except for the case of Moderated Rooms and Org Administrators.

remove(message: (MessageObject | uuid)): Promise

Parameters

message ((MessageObject | uuid))

Returns

Promise: }

Example

var message1, room;
webex.rooms.create({title: 'Messages Example'})
  .then(function(r) {
    room = r;
    return webex.messages.create({
      text: 'Howdy!',
      roomId: room.id
    });
  })
  .then(function(m) {
    message1 = m;
    return webex.messages.create({
      text: 'How are you?',
      roomId: room.id
    });
  })
  .then(function() {
    return webex.messages.remove(message1);
  })
  .then(function() {
    return webex.messages.list({roomId: room.id});
  })
  .then(function(messages) {
    var assert = require('assert');
    assert.equal(messages.items.length, 1);
    assert(messages.items[0].id !== message1.id);
    return 'success';
  });
  // => success

Memberships

packages/@webex/plugin-memberships/src/memberships.js

Memberships represent a person's relationship to a room. Use this API to list members of any room that you're in or create memberships to invite someone to a room. Memberships can also be updated to make someone a moderator or deleted to remove them from the room.

new Memberships()

Instance Members

▸ listen()

packages/@webex/plugin-memberships/src/memberships.js

Register to listen for incoming membership events This is an alternate approach to registering for membership webhooks. The events passed to any registered handlers will be similar to the webhook JSON, but will omit webhook specific fields such as name, secret, url, etc. To utilize the listen() method, the authorization token used will need to have spark:all and spark:kms scopes enabled. Note that by configuring your application to enable or disable spark:all via its configuration page will also enable or disable spark:kms. See the Sample App for more details.

listen(): Promise

Returns

Promise:

Example

webex.memberships.listen()
  .then(() => {
    console.log('listening to membership events');
    webex.memberships.on('created', (event) => {
      console.log(`Got a membership:created event:\n${event}`);
    }
    webex.memberships.on('updated', (event) => {
       console.log(`Got a membership:updated event:\n${event}`);
    }
    webex.memberships.on('seen', (event) => {
      // This represents a "read receipt" and will include a
      // lastSeenId for the message this member has just "read",
      // There is currently no equivalent webhook for this event.
      console.log(`Got a membership:seen event:\n${event}`);
    }
    webex.memberships.on('deleted', (event) =>  => {
      console.log(`Got a membership:created event:\n${event}`);
    }
  })
  .catch((e) => console.error(`Unable to register for membership events: ${e}`));
// App logic goes here...
// Later when it is time to clean up
webex.memberships.stopListening();
webex.memberships.off('created');
webex.memberships.off('updated');
webex.memberships.off('seen');
webex.memberships.off('deleted');

▸ create(membership)

packages/@webex/plugin-memberships/src/memberships.js

Adds a person to a room. The person can be added by ID (personId) or by Email Address (personEmail). The person can be optionally added to the room as a moderator.

create(membership: MembershipObject): Promise<MembershipObject>

Parameters

membership (MembershipObject)

Returns

Promise<MembershipObject>:

Example

webex.rooms.create({title: 'Create Membership Example'})
  .then(function(room) {
    return webex.memberships.create({
     personEmail: 'alice@example.com',
     roomId: room.id
   });
  })
  .then(function(membership) {
    var assert = require('assert');
    assert(membership.id);
    assert(membership.roomId);
    assert(membership.personId);
    assert(membership.personEmail);
    assert('isModerator' in membership);
    assert('isMonitor' in membership);
    assert(membership.created);
    return 'success';
  });
  // => success

▸ get(membership)

packages/@webex/plugin-memberships/src/memberships.js

Returns a single membership.

get(membership: (MembershipObject | uuid)): Promise<MembershipObject>

Parameters

membership ((MembershipObject | uuid))

Returns

Promise<MembershipObject>:

Example

var membership;
webex.rooms.create({title: 'Get Membership Example'})
  .then(function(room) {
    return webex.memberships.create({
      personEmail: 'alice@example.com',
      roomId: room.id
    });
  })
  .then(function(m) {
    membership = m;
    return webex.memberships.get(m.id);
  })
  .then(function(m) {
    var assert = require('assert');
    assert.deepEqual(m, membership);
    return 'success';
  });
  // => success

▸ list(options)

packages/@webex/plugin-memberships/src/memberships.js

Returns a list of memberships. In most cases the results will only contain rooms that the authenticated user is a member of. You can filter the results by room to list people in a room or by person to find rooms that a specific person is a member of.

list(options: Object): Promise<Page<MembershipObject>>

Parameters

options (Object)

Name	Description
options.personId `string`
options.personEmail `string`
options.roomId `string`
options.max `number`

Returns

Promise<Page<MembershipObject>>:

Example

var room;
webex.rooms.create({title: 'List Membership Example'})
  .then(function(r) {
    room = r;
    return webex.memberships.create({
     personEmail: 'alice@example.com',
     roomId: room.id
    });
  })
  .then(function() {
    return webex.memberships.list({roomId: room.id});
  })
  .then(function(memberships) {
    var assert = require('assert');
    assert.equal(memberships.length, 2);
    for (var i = 0; i < memberships.length; i+= 1) {
      assert.equal(memberships.items[i].roomId, room.id);
    }
    return 'success';
  });
  // => success

▸ listWithReadStatus(options)

packages/@webex/plugin-memberships/src/memberships.js

Returns a list of memberships with details about the lastSeenId for each user, allowing a client to indicate "read status" in a space GUI

This differs from the memberships.list() function in the following ways: -- it accepts only a room or object with a valid roomId -- no other options, eg: max, are considered -- results are not paginated -- memberships in the return do not include the "created", "isRoomHidden", fields -- memberships in the return do include the new "lastSeenId", and "lastSeenDate" fields these will not exist if the member has never "seen" the space

In general this function should be used only when the client needs to access read status info.

This function may be deprecated when this info is provided in the membership objects returned in the list function.

listWithReadStatus(options: Object): Promise<MembershipObjectList>

Parameters

options (Object)

Name	Description
options.roomId `string`

Returns

Promise<MembershipObjectList>:

▸ remove(membership)

packages/@webex/plugin-memberships/src/memberships.js

Deletes a single membership.

remove(membership: (MembershipObject | uuid)): Promise

Parameters

membership ((MembershipObject | uuid))

Returns

Promise:

Example

var membership, room;
webex.rooms.create({title: 'Remove Membership Example'})
  .then(function(r) {
    room = r;
    return webex.memberships.create({
     personEmail: 'alice@example.com',
     roomId: room.id
    });
  })
  .then(function(m) {
    membership = m;
    return webex.memberships.list({roomId: room.id});
  })
  .then(function(memberships) {
    var assert = require('assert');
    assert.equal(memberships.length, 2);
    return webex.memberships.remove(membership);
  })
  .then(function() {
    return webex.memberships.list({roomId: room.id});
  })
  .then(function(memberships) {
    var assert = require('assert');
    assert.equal(memberships.length, 1);
    return 'success';
  });
  // => success

▸ update(membership)

packages/@webex/plugin-memberships/src/memberships.js

Used to update a single membership's properties

update(membership: (MembershipObject | uuid)): Promise<MembershipObject>

Parameters

membership ((MembershipObject | uuid))

Returns

Promise<MembershipObject>:

Example

// Change membership to make user a moderator
var membership, room;
webex.rooms.create({title: 'Memberships Example'})
  .then(function(r) {
    room = r;
    return webex.memberships.list({roomId: room.id});
  })
  .then(function(memberships) {
    membership = memberships.items[0];
    var assert = require('assert');
    assert.equal(membership.isModerator, false);
    membership.isModerator = true;
    return webex.memberships.update(membership);
  })
  .then(function() {
    return webex.memberships.get(membership.id);
  })
  .then(function(membership) {
    var assert = require('assert');
    assert.equal(membership.isModerator, true);
    return 'success';
  });
  // => success

// Hide a one on one space
var assert = require('assert');
var membership, myId;
webex.people.get('me')
  .then(function(person) {
    myId = personId;
    return webex.messages.create({
      toPersonEmail: 'otherUser@acme.com',
      text: 'This message will create a 1-1 space'
    });
  })
  then(function(message) {
    return webex.memberships.list({
      roomId: message.roomId,
      personId: myId
    });
  })
  .then((memberships) => {
    membership = memberships.items[0];
    assert.equal(membership.isRoomHidden, false);
    membership.isRoomHidden = true;
    // This will generate a memberships:updated event
    // that will only be seen by this user
    return webex.memberships.update(membership);
  })
  .then(function(membership) {
    assert.equal(membership.isRoomHidden, true);
    return 'success';
  });
  // => success

▸ updateLastSeen(message)

packages/@webex/plugin-memberships/src/memberships.js

Updates the lastSeenId attribute of a membership. Call this method to send a "read receipt" for a given message. This will update the lastSeenId for the user's membership in space where the message is.

updateLastSeen(message: string): Promise<MembershipObject>

Parameters

message (string)

Returns

Promise<MembershipObject>:

People

packages/@webex/plugin-people/src/people.js

new People()

Instance Members

▸ get(person)

packages/@webex/plugin-people/src/people.js

Returns a single person by ID

get(person: (PersonObject | uuid | string)): Promise<PersonObject>

Parameters

person ((PersonObject | uuid | string))

Returns

Promise<PersonObject>:

Example

webex.rooms.create({title: 'Get Person Example'})
  .then(function(room) {
    return webex.memberships.create({
      personEmail: 'alice@example.com',
      roomId: room.id
    });
  })
  .then(function(membership) {
    return webex.people.get(membership.personId);
  })
  .then(function(alice) {
    var assert = require('assert');
    assert(alice.id);
    assert(Array.isArray(alice.emails));
    assert.equal(alice.emails.filter(function(email) {
      return email === 'alice@example.com';
    }).length, 1);
    assert(alice.displayName);
    assert(alice.created);
    return 'success';
  });
  // => success

▸ list(options, showAllTypes)

packages/@webex/plugin-people/src/people.js

Returns a list of people

list(options: (Object | Array<uuid>), showAllTypes: bool): Promise<Page<PersonObject>>

Parameters

options ((Object | Array<uuid>)) or array of uuids

Name	Description
options.email `email`	Returns people with an email that contains this string
options.displayName `string`	Returns people with a name that contains this string

showAllTypes (bool) optional flag that requires Hydra to send every type field, even if the type is not "person" (e.g.: SX10, webhook_integration, etc.)

Returns

Promise<Page<PersonObject>>:

Example

var room;
webex.rooms.create({title: 'List People Example'})
  .then(function(r) {
    room = r;
    return webex.memberships.create({
      personEmail: 'alice@example.com',
      roomId: room.id
    });
  })
  .then(function() {
    return webex.memberships.create({
      personEmail: 'bob@example.com',
      roomId: room.id
    });
  })
  .then(function() {
    return webex.people.list({email: 'alice@example.com'});
  })
  .then(function(people) {
    var assert = require('assert');
    assert.equal(people.length, 1);
    var person = people.items[0];
    assert(person.id);
    assert(Array.isArray(person.emails));
    assert(person.displayName);
    assert(person.created);
    return 'success';
  });
  // => success

Example usage of array method

var room;
var aliceId;
var bobId;
webex.rooms.create({title: 'List People Array Example'})
  .then(function(r) {
    room = r;
    return webex.memberships.create({
      personEmail: 'alice@example.com',
      roomId: room.id
    });
  })
  .then(function(membership) {
    aliceId = membership.personId;
  })
  .then(function() {
    return webex.memberships.create({
      personEmail: 'bob@example.com',
      roomId: room.id
    });
  })
  .then(function(membership) {
    bobId = membership.personId;
  })
  .then(function() {
    return webex.people.list([aliceId, bobId]);
  })
  .then(function(people) {
    var assert = require('assert');
    assert.equal(people.length, 2);
    var person = people.items[0];
    assert(person.id);
    assert(Array.isArray(person.emails));
    assert(person.displayName);
    assert(person.created);
    return 'success';
  });
  // => success

Rooms

packages/@webex/plugin-rooms/src/rooms.js

Rooms are virtual meeting places for getting stuff done. This resource represents the room itself. Check out the Memberships API to learn how to add and remove people from rooms and the Messages API for posting and managing content.

new Rooms()

Instance Members

▸ listen()

packages/@webex/plugin-rooms/src/rooms.js

Register to listen for incoming rooms events This is an alternate approach to registering for rooms webhooks. The events passed to any registered handlers will be similar to the webhook JSON, but will omit webhook specific fields such as name, secret, url, etc. To utilize the listen() method, the authorization token used will need to have spark:all and spark:kms scopes enabled. Note that by configuring your application to enable or disable spark:all via its configuration page will also enable or disable spark:kms. See the Sample App for more details.

listen(): Promise

Returns

Promise:

Example

webex.rooms.listen()
  .then(() => {
    console.log('listening to room events');
    webex.rooms.on('created', (event) => console.log(`Got a room:created event:\n${event}`);
    webex.rooms.on('updated', (event) => console.log(`Got a room:updated event:\n${event}`);
  })
  .catch((e) => console.error(`Unable to register for room events: ${e}`));
// Some app logic...
// WHen it is time to cleanup
webex.rooms.stopListening();
webex.rooms.off('created');
webex.rooms.off('updated');

▸ create(room)

packages/@webex/plugin-rooms/src/rooms.js

Creates a new room. The authenticated user is automatically added as a member of the room. See the Memberships API to learn how to add more people to the room.

create(room: RoomObject): Promise<RoomObject>

Parameters

room (RoomObject)

Returns

Promise<RoomObject>:

Example

webex.rooms.create({title: 'Create Room Example'})
  .then(function(room) {
    var assert = require('assert')
    assert(typeof room.created === 'string');
    assert(typeof room.id === 'string');
    assert(room.title === 'Create Room Example');
    console.log(room.title);
    return 'success';
  });
  // => success

▸ get(room, options)

packages/@webex/plugin-rooms/src/rooms.js

Returns a single room.

get(room: (RoomObject | string), options: Object): Promise<RoomObject>

Parameters

room ((RoomObject | string))

options (Object)

Returns

Promise<RoomObject>:

Example

var room;
webex.rooms.create({title: 'Get Room Example'})
  .then(function(r) {
    room = r
    return webex.rooms.get(room.id)
  })
  .then(function(r) {
    var assert = require('assert');
    assert.deepEqual(r, room);
    return 'success';
  });
  // => success

▸ list(options)

packages/@webex/plugin-rooms/src/rooms.js

Returns a list of rooms. In most cases the results will only contain rooms that the authenticated user is a member of.

list(options: Object): Promise<Page<RoomObject>>

Parameters

options (Object)

Name	Description
options.max `Object`	Limit the maximum number of rooms in the response.

Returns

Promise<Page<RoomObject>>:

Example

var createdRooms;
Promise.all([
  webex.rooms.create({title: 'List Rooms Example 1'}),
  webex.rooms.create({title: 'List Rooms Example 2'}),
  webex.rooms.create({title: 'List Rooms Example 3'})
])
  .then(function(r) {
    createdRooms = r;
    return webex.rooms.list({max: 3})
      .then(function(rooms) {
        var assert = require('assert');
        assert(rooms.length === 3);
        for (var i = 0; i < rooms.items.length; i+= 1) {
          assert(createdRooms.filter(function(room) {
            return room.id === rooms.items[i].id;
          }).length === 1);
        }
        return 'success';
      });
  });
  // => success

▸ listWithReadStatus(maxRecent)

packages/@webex/plugin-rooms/src/rooms.js

Returns a list of rooms with details about the data of the last activity in the room, and the date of the users last presences in the room. The list is sorted with this with most recent activity first

For rooms where lastActivityDate > lastSeenDate the space can be considered to be "unread"

This differs from the rooms.list() function in the following ways: -- when called with no parameters it returns an array of all spaces, up to 1000, that the user is a member of -- pagination is not supported. ALL rooms are returned which can result in a large payload -- For users with hundreds of spaces, this API can take some time to to return, for this reason it supports an optional maxRecent parameter. If set this will return only the specified number of spaces with activity in the last two weeks. Recommended value is 30. Max supported is 100. -- only "id", "type", "lastActivityDate", and "lastSeenDate" are guaranteed to be available for each room in the list -- "title" is usually returned, but not guaranteed

In general this function should be used only when the client needs to access read status info, for example on startup. After startup, clients should track message and membership:seen events to maintain read status client side.

Since this API can take some time to return up to 1000 spaces, it is recommended that custom clients call this first with the maxRecent parameter set to 30, so that they can display some of the more recents spaces. Calling this API a second time with no parameters will return all the spaces.

Not all spaces may be returned, for example when users in more than 1000 spaces, or when a new spaces is added after this function is called, but before it returns. Custom clients should be prepared to gracefully handle cases where an event occurs in a space not returned by this call, by querying rooms.getWithReadStatus() with the id of the room in question

This function may be deprecated when this info is provided in the membership objects returned in the list function.

listWithReadStatus(maxRecent: int): Promise<RoomInfoObjectList>

Parameters

maxRecent

(int
            = 0)

Returns

Promise<RoomInfoObjectList>:

▸ getWithReadStatus(roomId)

packages/@webex/plugin-rooms/src/rooms.js

Returns a single room object with details about the data of the last activity in the room, and the date of the users last presence in the room.

For rooms where lastActivityDate > lastSeenDate the room can be considered to be "unread"

This differs from the rooms.get() function in the following ways: -- it takes a single roomId parameter to fetch -- no other options are considered -- only "id", "type", "lastActivityDate", and "lastSeenDate" are guaranteed to be available in the return object -- "title" is usually returned, but not guaranteed

In general clients should use the listWithReadStatus() method on startup to get the initial roomStatus and then update their client side copy by responding to message, membership and room events.

This function allows a custom client to be "nimble" if it is responding to an event with a roomId that was not in the original fetch. The anticipated behavior is that getWithReadStats is called "just in time", with the resulting room object being added to the list of cached room objects on the client side.

This function may be deprecated when this info is provided in the room object returned in the get function.

getWithReadStatus(roomId: string): Promise<RoomInfoObject>

Parameters

roomId (string)

Returns

Promise<RoomInfoObject>:

▸ remove(room)

packages/@webex/plugin-rooms/src/rooms.js

Deletes a single room.

remove(room: (RoomObject | string)): Promise

Parameters

room ((RoomObject | string))

Returns

Promise:

Example

var room;
webex.rooms.create({title: 'Remove Room Example'})
 .then(function(r) {
   room = r;
   return webex.rooms.remove(room.id);
 })
 .then(function() {
   return webex.rooms.get(room.id);
 })
 .then(function() {
   var assert = require('assert');
   assert(false, 'the previous get should have failed');
 })
 .catch(function(reason) {
   var assert = require('assert');
   assert.equal(reason.statusCode, 404);
   return 'success'
 });
 // => success

▸ update(room)

packages/@webex/plugin-rooms/src/rooms.js

Used to update a single room's properties.

update(room: RoomObject): Promise<RoomObject>

Parameters

room (RoomObject)

Returns

Promise<RoomObject>:

Example

var room;
webex.rooms.update({title: 'Update Room Example'})
  .then(function(r) {
    room = r;
    room.title = 'Update Room Example (Updated Title)';
    return webex.rooms.update(room);
  })
  .then(function() {
    return webex.rooms.get(room.id);
  })
  .then(function(room) {
   var assert = require('assert');
    assert.equal(room.title, 'Update Room Example (Updated Title)');
    return 'success';
  });
  // => success

Teams

packages/@webex/plugin-teams/src/teams.js

new Teams()

Instance Members

▸ create(team)

packages/@webex/plugin-teams/src/teams.js

Create a new team.

create(team: TeamObject): Promise<TeamObject>

Parameters

team (TeamObject)

Returns

Promise<TeamObject>:

Example

webex.teams.create({name: 'Create Team Example'})
  .then(function(team) {
    var assert = require('assert');
    assert(team.id);
    assert(team.name);
    assert(team.created);
    return 'success';
  });
  // => success

▸ get(team, options)

packages/@webex/plugin-teams/src/teams.js

Returns a single team

get(team: (TeamObject | string), options: Object): Promise<TeamObject>

Parameters

team ((TeamObject | string))

options (Object)

Returns

Promise<TeamObject>:

Example

var team;
webex.teams.create({name: 'Get Team Example'})
  .then(function(r) {
    team = r;
    return webex.teams.get(team.id);
  })
  .then(function(team2) {
    var assert = require('assert');
    assert.equal(team2.id, team.id);
    return 'success';
  });
  // => success

▸ list(options)

packages/@webex/plugin-teams/src/teams.js

List teams.

list(options: object): Promise<Page<TeamObject>>

Parameters

options (object)

Name	Description
options.max `object`	Limit the maximum number of teams in the response.

Returns

Promise<Page<TeamObject>>:

Example

var createdRooms;
Promise.all([
  webex.teams.create({name: 'List Teams Example 1'}),
  webex.teams.create({name: 'List Teams Example 2'}),
  webex.teams.create({name: 'List Teams Example 3'})
])
  .then(function(r) {
    createdRooms = r;
    return webex.teams.list({max: 3});
  })
  .then(function(teams) {
    var assert = require('assert');
    assert(teams.length === 3);
    for (var i = 0; i < teams.items.length; i+= 1) {
      assert(createdRooms.filter(function(room) {
        return room.id === teams.items[i].id;
      }).length === 1);
    }
    return 'success';
  });
  // => success

▸ update(team)

packages/@webex/plugin-teams/src/teams.js

Update a team.

update(team: TeamObject): Promise<TeamObject>

Parameters

team (TeamObject)

Returns

Promise<TeamObject>:

Example

var teams;
webex.teams.create({name: 'Update Team Example'})
  .then(function(r) {
    teams = r;
    teams.name = 'Teams Example (Updated Title)';
    return webex.teams.update(teams);
  })
  .then(function() {
    return webex.teams.get(teams.id);
  })
  .then(function(teams) {
    var assert = require('assert');
    assert.equal(teams.name, 'Teams Example (Updated Title)');
    return 'success';
  });
  // => success

TeamMemberships

packages/@webex/plugin-team-memberships/src/team-memberships.js

Team Memberships represent a person's relationship to a team. Use this API to list members of any team that you're in or create memberships to invite someone to a team. Team memberships can also be updated to make someone a moderator or deleted to remove them from the team.

Just like in the Webex app, you must be a member of the team in order to list its memberships or invite people.

new TeamMemberships()

Instance Members

▸ create(membership)

packages/@webex/plugin-team-memberships/src/team-memberships.js

Add someone to a team by Person ID or email address; optionally making them a moderator.

create(membership: TeamMembershipObject): Promise<TeamMembershipObject>

Parameters

membership (TeamMembershipObject)

Returns

Promise<TeamMembershipObject>:

Example

webex.teams.create({name: 'Create Team Membership Example'})
  .then(function(team) {
    return webex.teamMemberships.create({
     personEmail: 'alice@example.com',
     teamId: team.id
   });
  })
  .then(function(membership) {
    var assert = require('assert');
    assert(membership.id);
    assert(membership.teamId);
    assert(membership.personId);
    assert(membership.personEmail);
    assert('isModerator' in membership);
    assert(membership.created);
    return 'success';
  });
  // => success

▸ get(membership)

packages/@webex/plugin-team-memberships/src/team-memberships.js

Get details for a membership by ID.

get(membership: (TeamMembershipObject | string)): Promise<TeamMembershipObject>

Parameters

membership ((TeamMembershipObject | string))

Returns

Promise<TeamMembershipObject>:

Example

var membership;
webex.teams.create({name: 'Get Team Memberships Example'})
  .then(function(team) {
    return webex.teamMemberships.create({
      personEmail: 'alice@example.com',
      teamId: team.id
    });
  })
  .then(function(m) {
    membership = m;
    return webex.teamMemberships.get(m.id);
  })
  .then(function(m) {
    var assert = require('assert');
    assert.deepEqual(m, membership);
    return 'success';
  });
  // => success

▸ list(options)

packages/@webex/plugin-team-memberships/src/team-memberships.js

Lists all team memberships. By default, lists memberships for teams to which the authenticated user belongs.

list(options: Object): [type]

Parameters

options (Object)

Name	Description
options.max `string`

Returns

[type]:

Example

var team;
webex.teams.create({name: 'List Team Memberships Example'})
  .then(function(t) {
    team = t;
    return webex.teamMemberships.create({
     personEmail: 'alice@example.com',
     teamId: team.id
    });
  })
  .then(function() {
    return webex.teamMemberships.list({teamId: team.id});
  })
  .then(function(teamMemberships) {
    var assert = require('assert');
    assert.equal(teamMemberships.length, 2);
    for (var i = 0; i < teamMemberships.length; i+= 1) {
      assert.equal(teamMemberships.items[i].teamId, team.id);
    }
    return 'success';
  });
  // => success

▸ remove(membership)

packages/@webex/plugin-team-memberships/src/team-memberships.js

Deletes a membership by ID.

remove(membership: (TeamMembershipObject | string)): Promise

Parameters

membership ((TeamMembershipObject | string))

Returns

Promise:

Example

var membership, team;
webex.teams.create({name: 'Remove Team Memberships Example'})
  .then(function(t) {
    team = t;
    return webex.teamMemberships.create({
     personEmail: 'alice@example.com',
     teamId: team.id
    });
  })
  .then(function(m) {
    membership = m;
    return webex.teamMemberships.list({teamId: team.id});
  })
  .then(function(teamMemberships) {
    var assert = require('assert');
    assert.equal(teamMemberships.length, 2);
    return webex.teamMemberships.remove(membership);
  })
  .then(function() {
    return webex.teamMemberships.list({teamId: team.id});
  })
  .then(function(teamMemberships) {
    var assert = require('assert');
    assert.equal(teamMemberships.length, 1);
    return 'success';
  });
  // => success

▸ update(membership)

packages/@webex/plugin-team-memberships/src/team-memberships.js

Updates properties for a membership.

update(membership: TeamMembershipObject): Promise<TeamMembershipObject>

Parameters

membership (TeamMembershipObject)

Returns

Promise<TeamMembershipObject>:

Webhooks

Webhooks allow your app to be notified via HTTP when a specific event occurs on Webex. For example, your app can register a webhook to be notified when a new message is posted into a specific room.

new Webhooks()

Instance Members

▸ create(webhook)

Posts a webhook.

create(webhook: WebhookObject): Promise<Webhook>

Parameters

webhook (WebhookObject)

Returns

Promise<Webhook>:

Example

webex.rooms.create({title: 'Create Webhook Example'})
  .then(function(room) {
    return webex.webhooks.create({
      resource: 'messages',
      event: 'created',
      filter: 'roomId=' + room.id,
      targetUrl: 'https://example.com/webhook',
      name: 'Test Webhook'
    });
  })
  .then(function(webhook) {
    var assert = require('assert');
    assert(webhook.id);
    assert(webhook.resource);
    assert(webhook.event);
    assert(webhook.filter);
    assert(webhook.targetUrl);
    assert(webhook.name);
    return 'success';
  });
  // => success

▸ get(webhook)

Shows details for a webhook.

get(webhook: (Webhook | string)): Promise<Webhook>

Parameters

webhook ((Webhook | string))

Returns

Promise<Webhook>:

Example

var webhook;
webex.rooms.create({title: 'Get Webhook Example'})
  .then(function(room) {
    return webex.webhooks.create({
      resource: 'messages',
      event: 'created',
      filter: 'roomId=' + room.id,
      targetUrl: 'https://example.com/webhook',
      name: 'Test Webhook'
    });
  })
  .then(function(w) {
    webhook = w;
    return webex.webhooks.get(webhook.id);
  })
  .then(function(webhook2) {
    var assert = require('assert');
    assert.deepEqual(webhook2, webhook);
    return 'success';
  });
  // => success

▸ list(options)

Lists all webhooks.

list(options: Object): Promise<Array<Webhook>>

Parameters

options (Object)

Name	Description
options.max `integer`	Limit the maximum number of webhooks in the response.

Returns

Promise<Array<Webhook>>:

Example

var room, webhook;
webex.rooms.create({title: 'List Webhooks Example'})
  .then(function(r) {
    room = r;
    return webex.webhooks.create({
      resource: 'messages',
      event: 'created',
      filter: 'roomId=' + room.id,
      targetUrl: 'https://example.com/webhook',
      name: 'Test Webhook'
    });
  })
  .then(function(w) {
    webhook = w;
    return webex.webhooks.list();
  })
  .then(function(webhooks) {
    var assert = require('assert');
    assert.equal(webhooks.items.filter(function(w) {
      return w.id === webhook.id;
    }).length, 1);
    return 'success';
  });
  // => success

▸ remove(webhook)

Delete a webhook.

remove(webhook: (Webhook | string)): Promise

Parameters

webhook ((Webhook | string))

Returns

Promise:

Example

var room, webhook;
webex.rooms.create({title: 'Remove Webhook Example'})
  .then(function(r) {
    room = r;
    return webex.webhooks.create({
      resource: 'messages',
      event: 'created',
      filter: 'roomId=' + room.id,
      targetUrl: 'https://example.com/webhook',
      name: 'Test Webhook'
    });
  })
  .then(function(w) {
    webhook = w;
    return webex.webhooks.remove(webhook);
  })
  .then(function() {
    return webex.webhooks.list();
  })
  .then(function(webhooks) {
    var assert = require('assert');
    assert.equal(webhooks.items.filter(function(w) {
      return w.id === webhook.id;
    }).length, 0);
    return 'success';
  });
  // => success

▸ update(webhook)

Update a webhook.

update(webhook: Webhook): Promise<Webhook>

Parameters

webhook (Webhook)

Returns

Promise<Webhook>:

Example

var webhook;
webex.rooms.create({title: 'Webhook Example'})
  .then(function(room) {
    return webex.webhooks.create({
      resource: 'messages',
      event: 'created',
      filter: 'roomId=' + room.id,
      targetUrl: 'https://example.com/webhook',
      name: 'Test Webhook'
    });
  })
  .then(function(w) {
    webhook = w;
    webhook.targetUrl = 'https://example.com/webhook/newtarget';
    return webex.webhooks.update(webhook);
  })
  .then(function() {
    return webex.webhooks.get(webhook);
  })
  .then(function(webhook) {
    var assert = require('assert');
    assert.equal(webhook.targetUrl, 'https://example.com/webhook/newtarget');
    return 'success';
  });
  // => success

Logger

packages/@webex/plugin-logger/src/logger.js

new Logger()

Instance Members

▸ formatLogs()

packages/@webex/plugin-logger/src/logger.js

Format logs (for upload)

If separate client, SDK buffers is configured, merge the buffers, if configured

formatLogs(): string

Returns

string: formatted buffer

LoggerConfig

packages/@webex/plugin-logger/src/config.js

LoggerConfig

Type: Object

Properties

historyLength (number?) : Maximum number of entries to store in the log buffer.

Example

{
  level: process.env.WEBEX_LOG_LEVEL,
  historyLength: 1000
}

MembershipObject

packages/@webex/plugin-memberships/src/memberships.js

MembershipObject

Type: Object

Properties

id (string) : Unique identifier for the membership

roomId (string) : The room ID

personId (string) : The person ID

personEmail (email) : The email address of the person / room member

isModerator (boolean) : Indicates whether the specified person should be a room moderator

isMonitor (boolean) : Indicates whether the specified member is a room monitor

created (isoDate) : The date and time that this membership was created

MessageObject

MessageObject

Type: Object

Properties

id (string) : (server generated) Unique identifier for the message

personId (string) : The ID for the author of the message

personEmail (email) : The email for the author of the message

roomId (string) : The ID for the room of the message

text (string) : The message posted to the room in plain text

markdown (string) : The message posted to the room in markdown

files (Array<string>) : The source URL(s) for the message attachment(s). See the Message Attachments Guide for a list of supported media types.

created (isoDate) : (server generated) The date and time that the message was created

PersonObject

packages/@webex/plugin-people/src/people.js

PersonObject

Type: Object

Properties

id (string) : (server generated) Unique identifier for the person

emails (Array<email>) : Email addresses of the person

displayName (string) : Display name of the person

created (isoDate) : (server generated) The date and time that the person was created

RoomObject

packages/@webex/plugin-rooms/src/rooms.js

RoomObject

Type: Object

Properties

id (string) : (server generated) Unique identifier for the room

title (string) : The display name for the room. All room members will see the title so make it something good

teamId (string) : (optional) The ID of the team to which the room belongs

created (isoDate) : (server generated) The date and time that the room was created

TeamObject

packages/@webex/plugin-teams/src/teams.js

TeamObject

Type: Object

Properties

id (string) : (server generated) Unique identifier for the team

name (string) : The name of the team

created (isoDate) : (server generated) The date and time that the team was created

TeamMembershipObject

packages/@webex/plugin-team-memberships/src/team-memberships.js

TeamMembershipObject

Type: Object

Properties

id (string) : (server generated) Unique identifier for the team membership

teamId (string) : The team ID

personId (string) : The person ID

personEmail (string) : The email address of the person

isModerator (boolean) : Set to true to make the person a team moderator

created (string) : (server generated) The date and time that the team membership was created

WebhookObject

WebhookObject

Type: Object

Properties

id (string) : (server generated) Unique identifier for the webhook

resource (string) : The resource type for the webhook

event (string) : The event type for the webhook

filter (string) : The filter that defines the webhook scope

targetUrl (string) : The URL that receives POST requests for each event

name (string) : A user-friendly name for this webhook

created (string) : (server generated) The date and time that the webhook was created

email

packages/webex/src/index.js

An email address, as a string.

email

Type: string

isoDate

packages/webex/src/index.js

The date and time, specified in ISO 8601 extended offset date/time format (e.g. 2015-10-18T14:26:16+00:00).

isoDate

Type: string

AttachmentActionObject

packages/@webex/plugin-attachment-actions/src/attachmentActions.js

AttachmentActionObject

Type: Object

Properties

id (string) : (server generated) Unique identifier for the attachment action

messageId (string) : The ID of the message in which attachment action is to be performed

type (string) : The type of attachment action eg., submit

inputs (Object) : The inputs for form fields in attachment message

personId (string) : (server generated) The ID for the author of the attachment action

roomId (string) : (server generated) The ID for the room of the message

created (isoDate) : (server generated) The date and time that the message was created

AttachmentActions

packages/@webex/plugin-attachment-actions/src/attachmentActions.js

AttachmentActions are events that communicate information when a user clicks on an Action.Submit button in a card displayed in Webex Information conveyed in an AttachmentAction includes details about the user that clicked the button along with any card specific inputs. See the Attachments Actions API Documentation for more details

new AttachmentActions()

Instance Members

▸ create(attachmentAction)

packages/@webex/plugin-attachment-actions/src/attachmentActions.js

Post a new attachment action for a message with attachment.

create(attachmentAction: AttachmentActionObject): Promise<AttachmentActionObject>

Parameters

attachmentAction (AttachmentActionObject)

Returns

Promise<AttachmentActionObject>:

Example

webex.rooms.create({title: 'Create Message with card Example'})
  .then(function(room) {
    return webex.messages.create({
      text: 'Howdy!',
      roomId: room.id,
      attachments:[ {
         contentType: 'application/vnd.microsoft.card.adaptive',
        content: {
          type: 'AdaptiveCard',
          version: '1.0',
          body: [
           {
            type: 'TextBlock',
            text: '',
            size: 'large'
            },
          {
            type: 'TextBlock',
            text: 'Adaptive Cards',
            separation: 'none'
          }
          {
          type: 'Input.Date',
          id: 'dueDate'
          }
      ],
    actions: [
        {
            type: 'Action.Submit',
            title: 'Due Date'
        }
    ]
  }
 }]
    });
  })
  .then(function(message) {
   return webex.attachmentActions.create({
     type: 'submit',
     messageId: message.id,
     inputs:{
       dueDate: '26/06/1995'
     }
   })
   .then(function(attachmentAction)){
     var assert = require('assert');
     assert(attachmentAction.id);
     assert(attachmentAction.type);
     assert(attachmentAction.personId);
     assert(attachmentAction.inputs);
     assert(attachmentAction.messageId);
     assert(attachmentAction.roomId);
     assert(attachmentAction.created);
     return 'success';
    }
  });
  // => success

▸ get(attachmentAction)

packages/@webex/plugin-attachment-actions/src/attachmentActions.js

Returns a single attachment action.

get(attachmentAction: string): Promise<AttachmentActionObject>

Parameters

attachmentAction (string)

Returns

Promise<AttachmentActionObject>:

Example

var attachmentAction;
webex.rooms.create({title: 'Get Message Example'})
  .then(function(room) {
    return webex.messages.create({
      text: 'Howdy!',
      roomId: room.id,
      attachments:[ {
         contentType: 'application/vnd.microsoft.card.adaptive',
        content: {
          type: 'AdaptiveCard',
          version: '1.0',
          body: [
           {
            type: 'TextBlock',
            text: '',
            size: 'large'
            },
          {
            type: 'TextBlock',
            text: 'Adaptive Cards',
            separation: 'none'
          },
          {
          type: 'Input.Date',
          id: 'dueDate'
          }
      ],
    actions: [
        {
            type: 'Action.Submit',
            title: 'Due Date'
        }
    ]
  }
 }]
    });
  })
  .then(function(message) {
    return webex.attachmentActions.create({
     type: 'submit',
     messageId: message.id,
     inputs:{
       dueDate: '26/06/1995'
     });
  })
  .then(function(attachmentAction) {
    return webex.attachmentActions.get(attachmentAction.id)
  })
   .then(function(attachmentAction){
       var assert = require('assert');
       assert.deepEqual(attachmentAction, attachmentAction);
       return 'success';
     })
  // => success

getAll

packages/@webex/plugin-device-manager/src/device-manager.js

Gets a list of all recent devices associated with the user the device list gets populated from Redis

getAll(): Promise<Device>

Returns

Promise<Device>:

refresh

packages/@webex/plugin-device-manager/src/device-manager.js

Gets a list of all recent devices associated with the user the device list gets populated from Redis

refresh(): Promise<Device>

Returns

Promise<Device>:

search

packages/@webex/plugin-device-manager/src/device-manager.js

Search for a device by name

search(options: Object): Promise<Device>

Parameters

options (Object)

Name	Description
options.searchQuery `string`

Returns

Promise<Device>:

upsert

packages/@webex/plugin-device-manager/src/device-manager.js

Caches the device info and also registers to Redis for subsequent fetches

upsert(device: Object): deviceInfo

Parameters

device (Object)

Name	Description
device.id `string`

Returns

deviceInfo:

get

packages/@webex/plugin-device-manager/src/device-manager.js

Retreives device info of a particular device

get(token: string): Promise<deviceInfo>

Parameters

token (string)

Returns

Promise<deviceInfo>:

remove

packages/@webex/plugin-device-manager/src/device-manager.js

Unregisters the device from Redis, will not fetch in subsequent loads, similar to space.deleteBinding()

remove(deviceId: string): Promise<deviceInfo>

Parameters

deviceId (string)

Returns

Promise<deviceInfo>:

requestPin

packages/@webex/plugin-device-manager/src/device-manager.js

Requests to display PIN on the device

requestPin(device: object, options: object): Promise<deviceInfo>

Parameters

device (object)

options

(object
            = {})

Name	Description
options.data `object`

Returns

Promise<deviceInfo>:

pair

packages/@webex/plugin-device-manager/src/device-manager.js

pairs the device with the user (manual pairing), also adds it to user's recents list for subsequent fetches. similar to space.join()

pair(options: object): Promise<deviceInfo>

Parameters

options

(object
            = {})

Name	Description
options.pin `number`

Returns

Promise<deviceInfo>:

unpair

packages/@webex/plugin-device-manager/src/device-manager.js

unpairs the device with the user (manual/ultrasonic pairing), but still keeps in the recents list/does not remove from Redis options.removeAllDevices will remove all associated devices to user similar to space.leave()

unpair(options: object): Promise<deviceInfo>

Parameters

options

(object
            = {})

Name	Description
options.removeAllDevices `boolean`

Returns

Promise<deviceInfo>:

bindSpace

packages/@webex/plugin-device-manager/src/device-manager.js

binds the space to the paired device (if supported) similar to space.bindConversation()

bindSpace(options: object): Promise<deviceInfo>

Parameters

options

(object
            = {})

Name	Description
options.url `boolean`	, conversation url
options.kmsResourceObjectUrl `boolean`	of the convo

Returns

Promise<deviceInfo>:

unbindSpace

packages/@webex/plugin-device-manager/src/device-manager.js

unbinds the space to the paired device (if supported) similar to space.unbindConversation()

unbindSpace(): Promise<deviceInfo>

Returns

Promise<deviceInfo>:

getAudioState

packages/@webex/plugin-device-manager/src/device-manager.js

Gets the audio state of the paired device similar to device.getAudioState()

getAudioState(): Promise<audioState>

Returns

Promise<audioState>:

putAudioState

packages/@webex/plugin-device-manager/src/device-manager.js

Updates audio state of the paired device, should be called every 10 minutes or when mic or volume state is changed similar to device.putAudioState()

putAudioState(space: object, audioState: object): Promise<audioState>

Parameters

space (object)

audioState

(object
            = {})

Returns

Promise<audioState>:

mute

packages/@webex/plugin-device-manager/src/device-manager.js

Mutes paired device similar to device.mute()

mute(): Promise<audioState>

Returns

Promise<audioState>:

unmute

packages/@webex/plugin-device-manager/src/device-manager.js

Unmutes paired device similar to device.unmute()

unmute(): Promise<audioState>

Returns

Promise<audioState>:

increaseVolume

packages/@webex/plugin-device-manager/src/device-manager.js

Increases paired device's volume similar to device.increaseVolume()

increaseVolume(): Promise<audioState>

Returns

Promise<audioState>:

decreaseVolume

packages/@webex/plugin-device-manager/src/device-manager.js

Decreases paired device's volume similar to device.decreaseVolume()

decreaseVolume(): Promise<audioState>

Returns

Promise<audioState>:

setVolume

packages/@webex/plugin-device-manager/src/device-manager.js

Sets paired device's volume but should use increase and decrease api instead similar to device.setVolume()

setVolume(level: number): Promise<audioState>

Parameters

level

(number
            = 0)

Returns

Promise<audioState>:

_updateDeviceMetadata

packages/@webex/plugin-device-manager/src/device-manager.js

Utility function to update decrypted device name on device object

_updateDeviceMetadata(deviceArray: Array): device

Parameters

deviceArray

(Array
            = [])

Returns

device:

_decryptDeviceName

packages/@webex/plugin-device-manager/src/device-manager.js

Utility function to update decrypted device name on device object

_decryptDeviceName(inDevice: object): device

Parameters

inDevice

(object
            = {})

Returns

device:

_receiveDeviceUpdates

packages/@webex/plugin-device-manager/src/device-manager.js

Utility function to update device info on mercury updates

_receiveDeviceUpdates(device: object): device

Parameters

device (object)

Returns

device:

BasicMeetingInformation

packages/@webex/plugin-meetings/src/meetings/index.ts

Object containing only the most basic information about a meeting. This is the information that is kept even after the meeting is deleted from the MeetingCollection

BasicMeetingInformation

Type: {allowMediaInLobby: boolean, correlationId: string, environment: string, id: string, locusUrl: string, locusInfo: {url: string, fullState: {lastActive: string, sessionId: string}}, meetingInfo: any, sessionCorrelationId: string}

Properties

allowMediaInLobby (boolean)

correlationId (string)

environment (string)

id (string)

locusUrl (string)

locusInfo ({url: string, fullState: {lastActive: string, sessionId: string}})

meetingInfo (any)

sessionCorrelationId (string)

LogsRequest

packages/@webex/plugin-meetings/src/common/logs/request.ts

new LogsRequest()

Static Members

▸ uploadLogs(options)

packages/@webex/plugin-meetings/src/common/logs/request.ts

Uploads logs to the support server

uploadLogs(options: Object): Promise<String>

Parameters

options

(Object
            = {})

Name	Description
options.feedbackId `String` (default `uuid.v4`)	ID used for tracking
options.locusId `String?`
options.correlationId `String?`
options.callStart `String?`	Call Start Time
options.meetingId `String?`	webex meeting ID

Returns

Promise<String>: Feedback ID

MediaDirection

MediaDirection

Type: Object

Properties

sendAudio (boolean)

receiveAudio (boolean)

sendVideo (boolean)

receiveVideo (boolean)

sendShare (boolean)

receiveShare (boolean)

MediaDirection

packages/@webex/plugin-meetings/src/meeting/index.ts

MediaDirection

Type: Object

Properties

sendAudio (boolean)

receiveAudio (boolean)

sendVideo (boolean)

receiveVideo (boolean)

sendShare (boolean)

receiveShare (boolean)

isSharing (boolean)

SendOptions

SendOptions

Type: Object

Properties

sharePreferences (Object)

Media

Media

Type: any

Static Members

▸ getLocalMedia(options, config)

make a browser call to get the media

getLocalMedia(options: SendOptions, config: Object): Promise

Parameters

options (SendOptions)

config (Object) SDK Configuration for meetings plugin

Returns

Promise:

▸ createMediaConnection(isMultistream, debugId, meetingId, options)

creates a webrtc media connection with provided tracks and mediaDirection configuration

createMediaConnection(isMultistream: boolean, debugId: string, meetingId: string, options: Object): (RoapMediaConnection | MultistreamRoapMediaConnection)

Parameters

isMultistream (boolean)

debugId (string) string useful for debugging (will appear in media connection logs)

meetingId (string) id for the meeting using this connection

options (Object)

Name	Description
options.mediaProperties `Object?`	contains mediaDirection and local tracks: audioTrack, videoTrack, shareVideoTrack, and shareAudioTrack
options.remoteQualityLevel `string?`	LOW\|MEDIUM\|HIGH applicable only to non-multistream connections
options.enableRtx `boolean?`	applicable only to non-multistream connections
options.enableExtmap `boolean?`	applicable only to non-multistream connections
options.turnServerInfo `Object?`
options.bundlePolicy `BundlePolicy?`

Returns

(RoapMediaConnection | MultistreamRoapMediaConnection):

▸ getDisplayMedia(options, config)

generates share streams

getDisplayMedia(options: Object, config: Object): Promise<MediaStream>

Parameters

options (Object) parameter

Name	Description
options.sendAudio `Boolean`	send audio from the display share
options.sendShare `Boolean`	send video from the display share
options.sharePreferences `Object`
options.sharePreferences.shareConstraints `MediaTrackConstraints`	constraints to apply to video
options.sharePreferences.highFrameRate `Boolean`	if shareConstraints isn't provided, set default values based off of this boolean

config

(Object
            = {})

SDK Configuration for meetings plugin

Returns

Promise<MediaStream>:

▸ getMedia(audio, video, config)

generates audio and video using constraints (often called after getSupportedDevices)

getMedia(audio: (Object | Boolean), video: (Object | Boolean), config: Object): Object

Parameters

audio ((Object | Boolean)) gum constraints

video ((Object | Boolean)) gum constraints

config (Object) SDK Configuration for meetings plugin

Returns

Object: {streams}

▸ toggleStream()

Toggle a specific stream noop as of now, does nothing

toggleStream(): null

Returns

null:

▸ stopStream(stream)

Stop input stream

stopStream(stream: LocalStream): null

Parameters

stream (LocalStream) A local stream

Returns

null:

▸ getUserMedia(mediaSetting, audioVideo, sharePreferences, config)

generates streams for audio video and share

getUserMedia(mediaSetting: object, audioVideo: Object, sharePreferences: Object, config: Object): Array

Parameters

mediaSetting (object) parameter

Name	Description
mediaSetting.sendAudio `Object`	sendAudio: {Boolean} sendAudio constraints
mediaSetting.sendVideo `Object`	sendVideo: {Boolean} sendVideo constraints
mediaSetting.sendShare `Object`	sendShare: {Boolean} sendShare constraints
mediaSetting.isSharing `Object`	isSharing: {Boolean} isSharing constraints

audioVideo (Object) parameter

Name	Description
audioVideo.audio `Object`	{deviceId: {String}}
audioVideo.video `Object`	{deviceId: {String}}

sharePreferences (Object) parameter

Name	Description
sharePreferences.shareConstraints `Object`	parameter
sharePreferences.highFrameRate `Boolean`	parameter

config (Object) SDK Config

Returns

Array: [localStream, shareStream]

getIpVersion

packages/@webex/plugin-meetings/src/meeting/util.ts

Returns the current state of knowledge about whether we are on an ipv4-only or ipv6-only or mixed (ipv4 and ipv6) network. The return value matches the possible values of "ipver" parameter used by the backend APIs.

getIpVersion(webex: Object): (IP_VERSION | undefined)

Parameters

webex (Object) webex instance

Returns

(IP_VERSION | undefined): ipver value to be passed to the backend APIs or undefined if we should not pass any value to the backend

prepareLeaveMeetingOptions

packages/@webex/plugin-meetings/src/meeting/util.ts

Returns options for leaving a meeting.

prepareLeaveMeetingOptions(meeting: any, options: any): any

Parameters

meeting (any)

options

(any
            = {})

Returns

any: leave options

buildLeaveFetchRequestOptions

packages/@webex/plugin-meetings/src/meeting/util.ts

Returns request options for leaving a meeting.

buildLeaveFetchRequestOptions(meeting: any, options: any): any

Parameters

meeting (any)

options

(any
            = {})

Returns

any: request options

addSequence

packages/@webex/plugin-meetings/src/meeting/util.ts

Adds the current locus sequence information to a request body

addSequence(meeting: Object, requestBody: Object): void

Parameters

meeting (Object) The meeting object

requestBody (Object) The body of a request to locus

Returns

void:

updateLocusWithDelta

packages/@webex/plugin-meetings/src/meeting/util.ts

Updates the locus info for the meeting with the delta locus returned from requests that include the sequence information Returns the original response object

updateLocusWithDelta(meeting: Object, response: Object): Object

Parameters

meeting (Object) The meeting object

response (Object) The response of the http request

Returns

Object:

getChangeMeetingFloorErrorPayload

packages/@webex/plugin-meetings/src/meeting/util.ts

Returns a CA-recognized error payload for the specified raw error message/reason.

New errors can be added to this function for handling in the future

getChangeMeetingFloorErrorPayload(reason: String): Array<object>

Parameters

reason (String) the raw error message

Returns

Array<object>: an array of payload objects

MeetingInfo

packages/@webex/plugin-meetings/src/meeting-info/index.ts

new MeetingInfo()

Static Members

▸ getMeetingInfo(id)

packages/@webex/plugin-meetings/src/meeting-info/index.ts

getMeetingInfo(id: string): object

Parameters

id (string)

Returns

object:

▸ setMeetingInfo(id, info)

packages/@webex/plugin-meetings/src/meeting-info/index.ts

setMeetingInfo(id: string, info: object): null

Parameters

id (string)

info (object)

Returns

null:

▸ fetchInfoOptions(destination, type = null)

packages/@webex/plugin-meetings/src/meeting-info/meeting-info-v2.ts

converts hydra id into conversation url and persons Id

fetchInfoOptions(destination: String, type: String?): Promise

Parameters

destination (String) one of many different types of destinations to look up info for

type

(String?
            = null)

to match up with the destination value

Returns

Promise: destination and type

▸ fetchMeetingInfo(destination, type = null, password = null, captchaInfo = null, installedOrgID = null, locusId = null, extraParams = {}, options = {})

packages/@webex/plugin-meetings/src/meeting-info/index.ts

Fetches meeting info from the server

fetchMeetingInfo(destination: String, type: DESTINATION_TYPE?, password: String?, captchaInfo: Object?, installedOrgID: String?, locusId: String?, extraParams: Object?, options: Boolean?): Promise

Parameters

destination (String) one of many different types of destinations to look up info for

type

(DESTINATION_TYPE?
            = null)

to match up with the destination value

password

(String?
            = null)

meeting password

captchaInfo

(Object?
            = null)

captcha code and id

installedOrgID

(String?
            = null)

locusId

(String?
            = null)

extraParams

(Object?
            = {})

options

(Boolean?
            = {})

meeting Id and whether Call Analyzer events should be sent

Returns

Promise: returns a meeting info object

▸ fetchMeetingInfo(destination, type = null, password, captchaInfo, installedOrgID, locusId, extraParams, options)

packages/@webex/plugin-meetings/src/meeting-info/meeting-info-v2.ts

Fetches meeting info from the server

fetchMeetingInfo(destination: String, type: DESTINATION_TYPE?, password: String, captchaInfo: Object, installedOrgID: String, locusId: String, extraParams: Object, options: Object): Promise

Parameters

destination (String) one of many different types of destinations to look up info for

type

(DESTINATION_TYPE?
            = null)

to match up with the destination value

password

(String
            = null)

captchaInfo

(Object
            = null)

Name	Description
captchaInfo.code `String`
captchaInfo.id `String`

installedOrgID

(String
            = null)

org ID of user's machine

locusId

(String
            = null)

extraParams

(Object
            = {})

options

(Object
            = {})

Returns

Promise: returns a meeting info object

▸ createAdhocSpaceMeeting(conversationUrl, installedOrgID)

packages/@webex/plugin-meetings/src/meeting-info/meeting-info-v2.ts

Creates adhoc space meetings for a space by fetching the conversation infomation

createAdhocSpaceMeeting(conversationUrl: String, installedOrgID: String): Promise

Parameters

conversationUrl (String) conversationUrl to start adhoc meeting on

installedOrgID (String) org ID of user's machine

Returns

Promise: returns a meeting info object

MeetingInfo

packages/@webex/plugin-meetings/src/meeting-info/meeting-info-v2.ts

new MeetingInfo()

Static Members

▸ getMeetingInfo(id)

packages/@webex/plugin-meetings/src/meeting-info/index.ts

getMeetingInfo(id: string): object

Parameters

id (string)

Returns

object:

▸ setMeetingInfo(id, info)

packages/@webex/plugin-meetings/src/meeting-info/index.ts

setMeetingInfo(id: string, info: object): null

Parameters

id (string)

info (object)

Returns

null:

▸ fetchInfoOptions(destination, type = null)

packages/@webex/plugin-meetings/src/meeting-info/meeting-info-v2.ts

converts hydra id into conversation url and persons Id

fetchInfoOptions(destination: String, type: String?): Promise

Parameters

destination (String) one of many different types of destinations to look up info for

type

(String?
            = null)

to match up with the destination value

Returns

Promise: destination and type

▸ fetchMeetingInfo(destination, type = null, password = null, captchaInfo = null, installedOrgID = null, locusId = null, extraParams = {}, options = {})

packages/@webex/plugin-meetings/src/meeting-info/index.ts

Fetches meeting info from the server

fetchMeetingInfo(destination: String, type: DESTINATION_TYPE?, password: String?, captchaInfo: Object?, installedOrgID: String?, locusId: String?, extraParams: Object?, options: Boolean?): Promise

Parameters

destination (String) one of many different types of destinations to look up info for

type

(DESTINATION_TYPE?
            = null)

to match up with the destination value

password

(String?
            = null)

meeting password

captchaInfo

(Object?
            = null)

captcha code and id

installedOrgID

(String?
            = null)

locusId

(String?
            = null)

extraParams

(Object?
            = {})

options

(Boolean?
            = {})

meeting Id and whether Call Analyzer events should be sent

Returns

Promise: returns a meeting info object

▸ fetchMeetingInfo(destination, type = null, password, captchaInfo, installedOrgID, locusId, extraParams, options)

packages/@webex/plugin-meetings/src/meeting-info/meeting-info-v2.ts

Fetches meeting info from the server

fetchMeetingInfo(destination: String, type: DESTINATION_TYPE?, password: String, captchaInfo: Object, installedOrgID: String, locusId: String, extraParams: Object, options: Object): Promise

Parameters

destination (String) one of many different types of destinations to look up info for

type

(DESTINATION_TYPE?
            = null)

to match up with the destination value

password

(String
            = null)

captchaInfo

(Object
            = null)

Name	Description
captchaInfo.code `String`
captchaInfo.id `String`

installedOrgID

(String
            = null)

org ID of user's machine

locusId

(String
            = null)

extraParams

(Object
            = {})

options

(Object
            = {})

Returns

Promise: returns a meeting info object

▸ createAdhocSpaceMeeting(conversationUrl, installedOrgID)

packages/@webex/plugin-meetings/src/meeting-info/meeting-info-v2.ts

Creates adhoc space meetings for a space by fetching the conversation infomation

createAdhocSpaceMeeting(conversationUrl: String, installedOrgID: String): Promise

Parameters

conversationUrl (String) conversationUrl to start adhoc meeting on

installedOrgID (String) org ID of user's machine

Returns

Promise: returns a meeting info object

MeetingInfoCollection

packages/@webex/plugin-meetings/src/meeting-info/collection.ts

new MeetingInfoCollection()

Static Members

▸ get(id)

packages/@webex/plugin-meetings/src/meeting-info/collection.ts

get(id: String): MeetingInfo

Parameters

id (String) ID of the meeting info you wish to retreive

Returns

MeetingInfo: returns a meeting info instance

MeetingInfoRequest

packages/@webex/plugin-meetings/src/meeting-info/request.ts

new MeetingInfoRequest()

Static Members

▸ fetchMeetingInfo(options)

packages/@webex/plugin-meetings/src/meeting-info/request.ts

fetchMeetingInfo(options: Object): Promise

Parameters

options (Object) with format of {type: String, desintation: String} where type is PERSONAL_ROOM, SIP_URI, CONVERSATION_URL, and destination is userId, sipUri, conversationUrl respectively type can also be specified as an option and be of the list SIP_URI,MEETING_ID,LOCUS_ID,PERSONAL_ROOM,MEETING_LINK,ONE_ON_ONE,MEDIA_SIP_URI,CONVERSATION_URL,TEMP_SIP_URI with the desination matching

Returns

Promise: returns a promise that resolves/rejects the result of the request

Throws

Error: if the options are not valid and complete

MeetingInfoRequest

packages/@webex/plugin-meetings/src/personal-meeting-room/request.ts

new MeetingInfoRequest()

Static Members

▸ fetchMeetingInfo(options)

packages/@webex/plugin-meetings/src/meeting-info/request.ts

fetchMeetingInfo(options: Object): Promise

Parameters

options (Object) with format of {type: String, desintation: String} where type is PERSONAL_ROOM, SIP_URI, CONVERSATION_URL, and destination is userId, sipUri, conversationUrl respectively type can also be specified as an option and be of the list SIP_URI,MEETING_ID,LOCUS_ID,PERSONAL_ROOM,MEETING_LINK,ONE_ON_ONE,MEDIA_SIP_URI,CONVERSATION_URL,TEMP_SIP_URI with the desination matching

Returns

Promise: returns a promise that resolves/rejects the result of the request

Throws

Error: if the options are not valid and complete

MeetingInfoUtil

packages/@webex/plugin-meetings/src/meeting-info/util.ts

new MeetingInfoUtil()

Static Members

▸ isMeetingLink(value)

packages/@webex/plugin-meetings/src/meeting-info/util.ts

Helper function to check if a string matches a known meeting link pattern

isMeetingLink(value: String): Boolean

Parameters

value (String) string to parse and see if it matches a meeting link

Returns

Boolean:

▸ isMeetingLink(value)

packages/@webex/plugin-meetings/src/meeting-info/utilv2.ts

Helper function to check if a string matches a known meeting link pattern

isMeetingLink(value: String): Boolean

Parameters

value (String) string to parse and see if it matches a meeting link

Returns

Boolean:

▸ getResourceUrl(type, value)

packages/@webex/plugin-meetings/src/meeting-info/util.ts

Helper function to build up a correct locus url depending on the value passed

getResourceUrl(type: DESTINATION_TYPE, value: Object): Object

Parameters

type (DESTINATION_TYPE) One of [SIP_URI, PERSONAL_ROOM, MEETING_ID, CONVERSATION_URL, LOCUS_ID, MEETING_LINK]

value (Object) ?? value.value

Returns

Object: returns an object with {resource, method}

▸ getRequestBody(options)

packages/@webex/plugin-meetings/src/meeting-info/utilv2.ts

Helper function to build up a correct locus url depending on the value passed

getRequestBody(options: Object): Object

Parameters

options (Object) type and value to fetch meeting info

Name	Description
options.type `DESTINATION_TYPE`	One of [SIP_URI, PERSONAL_ROOM, MEETING_ID, CONVERSATION_URL, LOCUS_ID, MEETING_LINK]
options.installedOrgID `String`	org ID of user's machine
options.destination `Object`	?? value.value

Returns

Object: returns an object with {resource, method}

▸ getWebexSite(uri)

packages/@webex/plugin-meetings/src/meeting-info/utilv2.ts

Helper function to parse the webex site/host from a URI string.

getWebexSite(uri: String): String

Parameters

uri (String) string (e.g. ' 10019857020@convergedats.webex.com ')

Returns

String: the site/host part of the URI string (e.g. 'convergedats.webex.com')

▸ getDirectMeetingInfoURI(options)

packages/@webex/plugin-meetings/src/meeting-info/utilv2.ts

Helper function to return the direct URI for fetching meeting info (to avoid a redirect).

getDirectMeetingInfoURI(options: Object): String

Parameters

options (Object) type and value to fetch meeting info

Name	Description
options.type `String`	One of [SIP_URI, PERSONAL_ROOM, MEETING_ID, CONVERSATION_URL, LOCUS_ID, MEETING_LINK]
options.destination `Object`	?? value.value

Returns

String: returns a URI string or null of there is no direct URI

MeetingInfoUtil

packages/@webex/plugin-meetings/src/meeting-info/utilv2.ts

new MeetingInfoUtil()

Static Members

▸ isMeetingLink(value)

packages/@webex/plugin-meetings/src/meeting-info/util.ts

Helper function to check if a string matches a known meeting link pattern

isMeetingLink(value: String): Boolean

Parameters

value (String) string to parse and see if it matches a meeting link

Returns

Boolean:

▸ isMeetingLink(value)

packages/@webex/plugin-meetings/src/meeting-info/utilv2.ts

Helper function to check if a string matches a known meeting link pattern

isMeetingLink(value: String): Boolean

Parameters

value (String) string to parse and see if it matches a meeting link

Returns

Boolean:

▸ getResourceUrl(type, value)

packages/@webex/plugin-meetings/src/meeting-info/util.ts

Helper function to build up a correct locus url depending on the value passed

getResourceUrl(type: DESTINATION_TYPE, value: Object): Object

Parameters

type (DESTINATION_TYPE) One of [SIP_URI, PERSONAL_ROOM, MEETING_ID, CONVERSATION_URL, LOCUS_ID, MEETING_LINK]

value (Object) ?? value.value

Returns

Object: returns an object with {resource, method}

▸ getRequestBody(options)

packages/@webex/plugin-meetings/src/meeting-info/utilv2.ts

Helper function to build up a correct locus url depending on the value passed

getRequestBody(options: Object): Object

Parameters

options (Object) type and value to fetch meeting info

Name	Description
options.type `DESTINATION_TYPE`	One of [SIP_URI, PERSONAL_ROOM, MEETING_ID, CONVERSATION_URL, LOCUS_ID, MEETING_LINK]
options.installedOrgID `String`	org ID of user's machine
options.destination `Object`	?? value.value

Returns

Object: returns an object with {resource, method}

▸ getWebexSite(uri)

packages/@webex/plugin-meetings/src/meeting-info/utilv2.ts

Helper function to parse the webex site/host from a URI string.

getWebexSite(uri: String): String

Parameters

uri (String) string (e.g. ' 10019857020@convergedats.webex.com ')

Returns

String: the site/host part of the URI string (e.g. 'convergedats.webex.com')

▸ getDirectMeetingInfoURI(options)

packages/@webex/plugin-meetings/src/meeting-info/utilv2.ts

Helper function to return the direct URI for fetching meeting info (to avoid a redirect).

getDirectMeetingInfoURI(options: Object): String

Parameters

options (Object) type and value to fetch meeting info

Name	Description
options.type `String`	One of [SIP_URI, PERSONAL_ROOM, MEETING_ID, CONVERSATION_URL, LOCUS_ID, MEETING_LINK]
options.destination `Object`	?? value.value

Returns

String: returns a URI string or null of there is no direct URI

PersonalMeetingRoom

packages/@webex/plugin-meetings/src/personal-meeting-room/index.ts

new PersonalMeetingRoom()

Static Members

▸ claim(link, pin, preferred = true)

packages/@webex/plugin-meetings/src/personal-meeting-room/index.ts

claims a pmr and updates the cached PMR values

claim(link: String, pin: String, preferred: Boolean?): Promise

Parameters

link (String)

pin (String)

preferred

(Boolean?
            = true)

defaults to true to set this claimed PMR as the preferred

Returns

Promise:

▸ get(options)

packages/@webex/plugin-meetings/src/personal-meeting-room/index.ts

TODO: implement TTL for syncing and caching so to not request again and again

get(options: Object): Promise

Parameters

options (Object)

Returns

Promise:

Instance Members

▸ pmr

packages/@webex/plugin-meetings/src/personal-meeting-room/index.ts

The pmr server object

pmr

Type: Object

▸ sipUri

packages/@webex/plugin-meetings/src/personal-meeting-room/index.ts

The pmr sip Uri

sipUri

Type: String

▸ link

packages/@webex/plugin-meetings/src/personal-meeting-room/index.ts

The pmr link

link

Type: String

▸ userId

packages/@webex/plugin-meetings/src/personal-meeting-room/index.ts

The pmr server object

userId

Type: Object

▸ name

packages/@webex/plugin-meetings/src/personal-meeting-room/index.ts

The pmr name

name

Type: String

claimPmr

packages/@webex/plugin-meetings/src/personal-meeting-room/request.ts

claimPmr(options: Object): Promise

Parameters

options (Object) with format of {userId, passcode, meetingAddress, preferred}

Returns

Promise: returns a promise that resolves/rejects the result of the request

TransportResultForBackend

packages/@webex/plugin-meetings/src/reachability/index.ts

This is the type that matches what backend expects us to send to them. It is a bit weird, because it uses strings instead of booleans and numbers, but that's what they require.

TransportResultForBackend

Type: {reachable: ("true" | "false")?, latencyInMilliseconds: string?, clientMediaIPs: Array<string>?, untested: "true"?}

Properties

reachable (("true" | "false")?)

latencyInMilliseconds (string?)

clientMediaIPs (Array<string>?)

untested ("true"?)

Reachability

packages/@webex/plugin-meetings/src/reachability/index.ts

new Reachability()

Static Members

▸ gatherReachability(trigger)

packages/@webex/plugin-meetings/src/reachability/index.ts

Gets a list of media clusters from the backend and performs reachability checks on all the clusters

gatherReachability(trigger: string): Promise<ReachabilityResults>

Parameters

trigger (string) explains the reason for starting reachability

Returns

Promise<ReachabilityResults>: reachability results

▸ isAnyPublicClusterReachable()

packages/@webex/plugin-meetings/src/reachability/index.ts

fetches reachability data and checks for cluster reachability

isAnyPublicClusterReachable(): boolean

Returns

boolean:

Instance Members

▸ getReachabilityMetrics()

packages/@webex/plugin-meetings/src/reachability/index.ts

Returns statistics about last reachability results. The returned value is an object with a flat list of properties so that it can be easily sent with metrics

getReachabilityMetrics(): Promise

Returns

Promise: Promise with metrics values, it never rejects/throws.

▸ getReachabilityResults()

packages/@webex/plugin-meetings/src/reachability/index.ts

Reachability results as an object in the format that backend expects

getReachabilityResults(): any

Returns

any: reachability results that need to be sent to the backend

▸ isWebexMediaBackendUnreachable()

packages/@webex/plugin-meetings/src/reachability/index.ts

Returns true only if ALL protocols (UDP, TCP and TLS) have been tested and none of the media clusters where reachable with any of the protocols. This is done irrespective of the config, so for example: if config.meetings.experimental.enableTlsReachability === false, it will return false, because TLS reachability won't be tested, so we can't say for sure that media backend is unreachable over TLS.

isWebexMediaBackendUnreachable(): boolean

Returns

boolean:

▸ getStatistics(results, protocol, isVideoMesh)

packages/@webex/plugin-meetings/src/reachability/index.ts

Helper function for calculating min/max/average values of latency

getStatistics(results: Array<any>, protocol: string, isVideoMesh: boolean): {min: number, max: number, average: number}

Parameters

results (Array<any>)

protocol (string)

isVideoMesh (boolean)

Returns

{min: number, max: number, average: number}:

▸ sendMetric()

packages/@webex/plugin-meetings/src/reachability/index.ts

Sends a metric with all the statistics about how long reachability took

sendMetric(): void

Returns

void:

ReachabilityRequest

packages/@webex/plugin-meetings/src/reachability/request.ts

new ReachabilityRequest()

Instance Members

▸ getClusters

packages/@webex/plugin-meetings/src/reachability/request.ts

Gets the cluster information

getClusters

Parameters

ipVersion (IP_VERSION) information about current ip network we're on

Returns

Promise:

▸ remoteSDPForClusters

packages/@webex/plugin-meetings/src/reachability/request.ts

gets remote SDP For Clusters

remoteSDPForClusters

Parameters

localSDPList (Object) localSDPs for the cluster

Returns

Object:

ClusterReachability

packages/@webex/plugin-meetings/src/reachability/clusterReachability.ts

A class that handles reachability checks for a single cluster. It emits events from Events enum

new ClusterReachability(name: string, clusterInfo: ClusterNode)

Extends EventsScope

Parameters

name (string) cluster name

clusterInfo (ClusterNode) information about the media cluster

Instance Members

▸ getResult()

packages/@webex/plugin-meetings/src/reachability/clusterReachability.ts

getResult(): ClusterReachabilityResult

Returns

ClusterReachabilityResult: reachability result for this cluster

▸ abort()

packages/@webex/plugin-meetings/src/reachability/clusterReachability.ts

Aborts the cluster reachability checks by closing the peer connection

abort(): void

Returns

void:

▸ start()

packages/@webex/plugin-meetings/src/reachability/clusterReachability.ts

Starts the process of doing UDP and TCP reachability checks on the media cluster. XTLS reachability checking is not supported.

start(): Promise

Returns

Promise:

convertStunUrlToTurn

packages/@webex/plugin-meetings/src/reachability/util.ts

Converts a stun url to a turn url

convertStunUrlToTurn(stunUrl: string, protocol: ("tcp" | "udp")): string

Parameters

stunUrl (string) url of a stun server

protocol (("tcp" | "udp")) what protocol to use for the turn server

Returns

string: url of a turn server

convertStunUrlToTurnTls

packages/@webex/plugin-meetings/src/reachability/util.ts

Converts a stun url to a turns url

convertStunUrlToTurnTls(stunUrl: string): string

Parameters

stunUrl (string) url of a stun server

Returns

string: url of a turns server

MeetingRequest

packages/@webex/plugin-meetings/src/meetings/request.ts

new MeetingRequest()

Instance Members

▸ getActiveMeetings()

packages/@webex/plugin-meetings/src/meetings/request.ts

get all the active meetings for the user

getActiveMeetings(): Array

Returns

Array: return locus array

▸ fetchGeoHint()

packages/@webex/plugin-meetings/src/meetings/request.ts

fetch geoHit for the user

fetchGeoHint(): Promise<object>

Returns

Promise<object>: geoHintInfo

▸ getMeetingPreferences()

packages/@webex/plugin-meetings/src/meetings/request.ts

get user meeting preference information

getMeetingPreferences(): Promise<object>

Returns

Promise<object>: getMeetingPreferences

▸ determineRedirections(responseBody)

packages/@webex/plugin-meetings/src/meetings/request.ts

Fetches indivdual locus rather then getting all at once

determineRedirections(responseBody: object): Promise

Parameters

responseBody (object) determine the locus and fetch them if a remoteUrl is given

Returns

Promise: returns locusObject array

▸ joinMeeting(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Make a network request to join a meeting

joinMeeting(options: Object): Promise

Parameters

options (Object)

Name	Description
options.sipUri `String`
options.deviceUrl `String`
options.locusUrl `String`
options.resourceId `String`	,
options.correlationId `String`
options.ensureConversation `boolean`
options.moderator `boolean`
options.pin `boolean`
options.moveToResource `boolean`
options.roapMessage `Object`
options.breakoutsSupported `boolean`
options.locale `String`	,
options.deviceCapabilities `Array`
options.liveAnnotationSupported `boolean`
options.alias `String`

Returns

Promise:

▸ getLocusDTO(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Sends a requests to get the latest locus DTO, it might be a full Locus or a delta, depending on the url provided

getLocusDTO(options: Object): Promise

Parameters

options (Object)

Name	Description
options.locusUrl `String`	sync url to get ht elatest locus delta

Returns

Promise:

▸ prepareLeaveMeetingRequestOptions(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Prepares request options to to leave a meeting

prepareLeaveMeetingRequestOptions(options: Object): Object

Parameters

options (Object)

Name	Description
options.locusUrl `Url`
options.selfId `String`
options.deviceUrl `Url`
options.resourceId `String`	,
options.correlationId `String`

Returns

Object: request options

▸ leaveMeeting(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Make a network request to leave a meeting

leaveMeeting(options: Object): Promise

Parameters

options (Object)

Name	Description
options.locusUrl `any`
options.selfId `any`
options.deviceUrl `any`
options.resourceId `any`
options.correlationId `any`

Returns

Promise:

▸ buildLeaveMeetingRequestOptions(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Builds request options to leave a meeting

buildLeaveMeetingRequestOptions(options: Object): Object

Parameters

options (Object)

Returns

Object: request options

▸ acknowledgeMeeting(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Make a network request to acknowledge a meeting

acknowledgeMeeting(options: Object): Promise

Parameters

options (Object)

Name	Description
options.locusUrl `String`
options.deviceUrl `String`
options.correlationId `String`

Returns

Promise:

▸ lockMeeting(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Makes a network request to lock the meeting

lockMeeting(options: Object): Promise

Parameters

options (Object)

Name	Description
options.lock `Boolean`	Whether it is locked or not

Returns

Promise:

▸ declineMeeting(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Make a network request to decline a meeting

declineMeeting(options: Object): Promise

Parameters

options (Object)

Name	Description
options.locusUrl `String`
options.deviceUrl `String`
options.reason `String`

Returns

Promise:

▸ changeMeetingFloor(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

change the content floor grant

changeMeetingFloor(options: Object): Promise

Parameters

options (Object) options for floor grant

Name	Description
options.disposition `String`	floor action (granted/released)
options.personUrl `String`	personUrl who is requesting floor
options.deviceUrl `String`	Url of a device
options.resourceId `String`	Populated if you are paired to a device
options.uri `String`	floor grant uri
options.shareInstanceId `String`	id for current share

Returns

Promise:

▸ sendDTMF(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Sends a request to the DTMF endpoint to send tones

sendDTMF(options: Object): Promise

Parameters

options (Object)

Name	Description
options.locusUrl `String`
options.deviceUrl `String`
options.tones `String`	a string of one or more DTMF tones to send

Returns

Promise:

▸ changeVideoLayout(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Sends a request to the controls endpoint to set the video layout

changeVideoLayout(options: Object): Promise

Parameters

options (Object)

Name	Description
options.locusUrl `String`
options.deviceUrl `String`
options.layoutType `String`	a layout type that should be available in meeting constants #layout_types
options.main `Object`	preferred dimensions for the remote main video stream
options.main.width `Number`	preferred width of main video stream
options.main.height `Number`	preferred height of main video stream
options.content `Object`	preferred dimensions for the remote content share stream
options.content.width `Number`	preferred width of content share stream
options.content.height `Number`	preferred height of content share stream

Returns

Promise:

▸ endMeetingForAll(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Make a network request to end meeting for all

endMeetingForAll(options: Object): Promise

Parameters

options (Object)

Name	Description
options.locusUrl `Url`

Returns

Promise:

▸ keepAlive(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Send a locus keepAlive (used in lobby)

keepAlive(options: Object): Promise

Parameters

options (Object)

Name	Description
options.keepAliveUrl `Url`

Returns

Promise:

▸ sendReaction(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Make a network request to send a reaction.

sendReaction(options: Object): Promise

Parameters

options (Object)

Name	Description
options.reactionChannelUrl `Url`
options.reaction `Reaction`
options.senderID `string`
options.participantId `any`

Returns

Promise:

▸ toggleReactions($0)

packages/@webex/plugin-meetings/src/meeting/request.ts

Make a network request to enable or disable reactions.

toggleReactions($0: ToggleReactionsOptions): Promise

Parameters

$0 (ToggleReactionsOptions)

Name	Description
$0.enable `any`
$0.locusUrl `any`
$0.requestingParticipantId `any`

Returns

Promise:

MeetingRequest

packages/@webex/plugin-meetings/src/meeting/request.ts

new MeetingRequest()

Instance Members

▸ getActiveMeetings()

packages/@webex/plugin-meetings/src/meetings/request.ts

get all the active meetings for the user

getActiveMeetings(): Array

Returns

Array: return locus array

▸ fetchGeoHint()

packages/@webex/plugin-meetings/src/meetings/request.ts

fetch geoHit for the user

fetchGeoHint(): Promise<object>

Returns

Promise<object>: geoHintInfo

▸ getMeetingPreferences()

packages/@webex/plugin-meetings/src/meetings/request.ts

get user meeting preference information

getMeetingPreferences(): Promise<object>

Returns

Promise<object>: getMeetingPreferences

▸ determineRedirections(responseBody)

packages/@webex/plugin-meetings/src/meetings/request.ts

Fetches indivdual locus rather then getting all at once

determineRedirections(responseBody: object): Promise

Parameters

responseBody (object) determine the locus and fetch them if a remoteUrl is given

Returns

Promise: returns locusObject array

▸ joinMeeting(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Make a network request to join a meeting

joinMeeting(options: Object): Promise

Parameters

options (Object)

Name	Description
options.sipUri `String`
options.deviceUrl `String`
options.locusUrl `String`
options.resourceId `String`	,
options.correlationId `String`
options.ensureConversation `boolean`
options.moderator `boolean`
options.pin `boolean`
options.moveToResource `boolean`
options.roapMessage `Object`
options.breakoutsSupported `boolean`
options.locale `String`	,
options.deviceCapabilities `Array`
options.liveAnnotationSupported `boolean`
options.alias `String`

Returns

Promise:

▸ getLocusDTO(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Sends a requests to get the latest locus DTO, it might be a full Locus or a delta, depending on the url provided

getLocusDTO(options: Object): Promise

Parameters

options (Object)

Name	Description
options.locusUrl `String`	sync url to get ht elatest locus delta

Returns

Promise:

▸ prepareLeaveMeetingRequestOptions(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Prepares request options to to leave a meeting

prepareLeaveMeetingRequestOptions(options: Object): Object

Parameters

options (Object)

Name	Description
options.locusUrl `Url`
options.selfId `String`
options.deviceUrl `Url`
options.resourceId `String`	,
options.correlationId `String`

Returns

Object: request options

▸ leaveMeeting(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Make a network request to leave a meeting

leaveMeeting(options: Object): Promise

Parameters

options (Object)

Name	Description
options.locusUrl `any`
options.selfId `any`
options.deviceUrl `any`
options.resourceId `any`
options.correlationId `any`

Returns

Promise:

▸ buildLeaveMeetingRequestOptions(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Builds request options to leave a meeting

buildLeaveMeetingRequestOptions(options: Object): Object

Parameters

options (Object)

Returns

Object: request options

▸ acknowledgeMeeting(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Make a network request to acknowledge a meeting

acknowledgeMeeting(options: Object): Promise

Parameters

options (Object)

Name	Description
options.locusUrl `String`
options.deviceUrl `String`
options.correlationId `String`

Returns

Promise:

▸ lockMeeting(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Makes a network request to lock the meeting

lockMeeting(options: Object): Promise

Parameters

options (Object)

Name	Description
options.lock `Boolean`	Whether it is locked or not

Returns

Promise:

▸ declineMeeting(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Make a network request to decline a meeting

declineMeeting(options: Object): Promise

Parameters

options (Object)

Name	Description
options.locusUrl `String`
options.deviceUrl `String`
options.reason `String`

Returns

Promise:

▸ changeMeetingFloor(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

change the content floor grant

changeMeetingFloor(options: Object): Promise

Parameters

options (Object) options for floor grant

Name	Description
options.disposition `String`	floor action (granted/released)
options.personUrl `String`	personUrl who is requesting floor
options.deviceUrl `String`	Url of a device
options.resourceId `String`	Populated if you are paired to a device
options.uri `String`	floor grant uri
options.shareInstanceId `String`	id for current share

Returns

Promise:

▸ sendDTMF(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Sends a request to the DTMF endpoint to send tones

sendDTMF(options: Object): Promise

Parameters

options (Object)

Name	Description
options.locusUrl `String`
options.deviceUrl `String`
options.tones `String`	a string of one or more DTMF tones to send

Returns

Promise:

▸ changeVideoLayout(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Sends a request to the controls endpoint to set the video layout

changeVideoLayout(options: Object): Promise

Parameters

options (Object)

Name	Description
options.locusUrl `String`
options.deviceUrl `String`
options.layoutType `String`	a layout type that should be available in meeting constants #layout_types
options.main `Object`	preferred dimensions for the remote main video stream
options.main.width `Number`	preferred width of main video stream
options.main.height `Number`	preferred height of main video stream
options.content `Object`	preferred dimensions for the remote content share stream
options.content.width `Number`	preferred width of content share stream
options.content.height `Number`	preferred height of content share stream

Returns

Promise:

▸ endMeetingForAll(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Make a network request to end meeting for all

endMeetingForAll(options: Object): Promise

Parameters

options (Object)

Name	Description
options.locusUrl `Url`

Returns

Promise:

▸ keepAlive(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Send a locus keepAlive (used in lobby)

keepAlive(options: Object): Promise

Parameters

options (Object)

Name	Description
options.keepAliveUrl `Url`

Returns

Promise:

▸ sendReaction(options)

packages/@webex/plugin-meetings/src/meeting/request.ts

Make a network request to send a reaction.

sendReaction(options: Object): Promise

Parameters

options (Object)

Name	Description
options.reactionChannelUrl `Url`
options.reaction `Reaction`
options.senderID `string`
options.participantId `any`

Returns

Promise:

▸ toggleReactions($0)

packages/@webex/plugin-meetings/src/meeting/request.ts

Make a network request to enable or disable reactions.

toggleReactions($0: ToggleReactionsOptions): Promise

Parameters

$0 (ToggleReactionsOptions)

Name	Description
$0.enable `any`
$0.locusUrl `any`
$0.requestingParticipantId `any`

Returns

Promise:

MeetingCollection

packages/@webex/plugin-meetings/src/meetings/collection.ts

new MeetingCollection()

Static Members

▸ getByKey(key, value)

packages/@webex/plugin-meetings/src/meetings/collection.ts

get a specific meeting searching for key

getByKey(key: MEETING_KEY, value: Any): Meeting

Parameters

key (MEETING_KEY)

value (Any)

Returns

Meeting: if found, else returns null

▸ getActiveBreakoutLocus(breakoutUrl)

packages/@webex/plugin-meetings/src/meetings/collection.ts

get a specific meeting searching for key

getActiveBreakoutLocus(breakoutUrl: String): Meeting

Parameters

breakoutUrl (String)

Returns

Meeting: if found, else returns null

▸ getActiveWebrtcMeeting()

packages/@webex/plugin-meetings/src/meetings/collection.ts

Gets the meeting that has a webrtc media connection NOTE: this function assumes there is no more than 1 such meeting

getActiveWebrtcMeeting(): Meeting

Returns

Meeting: first meeting found, else undefined

Collection

packages/@webex/plugin-meetings/src/common/collection.ts

new Collection()

Static Members

▸ get(id)

packages/@webex/plugin-meetings/src/common/collection.ts

get(id: String): Any

Parameters

id (String) ID of the thing stuffed into the collection at id location

Returns

Any: returns whatever is being stuffed into the collection

▸ set(id, value)

packages/@webex/plugin-meetings/src/common/collection.ts

set(id: String, value: Any): Any

Parameters

id (String) the id of the meeting info instance to add to the collection

value (Any) the thing to set in the collection

Returns

Any: returns the thing just put in the collection

▸ delete(id)

packages/@webex/plugin-meetings/src/common/collection.ts

remove the thing at the id

delete(id: String): undefined

Parameters

id (String) ID of the thing you wish to delete from the collection

Returns

undefined:

▸ getAll()

packages/@webex/plugin-meetings/src/common/collection.ts

getAll(): Object

Returns

Object: returns an object map of things stuffed into the collection

▸ setAll(set)

packages/@webex/plugin-meetings/src/common/collection.ts

setAll(set: Object): Object

Parameters

set (Object) the replacement object

Returns

Object: returns an object map of things stuffed into the collection

media:codec:missing

packages/@webex/plugin-meetings/src/meetings/util.ts

Meetings Media Codec Missing Event Emitted when H.264 codec is not found in the browser.

media:codec:missing

media:codec:loaded

packages/@webex/plugin-meetings/src/meetings/util.ts

Meetings Media Codec Loaded Event Emitted when H.264 codec has been loaded in the browser.

media:codec:loaded

getThisDevice

packages/@webex/plugin-meetings/src/meetings/util.ts

get device from locus data

getThisDevice(newLocus: Object, deviceUrl: String): Object

Parameters

newLocus (Object) new locus data

deviceUrl (String) current device url

Returns

Object:

joinedOnThisDevice

packages/@webex/plugin-meetings/src/meetings/util.ts

get self device joined status from locus data

joinedOnThisDevice(meeting: Object, newLocus: Object, deviceUrl: String): Object

Parameters

meeting (Object) current meeting data

newLocus (Object) new locus data

deviceUrl (String) current device url

Returns

Object:

NoMeetingInfoError

packages/@webex/plugin-meetings/src/common/errors/no-meeting-info.ts

Extended Error object for general parameter errors

new NoMeetingInfoError(message: String?, error: Object?)

Extends Error

Parameters

message

(String?
            = ERROR_DICTIONARY.NO_MEETING_INFO.MESSAGE)

error

(Object?
            = null)

LocusRetryStatusInterceptor

packages/@webex/plugin-meetings/src/interceptors/locusRetry.ts

new LocusRetryStatusInterceptor()

Extends Interceptor

Static Members

▸ create()

packages/@webex/plugin-meetings/src/interceptors/locusRetry.ts

create(): LocusRetryStatusInterceptor

Returns

LocusRetryStatusInterceptor:

Instance Members

▸ onResponseError(options, reason)

packages/@webex/plugin-meetings/src/interceptors/locusRetry.ts

Handle response errors

onResponseError(options: Object, reason: WebexHttpError): Promise<WebexHttpError>

Parameters

options (Object)

reason (WebexHttpError)

Returns

Promise<WebexHttpError>:

▸ handleRetryRequestLocusServiceError(options, retryAfterTime)

packages/@webex/plugin-meetings/src/interceptors/locusRetry.ts

Handle retries for locus service unavailable errors

handleRetryRequestLocusServiceError(options: Object, retryAfterTime: number): Promise

Parameters

options (Object) associated with the request

retryAfterTime (number) retry after time in milliseconds

Returns

Promise:

CaptchaError

packages/@webex/plugin-meetings/src/common/errors/captcha-error.ts

Extended Error object to signify captcha related errors

new CaptchaError(message: String?, error: Object?)

Extends Error

Parameters

message

(String?
            = ERROR_DICTIONARY.CAPTCHA.MESSAGE)

error

(Object?
            = null)

IntentToJoinError

packages/@webex/plugin-meetings/src/common/errors/intent-to-join.ts

Extended Error object to signify the intent to join for unclaimed PMR scenarios

new IntentToJoinError(message: String?, error: Object?)

Extends Error

Parameters

message

(String?
            = ERROR_DICTIONARY.INTENT_TO_JOIN.MESSAGE)

error

(Object?
            = null)

PasswordError

packages/@webex/plugin-meetings/src/common/errors/password-error.ts

Extended Error object to signify password related errors

new PasswordError(message: String?, error: Object?)

Extends Error

Parameters

message

(String?
            = ERROR_DICTIONARY.PASSWORD.MESSAGE)

error

(Object?
            = null)

PermissionError

packages/@webex/plugin-meetings/src/common/errors/permission.ts

Extended Error object for general parameter errors

new PermissionError(message: String?, error: Object?)

Extends Error

Parameters

message

(String?
            = ERROR_DICTIONARY.PERMISSION.MESSAGE)

error

(Object?
            = null)

WebinarRegistrationError

packages/@webex/plugin-meetings/src/common/errors/webinar-registration-error.ts

Error occurred while the webinar required registration

new WebinarRegistrationError(message: String?, error: Object?)

Extends Error

Parameters

message

(String?
            = ERROR_DICTIONARY.WebinarRegistrationError.MESSAGE)

error

(Object?
            = null)

ReclaimHostEmptyWrongKeyError

packages/@webex/plugin-meetings/src/common/errors/reclaim-host-role-errors.ts

Extended Error object for reclaim host role empty or wrong key

new ReclaimHostEmptyWrongKeyError(message: String?, error: Object?)

Extends Error

Parameters

message

(String?
            = MEETINGCONSTANTS.ERROR_DICTIONARY.RECLAIM_HOST_ROLE_EMPTY_OR_WRONG_KEY.MESSAGE)

error

(Object?
            = null)

ReclaimHostNotSupportedError

packages/@webex/plugin-meetings/src/common/errors/reclaim-host-role-errors.ts

Extended Error object for reclaim host role not supported

new ReclaimHostNotSupportedError(message: String?, error: Object?)

Extends Error

Parameters

message

(String?
            = MEETINGCONSTANTS.ERROR_DICTIONARY.RECLAIM_HOST_ROLE_NOT_SUPPORTED.MESSAGE)

error

(Object?
            = null)

ReclaimHostNotAllowedError

packages/@webex/plugin-meetings/src/common/errors/reclaim-host-role-errors.ts

Extended Error object for reclaim host role not allowed for other participants

new ReclaimHostNotAllowedError(message: String?, error: Object?)

Extends Error

Parameters

message

(String?
            = MEETINGCONSTANTS.ERROR_DICTIONARY.RECLAIM_HOST_ROLE_NOT_ALLOWED.MESSAGE)

error

(Object?
            = null)

ReclaimHostIsHostAlreadyError

packages/@webex/plugin-meetings/src/common/errors/reclaim-host-role-errors.ts

Extended Error object for reclaim host role when user is host already

new ReclaimHostIsHostAlreadyError(message: String?, error: Object?)

Extends Error

Parameters

message

(String?
            = MEETINGCONSTANTS.ERROR_DICTIONARY.RECLAIM_HOST_ROLE_IS_ALREADY_HOST.MESSAGE)

error

(Object?
            = null)

SharePreferences

packages/@webex/plugin-meetings/src/meeting/index.ts

SharePreferences

Type: Object

Properties

shareConstraints (Object?)

highFrameRate (Boolean?)

JoinOptions

packages/@webex/plugin-meetings/src/meeting/index.ts

JoinOptions

Type: Object

Properties

resourceId (String?)

pin (String?)

moderator (Boolean?)

meetingQuality ((String | Object)?)

meetingQuality.remote String?

rejoin (Boolean?)

enableMultistream (Boolean?)

Recording

packages/@webex/plugin-meetings/src/meeting/index.ts

Recording

Type: Object

Properties

state (Object)

modifiedBy (String)

meeting

packages/@webex/plugin-meetings/src/meeting/state.ts

The meeting instance to execute all state changes on

meeting

join

packages/@webex/plugin-meetings/src/meeting/index.ts

Specify joining via audio (option: pstn), video, screenshare

join(options: JoinOptions): Promise

Parameters

options

(JoinOptions
            = {})

A configurable options object for joining a meeting

Returns

Promise: the join response

RoapOptions

packages/@webex/plugin-meetings/src/roap/index.ts

Roap options

RoapOptions

Type: Object

Properties

sdp (String)

meeting (Meeting)

seq (Number)

tieBreaker (Number)

reconnect (Boolean)

SeqOptions

packages/@webex/plugin-meetings/src/roap/index.ts

SeqOptions

Type: Object

Properties

correlationId (String)

mediaId (String)

seq (Number)

RoapRequest

packages/@webex/plugin-meetings/src/roap/request.ts

new RoapRequest()

Instance Members

▸ attachReachabilityData(localSdp)

packages/@webex/plugin-meetings/src/roap/request.ts

Returns reachability data.

attachReachabilityData(localSdp: Object): Object

Parameters

localSdp (Object)

Returns

Object:

▸ sendRoap(options)

packages/@webex/plugin-meetings/src/roap/request.ts

Sends a ROAP message

sendRoap(options: Object): Promise

Parameters

options (Object)

Name	Description
options.roapMessage `Object`
options.locusSelfUrl `String`
options.mediaId `String`
options.correlationId `String`
options.meetingId `String`
options.ipVersion `IP_VERSION`	only required for offers

Returns

Promise: returns the response/failure of the request

TurnDiscovery

packages/@webex/plugin-meetings/src/roap/turnDiscovery.ts

Handles the process of finding out TURN server information from Linus. This is achieved by sending a TURN_DISCOVERY_REQUEST.

new TurnDiscovery(roapRequest: RoapRequest)

Parameters

roapRequest (RoapRequest)

Instance Members

▸ generateTurnDiscoveryRequestMessage(meeting, isForced)

packages/@webex/plugin-meetings/src/roap/turnDiscovery.ts

Generates TURN_DISCOVERY_REQUEST roap message. When this method returns a roapMessage, it means that a TURN discovery process has started. It needs be ended by calling handleTurnDiscoveryHttpResponse() once you get a response from the backend. If you don't get any response or want to abort, you need to call abort().

generateTurnDiscoveryRequestMessage(meeting: Meeting, isForced: boolean): Object

Parameters

meeting (Meeting)

isForced (boolean)

Returns

Object:

▸ abort()

packages/@webex/plugin-meetings/src/roap/turnDiscovery.ts

Aborts current TURN discovery. This method needs to be called if you called generateTurnDiscoveryRequestMessage(), but then never got any response from the server.

abort(): void

Returns

void:

▸ sendRoapOK(meeting)

packages/@webex/plugin-meetings/src/roap/turnDiscovery.ts

Sends the OK message that server expects to receive after it sends us TURN_DISCOVERY_RESPONSE

sendRoapOK(meeting: Meeting): Promise

Parameters

meeting (Meeting)

Returns

Promise:

▸ isSkipped(meeting)

packages/@webex/plugin-meetings/src/roap/turnDiscovery.ts

Checks if TURN discovery is skipped.

isSkipped(meeting: Meeting): Boolean

Parameters

meeting (Meeting)

Returns

Boolean: true if TURN discovery is being skipped, false if it is being done

▸ doTurnDiscovery(meeting, isReconnecting?, isForced?)

packages/@webex/plugin-meetings/src/roap/turnDiscovery.ts

Retrieves TURN server information from the backend by doing a roap message exchange: client server | -----TURN_DISCOVERY_REQUEST-----> | | <----TURN_DISCOVERY_RESPONSE----- | | --------------OK----------------> |

This TURN discovery roap exchange is always done with seq=0. The RoapMediaConnection SDP exchange always starts with seq=1, so it works fine no matter if TURN discovery is done or not.

doTurnDiscovery(meeting: Meeting, isReconnecting: Boolean?, isForced: Boolean?): Promise

Parameters

meeting (Meeting)

isReconnecting (Boolean?) should be set to true if this is a new media connection just after a reconnection

isForced (Boolean?)

Returns

Promise:

MediaProperties

packages/@webex/plugin-meetings/src/media/properties.ts

new MediaProperties()

Instance Members

▸ getVideoDeviceId()

packages/@webex/plugin-meetings/src/media/properties.ts

Retrieves the preferred video input device

getVideoDeviceId(): (Object | null)

Returns

(Object | null):

▸ setRemoteAudioStream(remoteAudioStream)

packages/@webex/plugin-meetings/src/media/properties.ts

Sets the remote audio stream

setRemoteAudioStream(remoteAudioStream: RemoteStream): void

Parameters

remoteAudioStream (RemoteStream) RemoteStream to save

Returns

void:

▸ setRemoteVideoStream(remoteVideoStream)

packages/@webex/plugin-meetings/src/media/properties.ts

Sets the remote video stream

setRemoteVideoStream(remoteVideoStream: RemoteStream): void

Parameters

remoteVideoStream (RemoteStream) RemoteStream to save

Returns

void:

▸ setVideoDeviceId(deviceId)

packages/@webex/plugin-meetings/src/media/properties.ts

Stores the preferred video input device

setVideoDeviceId(deviceId: string): void

Parameters

deviceId (string) Preferred video input device

Returns

void:

▸ unsetRemoteMedia()

packages/@webex/plugin-meetings/src/media/properties.ts

Removes both remote audio and video from class instance

unsetRemoteMedia(): void

Returns

void:

▸ unsetRemoteStreams()

packages/@webex/plugin-meetings/src/media/properties.ts

Unsets all remote streams

unsetRemoteStreams(): void

Returns

void:

▸ hasLocalShareStream()

packages/@webex/plugin-meetings/src/media/properties.ts

Returns if we have at least one local share stream or not.

hasLocalShareStream(): Boolean

Returns

Boolean:

▸ waitForMediaConnectionConnected()

packages/@webex/plugin-meetings/src/media/properties.ts

Waits for the webrtc media connection to be connected.

waitForMediaConnectionConnected(): Promise<void>

Returns

Promise<void>:

▸ getCurrentConnectionInfo()

packages/@webex/plugin-meetings/src/media/properties.ts

Returns information about current webrtc media connection

getCurrentConnectionInfo(): Promise<Object>

Returns

Promise<Object>:

MediaConnectionAwaiter

packages/@webex/plugin-meetings/src/media/MediaConnectionAwaiter.ts

new MediaConnectionAwaiter()

Instance Members

▸ connectionStateChange()

packages/@webex/plugin-meetings/src/media/MediaConnectionAwaiter.ts

On connection state change.

connectionStateChange(): void

Returns

void:

▸ peerConnectionStateHandler()

packages/@webex/plugin-meetings/src/media/MediaConnectionAwaiter.ts

Listener for peer connection state change.

peerConnectionStateHandler(): void

Returns

void:

▸ iceConnectionStateHandler()

packages/@webex/plugin-meetings/src/media/MediaConnectionAwaiter.ts

Listener for ICE connection state change.

iceConnectionStateHandler(): void

Returns

void:

▸ iceGatheringStateHandler()

packages/@webex/plugin-meetings/src/media/MediaConnectionAwaiter.ts

Listener for ICE gathering state change.

iceGatheringStateHandler(): void

Returns

void:

▸ onTimeout()

packages/@webex/plugin-meetings/src/media/MediaConnectionAwaiter.ts

Function called when the timeout is reached.

onTimeout(): void

Returns

void:

▸ waitForMediaConnectionConnected()

packages/@webex/plugin-meetings/src/media/MediaConnectionAwaiter.ts

Waits for the webrtc media connection to be connected.

waitForMediaConnectionConnected(): Promise

Returns

Promise:

create

packages/@webex/plugin-meetings/src/meeting/state.ts

Initializes the StateMachine for the meeting

create(meetingRef: Meeting): StateMachine

Parameters

meetingRef (Meeting) A reference to a meeting instance

Returns

StateMachine:

to

packages/@webex/plugin-meetings/src/meeting/state.ts

to(remote: Object): String

Parameters

remote (Object)

Name	Description
remote.remoteAnswered `Boolean`
remote.remoteDeclined `Boolean`

Returns

String:

onRemote

packages/@webex/plugin-meetings/src/meeting/state.ts

Ring stop transition, to end the ring event for the meeting, and transition the state to ANSWERED OR DECLINED, only for outgoing meetings

onRemote(transition: Object, stop: Object): Boolean

Parameters

transition (Object) -- FiniteStateMachine automatically passed, not used

stop (Object) -- {remoteAnswered: {Boolean}, remoteDeclined: {Boolean}}

Returns

Boolean:

onRing

packages/@webex/plugin-meetings/src/meeting/state.ts

Ring transition, to cause the ring event for the meeting, and transition the state to RINGING, for both incoming, and outgoing meetings

onRing(transition: Object, type: String): Boolean

Parameters

transition (Object) -- FiniteStateMachine automatically passed, not used

type (String) -- incoming call === INCOMING / or other meetings have a ring type of JOIN

Returns

Boolean:

onEnterError

packages/@webex/plugin-meetings/src/meeting/state.ts

handle the entry to error state

onEnterError(transition: Object, error: Error): Boolean

Parameters

transition (Object)

error (Error)

Returns

Boolean:

onAfterTransition

packages/@webex/plugin-meetings/src/meeting/state.ts

After ANY transition occurs, we want to know what state the meeting moved to for debugging

onAfterTransition(transition: Object): Boolean

Parameters

transition (Object)

Returns

Boolean:

MuteState

packages/@webex/plugin-meetings/src/meeting/muteState.ts

The purpose of this class is to manage the local and remote mute state and make sure that the server state always matches the last requested state by the client.

More info about Locus muting API: https://sqbu-github.cisco.com/pages/WebExSquared/locus/guides/mute.html#

This class is exported only for unit tests. It should never be instantiated directly with new MuteState(), instead createMuteState() should be called

new MuteState(type: String, meeting: Object, enabled: boolean)

Parameters

type (String) audio or video

meeting (Object) the meeting object (used for reading current remote mute status)

enabled (boolean) whether the client audio/video is enabled at all

Static Members

▸ handleLocalStreamMuteStateChange(meeting?, mute?)

packages/@webex/plugin-meetings/src/meeting/muteState.ts

This method should be called when the local stream mute state is changed

handleLocalStreamMuteStateChange(meeting: Object?, mute: Boolean?): void

Parameters

meeting (Object?) the meeting object

mute (Boolean?) true for muting, false for unmuting request

Returns

void:

▸ applyClientStateLocally(meeting?, reason)

packages/@webex/plugin-meetings/src/meeting/muteState.ts

Applies the current mute state to the local stream (by enabling or disabling it accordingly)

applyClientStateLocally(meeting: Object?, reason: ServerMuteReason): void

Parameters

meeting (Object?) the meeting object

reason (ServerMuteReason) reason why we're applying our client state to the local stream

Returns

void:

▸ handleServerRemoteMuteUpdate(meeting, muted?, unmuteAllowed?)

packages/@webex/plugin-meetings/src/meeting/muteState.ts

This method should be called whenever the server remote mute state is changed

handleServerRemoteMuteUpdate(meeting: Meeting, muted: Boolean?, unmuteAllowed: Boolean?): undefined

Parameters

meeting (Meeting)

muted (Boolean?) true if user is remotely muted, false otherwise

unmuteAllowed (Boolean?) indicates if user is allowed to unmute self (false when "hard mute" feature is used)

Returns

undefined:

▸ handleServerLocalUnmuteRequired(meeting?, unmuteAllowed?)

packages/@webex/plugin-meetings/src/meeting/muteState.ts

This method should be called whenever we receive from the server a requirement to locally unmute

handleServerLocalUnmuteRequired(meeting: Object?, unmuteAllowed: Boolean?): undefined

Parameters

meeting (Object?) the meeting object

unmuteAllowed (Boolean?) whether the user is allowed to unmute self

Returns

undefined:

▸ isMuted()

packages/@webex/plugin-meetings/src/meeting/muteState.ts

Returns true if the user is locally or remotely muted. It only checks the mute status, ignoring the fact whether audio/video is enabled.

isMuted(): Boolean

Returns

Boolean:

▸ isRemotelyMuted()

packages/@webex/plugin-meetings/src/meeting/muteState.ts

Returns true if the user is remotely muted

isRemotelyMuted(): Boolean

Returns

Boolean:

▸ isUnmuteAllowed()

packages/@webex/plugin-meetings/src/meeting/muteState.ts

Returns true if unmute is allowed

isUnmuteAllowed(): Boolean

Returns

Boolean:

▸ isLocallyMuted()

packages/@webex/plugin-meetings/src/meeting/muteState.ts

Returns true if the user is locally muted or audio/video is disabled

isLocallyMuted(): Boolean

Returns

Boolean:

Instance Members

▸ init(meeting)

packages/@webex/plugin-meetings/src/meeting/muteState.ts

Starts the mute state machine. Needs to be called after a new MuteState instance is created.

init(meeting: Object): void

Parameters

meeting (Object) the meeting object

Returns

void:

▸ handleLocalStreamChange(meeting)

packages/@webex/plugin-meetings/src/meeting/muteState.ts

This method needs to be called whenever the local audio/video stream has changed. It reapplies the remote mute state onto the new stream and also reads the current local mute state from the stream and updates the internal state machine and sends any required requests to the server.

handleLocalStreamChange(meeting: Object): void

Parameters

meeting (Object) the meeting object

Returns

void:

▸ enable(meeting, enable)

packages/@webex/plugin-meetings/src/meeting/muteState.ts

Enables/disables audio/video

enable(meeting: Object, enable: boolean): void

Parameters

meeting (Object) the meeting object

enable (boolean)

Returns

void:

DeltaParticipant

packages/@webex/plugin-meetings/src/locus-info/index.ts

Stores the delta values for a changed participant.

DeltaParticipant

Type: Object

Properties

delta (Record<string, boolean>) : Contains changed streams.

person (Object) : Contains person data.

updateHostInfo

packages/@webex/plugin-meetings/src/locus-info/index.ts

handles when the locus.host is updated

updateHostInfo(host: Object): undefined

Parameters

host (Object) the locus.host property

Returns

undefined:

packages/@webex/plugin-meetings/src/locus-info/selfUtils.ts

Checks if user has joined the meeting

isJoined(self: Object): boolean

Parameters

self (Object)

Returns

boolean: isJoined

layoutChanged

packages/@webex/plugin-meetings/src/locus-info/selfUtils.ts

Validate if the Meeting Layout Controls Layout has changed.

layoutChanged(previous: Self, current: Self): boolean

Parameters

previous (Self) Previous self state

current (Self) Current self state [per event]

Returns

boolean: If the Meeting Layout Controls Layout has changed.

getSelfIdentity

packages/@webex/plugin-meetings/src/locus-info/selfUtils.ts

get the id from the self object

getSelfIdentity(self: Object): String

Parameters

self (Object)

Returns

String:

getRemoteVideoMuted

packages/@webex/plugin-meetings/src/locus-info/selfUtils.ts

get the "remote video mute" property from the self object

getRemoteVideoMuted(self: Object): Boolean

Parameters

self (Object)

Returns

Boolean:

getRemoteMuted

packages/@webex/plugin-meetings/src/locus-info/selfUtils.ts

get the "remote mute" property from the self object

getRemoteMuted(self: Object): Boolean

Parameters

self (Object)

Returns

Boolean:

wasMediaInactiveOrReleased

packages/@webex/plugin-meetings/src/locus-info/selfUtils.ts

wasMediaInactiveOrReleased(oldSelf: Object, changedSelf: Object): Boolean

Parameters

oldSelf

(Object
            = {})

changedSelf (Object)

Returns

Boolean:

isLocusUserUnadmitted

packages/@webex/plugin-meetings/src/locus-info/selfUtils.ts

isLocusUserUnadmitted(check: Object): Boolean

Parameters

check (Object)

Returns

Boolean:

isLocusUserAdmitted

packages/@webex/plugin-meetings/src/locus-info/selfUtils.ts

isLocusUserAdmitted(check: Object): Boolean

Parameters

check (Object)

Returns

Boolean:

isUserUnadmitted

packages/@webex/plugin-meetings/src/locus-info/selfUtils.ts

isUserUnadmitted(self: Object): Boolean

Parameters

self (Object)

Returns

Boolean:

Throws

Error: when self is undefined

isRolesChanged

packages/@webex/plugin-meetings/src/locus-info/selfUtils.ts

determine whether the roles of self is changed or not

isRolesChanged(oldSelf: Object, changedSelf: Object): Boolean

Parameters

oldSelf (Object)

changedSelf (Object)

Returns

Boolean:

isDeviceObserving

packages/@webex/plugin-meetings/src/locus-info/selfUtils.ts

isDeviceObserving(oldSelf: Object, changedSelf: Object): Boolean

Parameters

oldSelf (Object)

changedSelf (Object)

Returns

Boolean:

Throws

Error: if changed self was undefined

isUserAdmitted

packages/@webex/plugin-meetings/src/locus-info/selfUtils.ts

isUserAdmitted(oldSelf: Object, changedSelf: Object): Boolean

Parameters

oldSelf (Object)

changedSelf (Object)

Returns

Boolean:

Throws

Error: if changed self was undefined

getSipUrl

packages/@webex/plugin-meetings/src/locus-info/selfUtils.ts

extract the sipUrl from the partner

getSipUrl(partner: Object, type: any, sipUri: any, info: Object): Object

Parameters

partner (Object)

type (any)

sipUri (any)

info (Object)

Returns

Object:

packages/@webex/plugin-meetings/src/locus-info/hostUtils.ts

Extract the id from the host object

getId(host: Object): String

Parameters

host (Object)

Returns

String:

LocusControls

packages/@webex/plugin-meetings/src/locus-info/controlsUtils.ts

Controls

LocusControls

Type: Object

Properties

record (Object)

record.recording Boolean
record.meta Object

parse

packages/@webex/plugin-meetings/src/locus-info/controlsUtils.ts

parse the relevant host values that we care about: id

parse(controls: LocusControls): Object

Parameters

controls (LocusControls)

Returns

Object: parsedObject - parsed host or null if host was undefined

Returns

String: parsedObject.recordingId

getControls

packages/@webex/plugin-meetings/src/locus-info/controlsUtils.ts

parses and returns previous state vs current state and triggers the changes.

getControls(oldControls: LocusControls, newControls: LocusControls): Object

Parameters

oldControls (LocusControls) previous state

newControls (LocusControls) current state

Returns

Object: combination of state plus the changes

packages/@webex/plugin-meetings/src/locus-info/embeddedAppsUtils.ts

Parse the relevant values that we care about

parseApp(embeddedApp: Object): Object

Parameters

embeddedApp (Object) raw embedded app object

Returns

Object: parsedObject - parsed embedded app object

Determines if two embedded apps arrays are similar. NOTE: This is a simple test for performance reasons.

areSimilar(apps1: Array<any>, apps2: Array<any>): boolean

Parameters

apps1 (Array<any>) an array of apps

apps2 (Array<any>) an array of apps

Returns

boolean: true if the arrays are different

parse

packages/@webex/plugin-meetings/src/locus-info/embeddedAppsUtils.ts

Parse the array of embedded apps

parse(embeddedApps: array): array

Parameters

embeddedApps (array)

Returns

array: result - new array of parsed embedded app objects

parse

packages/@webex/plugin-meetings/src/locus-info/mediaSharesUtils.ts

parses the relevant values for mediaShares: contentId, disposition

parse(mediaShares: Object): undefined

Parameters

mediaShares (Object)

Returns

undefined:

getMediaShares

packages/@webex/plugin-meetings/src/locus-info/mediaSharesUtils.ts

get the previous and current mediaShares values parsed, as well as the boolean updates

getMediaShares(oldShare: Object, newShare: Object): Object

Parameters

oldShare (Object)

newShare (Object)

Returns

Object: previous: {Object} old share, current: {Object} new share,

getContentDisposition

packages/@webex/plugin-meetings/src/locus-info/mediaSharesUtils.ts

get the content floor disposition (released, granted)

getContentDisposition(mediaShares: Object): Boolean

Parameters

mediaShares (Object)

Returns

Boolean: disposition

getWhiteboardDisposition

packages/@webex/plugin-meetings/src/locus-info/mediaSharesUtils.ts

get the whiteboard floor disposition (released, granted)

getWhiteboardDisposition(mediaShares: Object): Boolean

Parameters

mediaShares (Object)

Returns

Boolean: disposition

extractContent

packages/@webex/plugin-meetings/src/locus-info/mediaSharesUtils.ts

extract the content property from media shares

extractContent(mediaShares: Object): Object

Parameters

mediaShares (Object)

Returns

Object:

extractWhiteboard

packages/@webex/plugin-meetings/src/locus-info/mediaSharesUtils.ts

extract the whiteboard property from media shares

extractWhiteboard(mediaShares: Object): Object

Parameters

mediaShares (Object)

Returns

Object:

extractFloor

packages/@webex/plugin-meetings/src/locus-info/mediaSharesUtils.ts

extract the media stream floor property from content object

extractFloor(mediaStream: Object): Object

Parameters

mediaStream (Object)

Returns

Object:

extractContentFloor

packages/@webex/plugin-meetings/src/locus-info/mediaSharesUtils.ts

extract the content's floor from media shares

extractContentFloor(mediaShares: Object): Object

Parameters

mediaShares (Object)

Returns

Object:

extractWhiteboardFloor

packages/@webex/plugin-meetings/src/locus-info/mediaSharesUtils.ts

extract the whiteboard's floor from media shares

extractWhiteboardFloor(mediaShares: Object): Object

Parameters

mediaShares (Object)

Returns

Object:

getContentBeneficiaryId

packages/@webex/plugin-meetings/src/locus-info/mediaSharesUtils.ts

get who is sharing from media shares (content)

getContentBeneficiaryId(mediaShares: Object): Object

Parameters

mediaShares (Object)

Returns

Object:

getContentAnnotation

packages/@webex/plugin-meetings/src/locus-info/mediaSharesUtils.ts

get live annotation is sharing from media shares (content)

getContentAnnotation(mediaShares: Object): Object

Parameters

mediaShares (Object)

Returns

Object:

getContentResourceType

packages/@webex/plugin-meetings/src/locus-info/mediaSharesUtils.ts

get live resourceType is sharing from media shares (content)

getContentResourceType(mediaShares: Object): Object

Parameters

mediaShares (Object)

Returns

Object:

getContentUrl

packages/@webex/plugin-meetings/src/locus-info/mediaSharesUtils.ts

get url is sharing from media shares (content)

getContentUrl(mediaShares: Object): Object

Parameters

mediaShares (Object)

Returns

Object:

getShareInstanceId

packages/@webex/plugin-meetings/src/locus-info/mediaSharesUtils.ts

get shareInstanceId is sharing from media shares (content)

getShareInstanceId(mediaShares: Object): Object

Parameters

mediaShares (Object)

Returns

Object:

getContentBeneficiaryDeviceUrl

packages/@webex/plugin-meetings/src/locus-info/mediaSharesUtils.ts

get deviceUrl that is requesting the floor for media shares (content)

getContentBeneficiaryDeviceUrl(mediaShares: Object): Object

Parameters

mediaShares (Object)

Returns

Object:

getWhiteboardBeneficiaryId

packages/@webex/plugin-meetings/src/locus-info/mediaSharesUtils.ts

get who is sharing from media shares (whiteboard)

getWhiteboardBeneficiaryId(mediaShares: Object): Object

Parameters

mediaShares (Object)

Returns

Object:

getWhiteboardResourceUrl

packages/@webex/plugin-meetings/src/locus-info/mediaSharesUtils.ts

get the which whiteboard is being shared via resource url

getWhiteboardResourceUrl(mediaShares: Object): Object

Parameters

mediaShares (Object)

Returns

Object:

compare

packages/@webex/plugin-meetings/src/locus-info/parser.ts

Compares two loci to determine which one contains the most recent state

compare(current: Types~Locus, incoming: Types~Locus): string

Parameters

current (Types~Locus)

incoming (Types~Locus)

Returns

string: loci comparison state

LociMetadata

packages/@webex/plugin-meetings/src/locus-info/parser.ts

LociMetadata

Type: object

Properties

start (number) : Starting sequence number

end (number) : Ending sequence number

first (number) : First sequence number

last (number) : Last sequence number

min (number) : Minimum sequence number

max (number) : Maximum sequence number

entries (number) : Loci sequence entries

SortedQueue

packages/@webex/plugin-meetings/src/common/queue.ts

Simple queue in which the elements are always sorted

new SortedQueue(compareFunc: Function)

Parameters

compareFunc (Function) comparison function used for sorting the elements of the queue

Instance Members

▸ clear()

packages/@webex/plugin-meetings/src/common/queue.ts

Removes all of the elements from queue.

clear(): undefined

Returns

undefined:

▸ enqueue(item)

packages/@webex/plugin-meetings/src/common/queue.ts

Inserts the specified element into the queue.

enqueue(item: object): undefined

Parameters

item (object)

Returns

undefined:

▸ dequeue()

packages/@webex/plugin-meetings/src/common/queue.ts

Returns and removes the head of the queue. Returns null if the queue is empty.

dequeue(): (object | null)

Returns

(object | null): Queue item or null.

▸ size()

packages/@webex/plugin-meetings/src/common/queue.ts

Returns the number of items in queue.

size(): number

Returns

number:

NeedsRetryError

packages/@webex/plugin-meetings/src/reconnection-manager/index.ts

Used to indicate that the reconnect logic needs to be retried.

new NeedsRetryError()

Extends Error

NeedsRejoinError

packages/@webex/plugin-meetings/src/reconnection-manager/index.ts

Used to indicate that the meeting needs to be rejoined, not just media reconnected

new NeedsRejoinError()

Extends Error

ReconnectionManager

packages/@webex/plugin-meetings/src/reconnection-manager/index.ts

new ReconnectionManager()

Static Members

▸ resetReconnectionTimer()

packages/@webex/plugin-meetings/src/reconnection-manager/index.ts

resetReconnectionTimer(): void

Returns

void:

▸ iceReconnected()

packages/@webex/plugin-meetings/src/reconnection-manager/index.ts

Sets the iceState to connected and clears any disconnect timeouts and related timeout data within the iceState.

iceReconnected(): undefined

Returns

undefined:

▸ waitForIceReconnect()

packages/@webex/plugin-meetings/src/reconnection-manager/index.ts

Set the iceState to disconnected and generates a timeout that waits for the iceState to reconnect and then resolves. If the ice state is already processing a reconnect, it immediately resolves. Rejects if the timeout duration is reached.

waitForIceReconnect(): Promise<undefined>

Returns

Promise<undefined>:

▸ reset()

packages/@webex/plugin-meetings/src/reconnection-manager/index.ts

reset(): undefined

Returns

undefined:

▸ cleanUp()

packages/@webex/plugin-meetings/src/reconnection-manager/index.ts

cleanUp(): undefined

Returns

undefined:

▸ isReconnectInProgress()

packages/@webex/plugin-meetings/src/reconnection-manager/index.ts

isReconnectInProgress(): Boolean

Returns

Boolean: true if reconnection operation is in progress

▸ reconnect(reconnectOptions, completionCallback = undefined)

packages/@webex/plugin-meetings/src/reconnection-manager/index.ts

Initiates a media reconnect for the active meeting

reconnect(reconnectOptions: Object, completionCallback: Function?): Promise

Parameters

reconnectOptions

(Object
            = {})

Name	Description
reconnectOptions.networkDisconnect `boolean` (default `false`)	indicates if a network disconnect event happened
reconnectOptions.networkRetry `boolean` (default `false`)	indicates if we are retrying the reconnect

completionCallback

(Function?
            = undefined)

callback that gets called when reconnection is started successfully

Returns

Promise:

Instance Members

▸ rejoinMeeting(wasSharing)

packages/@webex/plugin-meetings/src/reconnection-manager/index.ts

Rejoins a meeting after detecting the member was in a LEFT state

rejoinMeeting(wasSharing: boolean): Promise

Parameters

wasSharing

(boolean
            = false)

Returns

Promise:

ReconnectionNotStartedError

packages/@webex/plugin-meetings/src/common/errors/reconnection-not-started.ts

Error object for cases when new reconnection cannot be started

new ReconnectionNotStartedError(message: String?, error: Object?)

Extends ReconnectionError

Parameters

message

(String?
            = ERROR_DICTIONARY.RECONNECTION_NOT_STARTED.MESSAGE)

error

(Object?
            = null)

ReconnectionError

packages/@webex/plugin-meetings/src/common/errors/reconnection.ts

Extended Error object to signify the intent to join for unclaimed PMR scenarios

new ReconnectionError(message: String?, error: Object?)

Extends Error

Parameters

message

(String?
            = ERROR_DICTIONARY.RECONNECTION.MESSAGE)

error

(Object?
            = null)

Members

packages/@webex/plugin-meetings/src/members/index.ts

new Members()

Static Members

▸ setLocusUrl(locus, locusUrl = null)

packages/@webex/plugin-meetings/src/members/index.ts

Update the locus Url

setLocusUrl(locus: Object, locusUrl: String?): undefined

Parameters

locus (Object)

locusUrl

(String?
            = null)

optional, takes precedence

Returns

undefined:

Throws

ParameterError:

▸ setHostId(locus, hostId = null)

packages/@webex/plugin-meetings/src/members/index.ts

Update the host id

setHostId(locus: Object, hostId: String?): undefined

Parameters

locus (Object)

hostId

(String?
            = null)

optional, takes precedence

Returns

undefined:

Throws

ParameterError:

▸ setType(fullState, type = null)

packages/@webex/plugin-meetings/src/members/index.ts

Update the type

setType(fullState: Object, type: String?): undefined

Parameters

fullState (Object)

type

(String?
            = null)

optional, takes precedence

Returns

undefined:

Throws

ParameterError:

▸ setSelfId(locus, selfId = null)

packages/@webex/plugin-meetings/src/members/index.ts

Update the self Id

setSelfId(locus: Object, selfId: String?): undefined

Parameters

locus (Object)

selfId

(String?
            = null)

optional, takes precedence

Returns

undefined:

Throws

Error:

▸ setMediaShareContentId(locus, contentId?)

packages/@webex/plugin-meetings/src/members/index.ts

Update the media share content id

setMediaShareContentId(locus: Object, contentId: String?): undefined

Parameters

locus (Object)

contentId (String?) optional, takes precedence

Returns

undefined:

Throws

Error:

▸ setMediaShareWhiteboardId(locus, whiteboardId?)

packages/@webex/plugin-meetings/src/members/index.ts

Update the media share whiteboard id

setMediaShareWhiteboardId(locus: Object, whiteboardId: String?): undefined

Parameters

locus (Object)

whiteboardId (String?) optional, takes precedence

Returns

undefined:

Throws

Error:

▸ addMember(invitee, alertIfActive?)

packages/@webex/plugin-meetings/src/members/index.ts

Adds a guest Member to the associated meeting

addMember(invitee: String, alertIfActive: Boolean?): Promise

Parameters

invitee (String)

alertIfActive (Boolean?)

Returns

Promise:

▸ cancelPhoneInvite(invitee)

packages/@webex/plugin-meetings/src/members/index.ts

Cancels an outgoing PSTN call to the associated meeting

cancelPhoneInvite(invitee: String): Promise

Parameters

invitee (String)

Returns

Promise:

▸ admitMembers(memberIds, sessionLocusUrls)

packages/@webex/plugin-meetings/src/members/index.ts

Admits waiting members (invited guests to meeting)

admitMembers(memberIds: Array, sessionLocusUrls: Object): Promise

Parameters

memberIds (Array)

sessionLocusUrls (Object) : {authorizingLocusUrl, mainLocusUrl}

Returns

Promise:

▸ removeMember(memberId)

packages/@webex/plugin-meetings/src/members/index.ts

Removes a member from the meeting

removeMember(memberId: String): Promise

Parameters

memberId (String)

Returns

Promise:

▸ muteMember(memberId, mute = true, isAudio = true)

packages/@webex/plugin-meetings/src/members/index.ts

Audio mutes another member in a meeting

muteMember(memberId: String, mute: boolean?, isAudio: boolean?): Promise

Parameters

memberId (String)

mute

(boolean?
            = true)

default true

isAudio

(boolean?
            = true)

default true

Returns

Promise:

▸ assignRoles(memberId, roles)

packages/@webex/plugin-meetings/src/members/index.ts

Assign role(s) to a member in the meeting

assignRoles(memberId: String, roles: [ServerRoleShape]): Promise

Parameters

memberId (String)

roles ([ServerRoleShape]) to assign an array of roles

Returns

Promise:

▸ raiseOrLowerHand(memberId, raise = true)

packages/@webex/plugin-meetings/src/members/index.ts

Raise or lower the hand of a member in a meeting

raiseOrLowerHand(memberId: String, raise: boolean?): Promise

Parameters

memberId (String)

raise

(boolean?
            = true)

to raise hand (=true) or lower (=false), default: true

Returns

Promise:

▸ lowerAllHands(requestingMemberId)

packages/@webex/plugin-meetings/src/members/index.ts

Lower all hands of members in a meeting

lowerAllHands(requestingMemberId: String): Promise

Parameters

requestingMemberId (String) id of the participant which requested the lower all hands

Returns

Promise:

▸ transferHostToMember(memberId, moderator = true)

packages/@webex/plugin-meetings/src/members/index.ts

Transfers the host to another member

transferHostToMember(memberId: String, moderator: boolean?): Promise

Parameters

memberId (String)

moderator

(boolean?
            = true)

default true

Returns

Promise:

▸ sendDialPadKey(tones, memberId)

packages/@webex/plugin-meetings/src/members/index.ts

Sends DTMF tones for the PSTN member of a meeting

sendDialPadKey(tones: String, memberId: String): Promise

Parameters

tones

(String
            = '')

a string of one or more DTMF tones to send

memberId

(String
            = '')

member id

Returns

Promise:

▸ editDisplayName(memberId, requestingParticipantId, alias?)

packages/@webex/plugin-meetings/src/members/index.ts

Edit display name of participants in a meeting

editDisplayName(memberId: string, requestingParticipantId: string, alias: string?): Promise

Parameters

memberId (string) id of the participant who is receiving request

requestingParticipantId (string) id of the participant who is sending request (optional)

alias (string?) alias name

Returns

Promise:

Instance Members

▸ findMemberByCsi(csi)

packages/@webex/plugin-meetings/src/members/index.ts

Finds a member that has any device with a csi matching provided value

findMemberByCsi(csi: number): Member

Parameters

csi (number)

Returns

Member:

▸ getCsisForMember(memberId, mediaType, mediaContent)

packages/@webex/plugin-meetings/src/members/index.ts

Returns an array of a member's CSIs matching the mediaType and mediaContent

getCsisForMember(memberId: string, mediaType: string, mediaContent: string): Member

Parameters

memberId (string)

mediaType

(string
            = 'video')

'audio' or 'video'

mediaContent

(string
            = 'main')

'main' or 'slides'

Returns

Member:

Events

▸ members:update

packages/@webex/plugin-meetings/src/members/index.ts

Members Update Event Emitted when something in the roster list needs to be updated

members:update

Properties

delta (Object) : the changes to the members list

delta.updated Array
array only the updates, includes removals, as they will have updated status and member properties
delta.added Array
array added members to the meeting

full (Array) : array the full members collection

▸ members:content:update

packages/@webex/plugin-meetings/src/members/index.ts

Members Content Update Event Emitted when who is sharing changes

members:content:update

Properties

activeContentSharingId (String)

endedContentSharingId (String)

▸ members:host:update

packages/@webex/plugin-meetings/src/members/index.ts

Members Host Update Event Emitted when who is the host changes

members:host:update

Properties

activeHostId (String)

endedHostId (String)

▸ members:self:update

packages/@webex/plugin-meetings/src/members/index.ts

Members Self Update Event Emitted when who is the self changes

members:self:update

Properties

activeSelfId (String)

endedSelfId (String)

Member

packages/@webex/plugin-meetings/src/member/index.ts

new Member()

Static Members

▸ setIsContentSharing(flag)

packages/@webex/plugin-meetings/src/member/index.ts

set the isContentSharing on member

setIsContentSharing(flag: Boolean): undefined

Parameters

flag (Boolean)

Returns

undefined:

▸ setIsHost(flag)

packages/@webex/plugin-meetings/src/member/index.ts

set the isHost on member

setIsHost(flag: Boolean): undefined

Parameters

flag (Boolean)

Returns

undefined:

▸ setIsSelf(flag)

packages/@webex/plugin-meetings/src/member/index.ts

set the isSelf on member

setIsSelf(flag: Boolean): undefined

Parameters

flag (Boolean)

Returns

undefined:

▸ processIsContentSharing(participant, sharingId)

packages/@webex/plugin-meetings/src/member/index.ts

determine if this member is content sharing

processIsContentSharing(participant: Object, sharingId: String): undefined

Parameters

participant (Object)

sharingId (String)

Returns

undefined:

▸ processIsRecording(participant, recordingId)

packages/@webex/plugin-meetings/src/member/index.ts

Determine if this member is recording

processIsRecording(participant: Object, recordingId: String): undefined

Parameters

participant (Object)

recordingId (String)

Returns

undefined:

Instance Members

▸ canReclaimHost

packages/@webex/plugin-meetings/src/member/index.ts

canReclaimHost

Type: Boolean

▸ id

packages/@webex/plugin-meetings/src/member/index.ts

The member id

id

Type: String

▸ name

packages/@webex/plugin-meetings/src/member/index.ts

The member name

name

Type: String

▸ isAudioMuted

packages/@webex/plugin-meetings/src/member/index.ts

isAudioMuted

Type: Boolean

▸ isVideoMuted

packages/@webex/plugin-meetings/src/member/index.ts

isVideoMuted

Type: Boolean

▸ isHandRaised

packages/@webex/plugin-meetings/src/member/index.ts

isHandRaised

Type: Boolean

▸ supportsBreakouts

packages/@webex/plugin-meetings/src/member/index.ts

supportsBreakouts

Type: Boolean

▸ supportLiveAnnotation

packages/@webex/plugin-meetings/src/member/index.ts

supportLiveAnnotation

Type: Boolean

▸ isSelf

packages/@webex/plugin-meetings/src/member/index.ts

isSelf

Type: Boolean

▸ isHost

packages/@webex/plugin-meetings/src/member/index.ts

isHost

Type: Boolean

▸ isGuest

packages/@webex/plugin-meetings/src/member/index.ts

isGuest

Type: Boolean

▸ isInLobby

packages/@webex/plugin-meetings/src/member/index.ts

isInLobby

Type: Boolean

▸ isInMeeting

packages/@webex/plugin-meetings/src/member/index.ts

isInMeeting

Type: Boolean

▸ isNotAdmitted

packages/@webex/plugin-meetings/src/member/index.ts

isNotAdmitted

Type: Boolean

▸ isContentSharing

packages/@webex/plugin-meetings/src/member/index.ts

isContentSharing

Type: Boolean

▸ status

packages/@webex/plugin-meetings/src/member/index.ts

status

Type: Boolean

▸ isDevice

packages/@webex/plugin-meetings/src/member/index.ts

isDevice

Type: Boolean

▸ isUser

packages/@webex/plugin-meetings/src/member/index.ts

isUser

Type: Boolean

▸ associatedUser

packages/@webex/plugin-meetings/src/member/index.ts

Is this member associated to another user by way of pairing (typical of devices)

associatedUser

Type: String

▸ isRecording

packages/@webex/plugin-meetings/src/member/index.ts

isRecording

Type: Boolean

▸ isMutable

packages/@webex/plugin-meetings/src/member/index.ts

isMutable

Type: Boolean

▸ isRemovable

packages/@webex/plugin-meetings/src/member/index.ts

isRemovable

Type: Boolean

▸ isModerator

packages/@webex/plugin-meetings/src/member/index.ts

isModerator

Type: Boolean

▸ isModeratorAssignmentProhibited

packages/@webex/plugin-meetings/src/member/index.ts

isModeratorAssignmentProhibited

Type: Boolean

▸ roles

packages/@webex/plugin-meetings/src/member/index.ts

roles

Type: IExternalRoles

▸ mediaStatus

packages/@webex/plugin-meetings/src/member/index.ts

mediaStatus

Type: IMediaStatus

Example

{audio: MediaStatus.RECVONLY, video: MediaStatus.SENDRECV}

canReclaimHost

canReclaimHost(participant: Object): Boolean

Parameters

participant (Object) the locus participant

Returns

Boolean:

getControlsRoles

getControlsRoles(participant: Object): [ServerRoleShape]

Parameters

participant (Object) the locus participant

Returns

[ServerRoleShape]:

hasRole

utility method for audio/video muted status

isMuted(participant: any, statusAccessor: String, controlsAccessor: String): (Boolean | undefined)

Parameters

participant (any)

statusAccessor (String)

controlsAccessor (String)

Returns

(Boolean | undefined):

getRecordingMember

utility method for getting the recording member for later comparison

getRecordingMember(controls: Object): (String | null)

Parameters

controls (Object)

Returns

(String | null):

isRecording

isRecording(participant: Object): Boolean

Parameters

participant (Object) the locus participant

Returns

Boolean:

extractStatus

extractStatus(participant: Object): String

Parameters

participant (Object) the locus participant

Returns

String:

extractId

extractId(participant: Object): String

Parameters

participant (Object) the locus participant

Returns

String:

extractMediaStatus

extracts the media status from nested participant object

extractMediaStatus(participant: Object): Object

Parameters

participant (Object) the locus participant

Returns

Object:

extractName

docs https://sqbu-github.cisco.com/pages/WebExSquared/locus/guides/mute.html https://confluence-eng-gpk2.cisco.com/conf/display/LOCUS/Hard+Mute+and+Audio+Privacy#HardMuteandAudioPrivacy-SelfMuteonEntry https://confluence-eng-gpk2.cisco.com/conf/pages/viewpage.action?spaceKey=UC&title=WEBEX-124454%3A+UCF%3A+Hard+mute+support+for+Teams+joining+Webex+meeting https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-180867 https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-393351

extractName(participant: Object): String

Parameters

participant (Object) the locus participant

Returns

String:

MembersCollection

packages/@webex/plugin-meetings/src/members/collection.ts

new MembersCollection()

Static Members

▸ getAll()

packages/@webex/plugin-meetings/src/members/collection.ts

getAll(): Object

Returns

Object: returns an object map of Member instances

Instance Members

▸ get(id)

packages/@webex/plugin-meetings/src/members/collection.ts

get(id: String): Member

Parameters

id (String)

Returns

Member:

▸ reset()

packages/@webex/plugin-meetings/src/members/collection.ts

reset(): void

Returns

void: reset members

MembersRequest

packages/@webex/plugin-meetings/src/members/request.ts

new MembersRequest()

Static Members

▸ addMembers(options)

packages/@webex/plugin-meetings/src/members/request.ts

addMembers(options: Object): Promise

Parameters

options (Object) with format of {invitee: string, locusUrl: string}

Returns

Promise:

Throws

Error: if the options are not valid and complete, must have invitee with emailAddress OR email AND locusUrl

▸ admitMember(options)

packages/@webex/plugin-meetings/src/members/request.ts

admitMember(options: Object): Promise

Parameters

options (Object)

Returns

Promise:

Throws

Error: if the options are not valid and complete, must have memberIds AND locusUrl

▸ editDisplayNameMember(options)

packages/@webex/plugin-meetings/src/members/request.ts

editDisplayNameMember(options: Object): Promise

Parameters

options (Object) with format of {locusUrl: string, requestingParticipantId: string}

Returns

Promise:

Throws

Error: if the options are not valid and complete, must have requestingParticipantId AND locusUrl

▸ cancelPhoneInvite(options)

packages/@webex/plugin-meetings/src/members/request.ts

cancelPhoneInvite(options: Object): Promise

Parameters

options (Object) with format of {invitee: string, locusUrl: string}

Returns

Promise:

Throws

Error: if the options are not valid and complete, must have invitee with emailAddress OR email AND locusUrl

Instance Members

▸ removeMember(options)

packages/@webex/plugin-meetings/src/members/request.ts

Sends a request to remove a member

removeMember(options: Object): Promise

Parameters

options (Object)

Name	Description
options.locusUrl `String`
options.memberId `String`	ID of member

Returns

Promise:

▸ muteMember(options)

packages/@webex/plugin-meetings/src/members/request.ts

Sends a request to mute a member

muteMember(options: Object): Promise

Parameters

options (Object)

Name	Description
options.locusUrl `String`
options.memberId `String`	ID of member

Returns

Promise:

▸ assignRolesMember(options)

packages/@webex/plugin-meetings/src/members/request.ts

Sends a request to the DTMF endpoint to send tones

assignRolesMember(options: Object): Promise

Parameters

options (Object)

Name	Description
options.locusUrl `String`
options.memberId `String`	ID of PSTN user

Returns

Promise:

▸ raiseOrLowerHandMember(options)

packages/@webex/plugin-meetings/src/members/request.ts

Sends a request to raise or lower a member's hand

raiseOrLowerHandMember(options: Object): Promise

Parameters

options (Object)

Name	Description
options.locusUrl `String`
options.memberId `String`	ID of member

Returns

Promise:

▸ lowerAllHandsMember(options)

packages/@webex/plugin-meetings/src/members/request.ts

Sends a request to lower all hands

lowerAllHandsMember(options: Object): Promise

Parameters

options (Object)

Name	Description
options.locusUrl `String`
options.requestingParticipantId `String`	ID of requesting participant

Returns

Promise:

▸ transferHostToMember(options)

packages/@webex/plugin-meetings/src/members/request.ts

Sends a request to raise or lower a member's hand

transferHostToMember(options: Object): Promise

Parameters

options (Object)

Name	Description
options.locusUrl `String`
options.memberId `String`	ID of member
options.moderator `String`	ID of moderator

Returns

Promise:

▸ sendDialPadKey(options)

packages/@webex/plugin-meetings/src/members/request.ts

Sends a request to the DTMF endpoint to send tones

sendDialPadKey(options: Object): Promise

Parameters

options (Object)

Name	Description
options.locusUrl `String`
options.url `String`	device url SIP user
options.tones `String`	a string of one or more DTMF tones to send
options.memberId `String`	ID of PSTN user

Returns

Promise:

generateAddMemberOptions

packages/@webex/plugin-meetings/src/members/util.ts

generateAddMemberOptions(invitee: Object, locusUrl: String, alertIfActive: Boolean): Object

Parameters

invitee (Object) with emailAddress, email or phoneNumber

locusUrl (String)

alertIfActive (Boolean)

Returns

Object: the format object

generateAdmitMemberOptions

packages/@webex/plugin-meetings/src/members/util.ts

RoleAssignmentOptions:

generateEditDisplayNameMemberOptions

packages/@webex/plugin-meetings/src/members/util.ts

generateEditDisplayNameMemberOptions(memberId: String, requestingParticipantId: String, alias: String, locusUrl: String): Object

Parameters

memberId (String) id of the participant who is receiving request

requestingParticipantId (String) id of the participant who is sending request (optional)

alias (String) alias name

locusUrl (String) url

Returns

Object: consists of {memberID: string, requestingParticipantId: string, alias: string, locusUrl: string}

getAddedRoleShape

packages/@webex/plugin-meetings/src/members/util.ts

getAddedRoleShape(role: ServerRoleShape): ServerRoleShape

Parameters

role (ServerRoleShape)

Returns

ServerRoleShape: the role shape to be added to the body

getRoleAssignmentMemberRequestParams

packages/@webex/plugin-meetings/src/members/util.ts

getRoleAssignmentMemberRequestParams(options: RoleAssignmentOptions): RoleAssignmentRequest

Parameters

options (RoleAssignmentOptions)

Returns

RoleAssignmentRequest: the request parameters (method, uri, body) needed to make a addMember request

editDisplayNameMemberRequestParams

packages/@webex/plugin-meetings/src/members/util.ts

editDisplayNameMemberRequestParams(options: Object): Object

Parameters

options (Object) with format of {locusUrl: string, requestingParticipantId: string}

Returns

Object: request parameters (method, uri, body) needed to make a editDisplayName request

Utils

packages/@webex/plugin-meetings/src/controls-options-manager/util.ts

The Controls Options Manager utilities

new Utils()

Static Members

▸ canSetMuteOnEntry(displayHints)

packages/@webex/plugin-meetings/src/controls-options-manager/util.ts

Validate if enabling mute on entry can be set.

canSetMuteOnEntry(displayHints: Array<string>): boolean

Parameters

displayHints (Array<string>) Display Hints to use when validating.

Returns

boolean: True if the action is allowed.

▸ canSetDisallowUnmute(displayHints)

packages/@webex/plugin-meetings/src/controls-options-manager/util.ts

Validate if allowing unmuting can be set.

canSetDisallowUnmute(displayHints: Array<string>): boolean

Parameters

displayHints (Array<string>) Display Hints to use when validating.

Returns

boolean: True if the action is allowed.

▸ canUnsetMuteOnEntry(displayHints)

packages/@webex/plugin-meetings/src/controls-options-manager/util.ts

Validate if disabling mute on entry can be set.

canUnsetMuteOnEntry(displayHints: Array<string>): boolean

Parameters

displayHints (Array<string>) Display Hints to use when validating.

Returns

boolean: True if the action is allowed.

▸ canUnsetDisallowUnmute(displayHints)

packages/@webex/plugin-meetings/src/controls-options-manager/util.ts

Validate if enabling muting can be set.

canUnsetDisallowUnmute(displayHints: Array<string>): boolean

Parameters

displayHints (Array<string>) Display Hints to use when validating.

Returns

boolean: True if the action is allowed.

▸ canSetMuted(displayHints)

packages/@webex/plugin-meetings/src/controls-options-manager/util.ts

Validate if muting all can be set.

canSetMuted(displayHints: Array<string>): boolean

Parameters

displayHints (Array<string>) Display Hints to use when validating.

Returns

boolean: True if the action is allowed.

▸ canUnsetMuted(displayHints)

packages/@webex/plugin-meetings/src/controls-options-manager/util.ts

Validate if unmuting all can be set.

canUnsetMuted(displayHints: Array<string>): boolean

Parameters

displayHints (Array<string>) Display Hints to use when validating.

Returns

boolean: True if the action is allowed.

▸ hasHints(config)

packages/@webex/plugin-meetings/src/controls-options-manager/util.ts

Validate an array of hints are allowed based on a full collection of hints.

hasHints(config: Object): boolean

Parameters

config (Object) Configuration Object.

Name	Description
config.requiredHints `Array<string>`	Hints required for validation.
config.displayHints `Array<string>`	All available hints.

Returns

boolean: True if all of the actions are allowed.

▸ hasPolicies(config)

packages/@webex/plugin-meetings/src/controls-options-manager/util.ts

Validate that the self policy object contains the required policies.

hasPolicies(config: Object): boolean

Parameters

config (Object) Configuration Object.

Name	Description
config.requiredPolicies `Array<string>`	Policies required for validation.
config.policies `Array<string>`	All available policies.

Returns

boolean: True if all of the actions are allowed.

▸ canUpdateAudio(control, displayHints)

packages/@webex/plugin-meetings/src/controls-options-manager/util.ts

Validate if an audio-scoped control is allowed to be sent to the service.

canUpdateAudio(control: ControlConfig<AudioProperties>, displayHints: Array<string>): boolean

Parameters

control (ControlConfig<AudioProperties>) Audio control config to validate.

displayHints (Array<string>) All available hints.

Returns

boolean: True if all of the actions are allowed.

▸ canUpdateReactions(control, displayHints)

packages/@webex/plugin-meetings/src/controls-options-manager/util.ts

Validate if an reactions-scoped control is allowed to be sent to the service.

canUpdateReactions(control: ControlConfig<ReactionsProperties>, displayHints: Array<string>): boolean

Parameters

control (ControlConfig<ReactionsProperties>) Reaction control config to validate.

displayHints (Array<string>) All available hints.

Returns

boolean: True if all of the actions are allowed.

▸ canUpdateShareControl(displayHints)

packages/@webex/plugin-meetings/src/controls-options-manager/util.ts

Validate if an share-control-scoped control is allowed to be sent to the service.

canUpdateShareControl(displayHints: Array<string>): boolean

Parameters

displayHints (Array<string>) All available hints.

Returns

boolean: True if all of the actions are allowed.

▸ canUpdateViewTheParticipantsList(control, displayHints)

packages/@webex/plugin-meetings/src/controls-options-manager/util.ts

Validate if an view-the-participants-list-scoped control is allowed to be sent to the service.

canUpdateViewTheParticipantsList(control: ControlConfig<ViewTheParticipantListProperties>, displayHints: Array<string>): boolean

Parameters

control (ControlConfig<ViewTheParticipantListProperties>) View Participants List control config to validate.

displayHints (Array<string>) All available hints.

Returns

boolean: True if all of the actions are allowed.

▸ canUpdateVideo(control, displayHints)

packages/@webex/plugin-meetings/src/controls-options-manager/util.ts

Validate if a video-scoped control is allowed to be sent to the service.

canUpdateVideo(control: ControlConfig<VideoProperties>, displayHints: Array<string>): boolean

Parameters

control (ControlConfig<VideoProperties>) Video control config to validate.

displayHints (Array<string>) All available hints.

Returns

boolean: True if all of the actions are allowed.

▸ canUpdate(control, displayHints)

packages/@webex/plugin-meetings/src/controls-options-manager/util.ts

Validate that a control can be sent to the service based on the provided display hints.

canUpdate(control: ControlConfig, displayHints: Array<string>): boolean

Parameters

control (ControlConfig) Control to validate.

displayHints (Array<string>) All available hints.

Returns

boolean: True if all of the actions are allowed.

key

packages/@webex/plugin-meetings/src/controls-options-manager/types.ts

A list of additional properties that apply to various specific settings.

key

scope

packages/@webex/plugin-meetings/src/controls-options-manager/types.ts

The scope of the control within this object.

scope

Type: Control

properties

packages/@webex/plugin-meetings/src/controls-options-manager/types.ts

The properties to assign to this control.

properties

Type: Props

ReceiveSlotManager

packages/@webex/plugin-meetings/src/multistream/receiveSlotManager.ts

Manages all receive slots used by a meeting. WMCE receive slots cannot be ever deleted, so this manager has a pool in order to re-use the slots that were released earlier.

new ReceiveSlotManager(createSlotCallback: CreateSlotCallback, findMemberIdByCsiCallback: FindMemberIdCallback, meeting: Meeting)

Parameters

createSlotCallback (CreateSlotCallback)

findMemberIdByCsiCallback (FindMemberIdCallback)

meeting (Meeting)

Instance Members

▸ allocateSlot(mediaType)

packages/@webex/plugin-meetings/src/multistream/receiveSlotManager.ts

Creates a new receive slot or returns one from the existing pool of free slots

allocateSlot(mediaType: MediaType): Promise<ReceiveSlot>

Parameters

mediaType (MediaType)

Returns

Promise<ReceiveSlot>:

▸ releaseSlot(slot)

packages/@webex/plugin-meetings/src/multistream/receiveSlotManager.ts

Releases the slot back to the pool so it can be re-used by others in the future

releaseSlot(slot: ReceiveSlot)

Parameters

slot (ReceiveSlot)

▸ reset()

packages/@webex/plugin-meetings/src/multistream/receiveSlotManager.ts

Resets the slot manager - this method should be called when the media connection is torn down

reset()

▸ getStats()

packages/@webex/plugin-meetings/src/multistream/receiveSlotManager.ts

Returns statistics about the managed slots

getStats(): Object

Returns

Object:

▸ updateMemberIds()

packages/@webex/plugin-meetings/src/multistream/receiveSlotManager.ts

Tries to find the member id on all allocated receive slots This function should be called when new members are added to the meeting.

updateMemberIds()

▸ findReceiveSlotBySsrc(ssrc)

packages/@webex/plugin-meetings/src/multistream/receiveSlotManager.ts

Find a receive slot by a ssrc.

findReceiveSlotBySsrc(ssrc: number): (ReceiveSlot | undefined)

Parameters

ssrc (number) The ssrc of the receive slot to find.

Returns

(ReceiveSlot | undefined): The receive slot with this ssrc, undefined if not found.

createSlot

packages/@webex/plugin-meetings/src/multistream/sendSlotManager.ts

This method is used to create a sendSlot for the given mediaType and returns the created sendSlot

createSlot(mediaConnection: MultistreamRoapMediaConnection, mediaType: MediaType, active: boolean): SendSlot

Parameters

mediaConnection (MultistreamRoapMediaConnection) MultistreamRoapMediaConnection for which a sendSlot needs to be created

mediaType (MediaType) MediaType for which a sendSlot needs to be created (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)

active

(boolean
            = true)

This is optional boolean to set the active state of the sendSlot. Default is true

Returns

SendSlot: slot The created sendSlot

packages/@webex/plugin-meetings/src/multistream/sendSlotManager.ts

This method unpublishes the stream from the sendSlot of the given mediaType

unpublishStream(mediaType: MediaType): Promise<void>

Parameters

mediaType (MediaType) MediaType of the sendSlot from which a stream needs to be unpublished (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)

Returns

Promise<void>:

setActive

packages/@webex/plugin-meetings/src/multistream/sendSlotManager.ts

This method is used to set the active state of the sendSlot for the given mediaType

setActive(mediaType: MediaType, active: boolean): void

Parameters

mediaType (MediaType) The MediaType of the sendSlot for which the active state needs to be set (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)

active

(boolean
            = true)

The boolean to set the active state of the sendSlot. Default is true

Returns

void:

setCodecParameters

packages/@webex/plugin-meetings/src/multistream/sendSlotManager.ts

This method is used to set the codec parameters for the sendSlot of the given mediaType

setCodecParameters(mediaType: MediaType, codecParameters: Object): Promise<void>

Parameters

mediaType (MediaType) MediaType of the sendSlot for which the codec parameters needs to be set (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)

codecParameters (Object)

Returns

Promise<void>:

deleteCodecParameters

packages/@webex/plugin-meetings/src/multistream/sendSlotManager.ts

This method is used to delete the codec parameters for the sendSlot of the given mediaType

deleteCodecParameters(mediaType: MediaType, parameters: Array<String>): Promise<void>

Parameters

mediaType (MediaType) MediaType of the sendSlot for which the codec parameters needs to be deleted (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)

parameters (Array<String>) Array of keys of the codec parameters to be deleted

Returns

Promise<void>:

reset

packages/@webex/plugin-meetings/src/multistream/sendSlotManager.ts

This method is used to reset the SendSlotsManager by deleting all the sendSlots

reset(): undefined

Returns

undefined:

DefaultConfiguration

packages/@webex/plugin-meetings/src/multistream/remoteMediaManager.ts

Default configuration:

uses 3 audio streams
prefers active speakers with live video (e.g. are not audio only or video muted) over active speakers without live video
has a few layouts defined, including 1 that contains remote screen share (ScreenShareView)

DefaultConfiguration

Type: Configuration

RemoteMediaManager

packages/@webex/plugin-meetings/src/multistream/remoteMediaManager.ts

A helper class that manages all remote audio/video streams in order to achieve a predefined set of layouts. It also creates a fixed number of audio streams and these don't change during the meeting.

Things that RemoteMediaManager does:

owns the receive slots (creates them when needed, and re-uses them when switching layouts)
constructs appropriate RemoteMedia and RemoteMediaGroup objects and sends appropriate mediaRequests

new RemoteMediaManager(receiveSlotManager: ReceiveSlotManager, mediaRequestManagers: {audio: MediaRequestManager, video: mediaRequestManagers}, config: Configuration)

Extends EventsScope

Parameters

receiveSlotManager (ReceiveSlotManager)

mediaRequestManagers ({audio: MediaRequestManager, video: mediaRequestManagers})

config

(Configuration
            = DefaultConfiguration)

Configuration describing what video layouts to use during the meeting

Instance Members

▸ start()

packages/@webex/plugin-meetings/src/multistream/remoteMediaManager.ts

Starts the RemoteMediaManager.

start(): Promise

Returns

Promise:

▸ stop()

packages/@webex/plugin-meetings/src/multistream/remoteMediaManager.ts

Releases all the used resources (like allocated receive slots). This function needs to be called when we leave the meeting, etc.

stop()

▸ setLayout(layoutId)

packages/@webex/plugin-meetings/src/multistream/remoteMediaManager.ts

Changes the layout (triggers Event.VideoLayoutChanged)

setLayout(layoutId: LayoutId): Promise

Parameters

layoutId (LayoutId) new layout id

Returns

Promise:

▸ getLayoutId()

packages/@webex/plugin-meetings/src/multistream/remoteMediaManager.ts

Returns the currently selected layout id

getLayoutId(): LayoutId

Returns

LayoutId:

▸ setPreferLiveVideo(preferLiveVideo)

packages/@webex/plugin-meetings/src/multistream/remoteMediaManager.ts

sets the preferLiveVideo

setPreferLiveVideo(preferLiveVideo: boolean)

Parameters

preferLiveVideo (boolean)

▸ setActiveSpeakerCsis(remoteMediaCsis)

packages/@webex/plugin-meetings/src/multistream/remoteMediaManager.ts

Sets CSIs for multiple RemoteMedia instances belonging to RemoteMediaGroup. For each entry in the remoteMediaCsis array:

if csi is specified, the RemoteMedia instance is pinned to that CSI
if csi is undefined, the RemoteMedia instance is unpinned

setActiveSpeakerCsis(remoteMediaCsis: Array<{remoteMedia: RemoteMedia, csi: number?}>)

Parameters

remoteMediaCsis (Array<{remoteMedia: RemoteMedia, csi: number?}>)

▸ setReceiveNamedMediaGroup(mediaType, languageId, languageCode)

packages/@webex/plugin-meetings/src/multistream/remoteMediaManager.ts

Sets which named media group need receiving

setReceiveNamedMediaGroup(mediaType: MediaType, languageId: number, languageCode: number): void

Parameters

mediaType (MediaType) of the stream

languageId (number)

languageCode (number) of the stream. If the languageId is 0, the named media group request will be canceled, and only receive the main audio stream.

Returns

void:

▸ logAllReceiveSlots()

packages/@webex/plugin-meetings/src/multistream/remoteMediaManager.ts

Logs all current receive slots

logAllReceiveSlots()

▸ setRemoteVideoCsi(remoteMedia, csi)

packages/@webex/plugin-meetings/src/multistream/remoteMediaManager.ts

Sets a new CSI on a given remote media object

setRemoteVideoCsi(remoteMedia: RemoteMedia, csi: CSI)

Parameters

remoteMedia (RemoteMedia) remote Media object to modify

csi (CSI) new CSI value, can be null if we want to stop receiving media

▸ addMemberVideoPane(newPane)

packages/@webex/plugin-meetings/src/multistream/remoteMediaManager.ts

Adds a new member video pane to the currently selected layout.

Changes to the layout are lost after a layout change.

addMemberVideoPane(newPane: MemberVideoPane): Promise<RemoteMedia>

Parameters

newPane (MemberVideoPane)

Returns

Promise<RemoteMedia>:

▸ removeMemberVideoPane(paneId)

packages/@webex/plugin-meetings/src/multistream/remoteMediaManager.ts

Removes a member video pane from the currently selected layout.

Changes to the layout are lost after a layout change.

removeMemberVideoPane(paneId: PaneId): Promise<void>

Parameters

paneId (PaneId) pane id of the pane to remove

Returns

Promise<void>:

▸ pinActiveSpeakerVideoPane(remoteMedia, csi)

packages/@webex/plugin-meetings/src/multistream/remoteMediaManager.ts

Pins an active speaker remote media object to the given CSI value. From that moment onwards the remote media will only play audio/video from that specific CSI until unpinActiveSpeakerVideoPane() is called or current layout is changed.

pinActiveSpeakerVideoPane(remoteMedia: RemoteMedia, csi: CSI): void

Parameters

remoteMedia (RemoteMedia) remote media object reference

csi (CSI) CSI value to pin to, if undefined, then current CSI value is used

Returns

void

▸ unpinActiveSpeakerVideoPane(remoteMedia)

packages/@webex/plugin-meetings/src/multistream/remoteMediaManager.ts

Unpins a remote media object from the fixed CSI value it was pinned to.

unpinActiveSpeakerVideoPane(remoteMedia: RemoteMedia)

Parameters

remoteMedia (RemoteMedia) remote media object reference

▸ isPinned(remoteMedia)

packages/@webex/plugin-meetings/src/multistream/remoteMediaManager.ts

Returns true if a given remote media object belongs to an active speaker group and has been pinned. Throws an error if the remote media object doesn't belong to any active speaker remote media group.

isPinned(remoteMedia: RemoteMedia): boolean

Parameters

remoteMedia (RemoteMedia) remote media object

Returns

boolean:

getRemoteMedia

packages/@webex/plugin-meetings/src/multistream/remoteMediaGroup.ts

Gets the array of remote media elements from the group

getRemoteMedia(filter: string): Array<RemoteMedia>

Parameters

filter

(string
            = 'all')

'all' (default) returns both pinned and unpinned

Returns

Array<RemoteMedia>:

setActiveSpeakerCsis

packages/@webex/plugin-meetings/src/multistream/remoteMediaGroup.ts

Sets CSIs for multiple RemoteMedia instances belonging to this RemoteMediaGroup. For each entry in the remoteMediaCsis array:

if csi is specified, the RemoteMedia instance is pinned to that CSI
if csi is undefined, the RemoteMedia instance is unpinned

setActiveSpeakerCsis(remoteMediaCsis: Array<{remoteMedia: RemoteMedia, csi: number?}>, commit: any): void

Parameters

remoteMediaCsis (Array<{remoteMedia: RemoteMedia, csi: number?}>)

commit

(any
            = true)

Returns

void

pin

packages/@webex/plugin-meetings/src/multistream/remoteMediaGroup.ts

Pins a specific remote media instance to a specfic CSI, so the media will no longer come from active speaker, but from that CSI. If no CSI is given, the current CSI value is used.

pin(remoteMedia: RemoteMedia, csi: CSI?): void

Parameters

remoteMedia (RemoteMedia)

csi (CSI?)

Returns

void

packages/@webex/plugin-meetings/src/multistream/remoteMediaGroup.ts

Invalidates the remote media group by clearing the references to the receive slots used by all remote media from that group and cancelling all media requests. After this call the remote media group is unusable.

stop(commit: boolean)

Parameters

commit

(boolean
            = true)

whether to commit the cancellation of media requests

includes

packages/@webex/plugin-meetings/src/multistream/remoteMediaGroup.ts

Checks if a given RemoteMedia instance belongs to this group.

includes(remoteMedia: RemoteMedia, filter: ("all" | "pinned" | "unpinned")): boolean

Parameters

remoteMedia (RemoteMedia) RemoteMedia instance to check

filter

(("all" | "pinned" | "unpinned")
            = 'all')

Static Members

▸ initialize()

packages/@webex/plugin-meetings/src/breakouts/index.ts

initialize for the breakouts

initialize(): void

Returns

void:

▸ cleanUp()

packages/@webex/plugin-meetings/src/breakouts/index.ts

Calls this to clean up listeners

cleanUp(): void

Returns

void:

▸ locusUrlUpdate(locusUrl)

packages/@webex/plugin-meetings/src/breakouts/index.ts

Update the current locus url of the meeting

locusUrlUpdate(locusUrl: string): void

Parameters

locusUrl (string) // locus url

Returns

void:

▸ updateCanManageBreakouts(canManageBreakouts)

packages/@webex/plugin-meetings/src/breakouts/index.ts

Update whether self is moderator/cohost or not

updateCanManageBreakouts(canManageBreakouts: boolean): void

Parameters

canManageBreakouts (boolean)

Returns

void:

▸ breakoutServiceUrlUpdate(breakoutServiceUrl)

packages/@webex/plugin-meetings/src/breakouts/index.ts

Update the current breakout resource url

breakoutServiceUrlUpdate(breakoutServiceUrl: string): void

Parameters

breakoutServiceUrl (string)

Returns

void:

▸ queryRosters()

packages/@webex/plugin-meetings/src/breakouts/index.ts

The initial roster lists need to be queried because you don't get a breakout.roster event when you join the meeting

queryRosters(): void

Returns

void:

▸ handleRosterUpdate(locus)

packages/@webex/plugin-meetings/src/breakouts/index.ts

handleRosterUpdate(locus: Object): void

Parameters

locus (Object) // locus object

Returns

void:

▸ listenToCurrentSessionTypeChange()

packages/@webex/plugin-meetings/src/breakouts/index.ts

Sets up listener for currentBreakoutSession sessionType changed

listenToCurrentSessionTypeChange(): void

Returns

void:

▸ listenToBroadcastMessages()

packages/@webex/plugin-meetings/src/breakouts/index.ts

Sets up listener for broadcast messages sent to the breakout session

listenToBroadcastMessages(): void

Returns

void:

▸ listenToBreakoutRosters()

packages/@webex/plugin-meetings/src/breakouts/index.ts

Sets up a listener for roster messags from mecury

listenToBreakoutRosters(): void

Returns

void:

▸ listenToBreakoutHelp()

packages/@webex/plugin-meetings/src/breakouts/index.ts

Sets up a listener for ask help notify from mecury

listenToBreakoutHelp(): void

Returns

void:

▸ isBreakoutInProgress()

packages/@webex/plugin-meetings/src/breakouts/index.ts

get current breakout is in progress or not

isBreakoutInProgress(): boolean

Returns

boolean:

▸ isBreakoutIClosing()

packages/@webex/plugin-meetings/src/breakouts/index.ts

get current breakout is in closing or not

isBreakoutIClosing(): boolean

Returns

boolean:

▸ updateBreakout(params)

packages/@webex/plugin-meetings/src/breakouts/index.ts

Updates the information about the current breakout

updateBreakout(params: Object): void

Parameters

params (Object)

Returns

void:

▸ updateBreakoutSessions(payload)

packages/@webex/plugin-meetings/src/breakouts/index.ts

Updates the information about available breakouts

updateBreakoutSessions(payload: Object): void

Parameters

payload (Object)

Returns

void:

▸ clearBreakouts()

packages/@webex/plugin-meetings/src/breakouts/index.ts

clear breakouts collection

clearBreakouts(): void

Returns

void:

▸ getMainSession()

packages/@webex/plugin-meetings/src/breakouts/index.ts

get main session

getMainSession(): Breakout

Returns

Breakout:

▸ askAllToReturn()

packages/@webex/plugin-meetings/src/breakouts/index.ts

Host/CoHost ask all participants return to main session

askAllToReturn(): Promise

Returns

Promise:

▸ broadcast(message, options)

packages/@webex/plugin-meetings/src/breakouts/index.ts

Broadcast message to all breakout session's participants

broadcast(message: String, options: Object): Promise

Parameters

message (String)

options (Object)

Returns

Promise:

▸ enableBreakouts()

packages/@webex/plugin-meetings/src/breakouts/index.ts

Make enable breakout resource

enableBreakouts(): Promise

Returns

Promise:

▸ toggleBreakout(enable)

packages/@webex/plugin-meetings/src/breakouts/index.ts

Make the meeting enable or disable breakout session

toggleBreakout(enable: boolean): Promise

Parameters

enable (boolean)

Returns

Promise:

▸ doToggleBreakout(enable)

packages/@webex/plugin-meetings/src/breakouts/index.ts

do toggle meeting breakout session enable or disable

doToggleBreakout(enable: boolean): Promise

Parameters

enable (boolean)

Returns

Promise:

▸ _setManageGroups(breakoutInfo)

packages/@webex/plugin-meetings/src/breakouts/index.ts

set groups to manageGroups prop

_setManageGroups(breakoutInfo: Object): void

Parameters

breakoutInfo (Object) -- breakout groups

Returns

void:

▸ create(params)

packages/@webex/plugin-meetings/src/breakouts/index.ts

Create new breakout sessions

create(params: object): Promise

Parameters

params (object) -- breakout session group

Returns

Promise:

▸ clearSessions()

packages/@webex/plugin-meetings/src/breakouts/index.ts

Delete all breakout sessions

clearSessions(): Promise

Returns

Promise:

▸ start(params)

packages/@webex/plugin-meetings/src/breakouts/index.ts

Host or cohost starts breakout sessions

start(params: object): Promise

Parameters

params

(object
            = {})

Returns

Promise:

▸ end(params)

packages/@webex/plugin-meetings/src/breakouts/index.ts

Host or cohost ends breakout sessions

end(params: object): Promise

Parameters

params

(object
            = {})

Returns

Promise:

▸ update(params, unlockEdit)

packages/@webex/plugin-meetings/src/breakouts/index.ts

Host or cohost update breakout sessions

update(params: Object, unlockEdit: Boolean): Promise

Parameters

params (Object)

Name	Description
params.id `String`

unlockEdit (Boolean)

Returns

Promise:

▸ getBreakout(editlock)

packages/@webex/plugin-meetings/src/breakouts/index.ts

get existed breakout sessions

getBreakout(editlock: boolean): Promise

Parameters

editlock (boolean) -- lock operations of the breakout sessions

Returns

Promise:

▸ enableAndLockBreakout()

packages/@webex/plugin-meetings/src/breakouts/index.ts

enable and edit lock breakout

enableAndLockBreakout(): void

Returns

void:

▸ hasBreakoutLocked()

packages/@webex/plugin-meetings/src/breakouts/index.ts

breakout edit locked by yourself or not

hasBreakoutLocked(): boolean

Returns

boolean:

▸ lockBreakout()

packages/@webex/plugin-meetings/src/breakouts/index.ts

send breakout edit lock

lockBreakout(): void

Returns

void:

▸ keepEditLockAlive()

packages/@webex/plugin-meetings/src/breakouts/index.ts

keep edit lock alive

keepEditLockAlive(): void

Returns

void:

▸ unLockEditBreakout()

packages/@webex/plugin-meetings/src/breakouts/index.ts

unlock edit breakout

unLockEditBreakout(): void

Returns

void:

▸ assign(sessions)

packages/@webex/plugin-meetings/src/breakouts/index.ts

assign participants to breakout session

assign(sessions: Array): void

Parameters

sessions (Array)

Returns

void:

▸ queryPreAssignments()

packages/@webex/plugin-meetings/src/breakouts/index.ts

query preAssignments

queryPreAssignments(): void

Returns

void:

▸ dynamicAssign(sessions)

packages/@webex/plugin-meetings/src/breakouts/index.ts

assign participants dynamically after breakout sessions started, but currently it only used for admitting participants from lobby into breakout directly

dynamicAssign(sessions: Array): void

Parameters

sessions (Array)

Returns

void:

▸ triggerReturnToMainEvent(breakout)

packages/@webex/plugin-meetings/src/breakouts/index.ts

trigger ASK_RETURN_TO_MAIN event when main session requested

triggerReturnToMainEvent(breakout: Object): void

Parameters

breakout (Object)

Returns

void:

fn

packages/@webex/plugin-meetings/src/breakouts/breakout.ts

If the breakout has no name, assume it is the main session

fn(): boolean

Returns

boolean:

Breakout

packages/@webex/plugin-meetings/src/breakouts/breakout.ts

new Breakout()

Static Members

▸ initialize()

packages/@webex/plugin-meetings/src/breakouts/breakout.ts

initializer for the Breakout class

initialize(): void

Returns

void:

▸ join()

packages/@webex/plugin-meetings/src/breakouts/breakout.ts

Joins the breakout session

join(): Promise

Returns

Promise:

▸ leave()

packages/@webex/plugin-meetings/src/breakouts/breakout.ts

Leaves the breakout session to return to the main session

leave(): Promise

Returns

Promise:

Throws

Error: if an attempt is made to leave the main session or if the main session cannot be found

▸ askForHelp()

packages/@webex/plugin-meetings/src/breakouts/breakout.ts

Sends a help request for the current breakout

askForHelp(): Promise

Returns

Promise:

▸ initMembers()

packages/@webex/plugin-meetings/src/breakouts/breakout.ts

inits the members object

initMembers(): void

Returns

void:

▸ isNeedHandleRoster(locus)

packages/@webex/plugin-meetings/src/breakouts/breakout.ts

check sequence and determine whether to update the new roster or not

isNeedHandleRoster(locus: Object): Boolean

Parameters

locus (Object) Locus object

Returns

Boolean:

▸ parseRoster(locus)

packages/@webex/plugin-meetings/src/breakouts/breakout.ts

Parses the participants from the locus object

parseRoster(locus: Object): void

Parameters

locus (Object) Locus object

Returns

void:

▸ broadcast(message, options)

packages/@webex/plugin-meetings/src/breakouts/breakout.ts

Broadcast message to this breakout session's participants

broadcast(message: String, options: Object): Promise

Parameters

message (String)

options (Object)

Returns

Promise:

BreakoutRequest

packages/@webex/plugin-meetings/src/breakouts/request.ts

new BreakoutRequest()

Instance Members

▸ broadcast($0, url, message, options, groupId, sessionId)

packages/@webex/plugin-meetings/src/breakouts/request.ts

Broadcast message to all breakout session's participants

broadcast($0: {url: string, message: string, options: object?, groupId: string, sessionId: string?}, url: String, message: String, options: Object, groupId: string, sessionId: string): Promise

Parameters

$0 ({url: string, message: string, options: object?, groupId: string, sessionId: string?})

Name	Description
$0.url `any`
$0.message `any`
$0.options `any`
$0.groupId `any`
$0.sessionId `any`

url (String)

message (String)

options (Object)

groupId (string)

sessionId (string)

Returns

Promise:

boServiceErrorHandler

packages/@webex/plugin-meetings/src/breakouts/utils.ts

Deals with all kinds of errors of breakout service

boServiceErrorHandler

Parameters

error (object) // one of the breakout service error

position (string) // position of the error occur

Returns

object:

isSessionTypeChangedFromSessionToMain

packages/@webex/plugin-meetings/src/breakouts/utils.ts

isSessionTypeChangedFromSessionToMain

Parameters

breakout (object)

newSessionType (string)

Returns

boolean:

BreakoutEditLockedError

packages/@webex/plugin-meetings/src/breakouts/edit-lock-error.ts

Extended Error object to signify breakout related errors

new BreakoutEditLockedError(message: String?, error: Object?)

Extends Error

Parameters

message

(String?
            = ERROR_DICTIONARY.BREAKOUT_EDIT.MESSAGE)

error

(Object?
            = null)

fn

packages/@webex/plugin-meetings/src/interpretation/index.ts

Returns should query support languages or not

fn(): boolean

Returns

boolean:

SimultaneousInterpretation

packages/@webex/plugin-meetings/src/interpretation/index.ts

new SimultaneousInterpretation()

Static Members

▸ initialize()

packages/@webex/plugin-meetings/src/interpretation/index.ts

initialize for interpretation

initialize(): void

Returns

void:

▸ cleanUp()

packages/@webex/plugin-meetings/src/interpretation/index.ts

Calls this to clean up listeners

cleanUp(): void

Returns

void:

▸ locusUrlUpdate(locusUrl)

packages/@webex/plugin-meetings/src/interpretation/index.ts

Update the current locus url of the meeting

locusUrlUpdate(locusUrl: string): void

Parameters

locusUrl (string) // locus url

Returns

void:

▸ approvalUrlUpdate(approvalUrl)

packages/@webex/plugin-meetings/src/interpretation/index.ts

Update the approval url for handoff

approvalUrlUpdate(approvalUrl: string): void

Parameters

approvalUrl (string) // approval url

Returns

void:

▸ updateCanManageInterpreters(canManageInterpreters)

packages/@webex/plugin-meetings/src/interpretation/index.ts

Update whether self has capability to manage interpreters (only host can manage it)

updateCanManageInterpreters(canManageInterpreters: boolean): void

Parameters

canManageInterpreters (boolean)

Returns

void:

▸ updateHostSIEnabled(hostSIEnabled)

packages/@webex/plugin-meetings/src/interpretation/index.ts

Update whether the meeting's host si is enabled or not

updateHostSIEnabled(hostSIEnabled: boolean): void

Parameters

hostSIEnabled (boolean)

Returns

void:

▸ updateMeetingSIEnabled(meetingSIEnabled, selfIsInterpreter)

packages/@webex/plugin-meetings/src/interpretation/index.ts

Update whether the meeting support SI feature or not from meeting info

updateMeetingSIEnabled(meetingSIEnabled: boolean, selfIsInterpreter: boolean): void

Parameters

meetingSIEnabled (boolean)

selfIsInterpreter (boolean)

Returns

void:

▸ updateInterpretation(interpretation)

packages/@webex/plugin-meetings/src/interpretation/index.ts

Update the interpretation languages channels which user can choose to subscribe

updateInterpretation(interpretation: Object): void

Parameters

interpretation (Object)

Returns

void:

▸ updateSelfInterpretation($0, interpretation, selfParticipantId)

packages/@webex/plugin-meetings/src/interpretation/index.ts

Update self's interpretation information (self is interpreter)

updateSelfInterpretation($0: Object, interpretation: Object, selfParticipantId: String): bool

Parameters

$0 (Object)

Name	Description
$0.interpretation `any`
$0.selfParticipantId `any`

interpretation (Object)

selfParticipantId (String)

Returns

bool: is target language changed

▸ getTargetLanguageCode()

packages/@webex/plugin-meetings/src/interpretation/index.ts

Get the language code of the interpreter target language

getTargetLanguageCode(): number

Returns

number:

▸ querySupportLanguages()

packages/@webex/plugin-meetings/src/interpretation/index.ts

query interpretation languages

querySupportLanguages(): Promise

Returns

Promise:

▸ getInterpreters()

packages/@webex/plugin-meetings/src/interpretation/index.ts

get interpreters of the meeting

getInterpreters(): Promise

Returns

Promise:

▸ updateInterpreters(interpreters)

packages/@webex/plugin-meetings/src/interpretation/index.ts

update interpreters of the meeting

updateInterpreters(interpreters: Array): Promise

Parameters

interpreters (Array)

Returns

Promise:

▸ changeDirection()

packages/@webex/plugin-meetings/src/interpretation/index.ts

Change direction of interpretation for an interpreter participant

changeDirection(): Promise

Returns

Promise:

▸ listenToHandoffRequests()

packages/@webex/plugin-meetings/src/interpretation/index.ts

Sets up a listener for handoff requests from mercury

listenToHandoffRequests(): void

Returns

void:

▸ handoffInterpreter(participantId)

packages/@webex/plugin-meetings/src/interpretation/index.ts

handoff the active interpreter role to another interpreter in same group, only the interpreter is allowed to call this api

handoffInterpreter(participantId: string): Promise

Parameters

participantId (string) the participant id you want to hand off

Returns

Promise:

▸ requestHandoff()

packages/@webex/plugin-meetings/src/interpretation/index.ts

the in-active interpreter request to hand off the active role to self

requestHandoff(): Promise

Returns

Promise:

▸ acceptRequest(url)

packages/@webex/plugin-meetings/src/interpretation/index.ts

accept the request of handoff

acceptRequest(url: String): Promise

Parameters

url (String) the url get from last approval event

Returns

Promise:

▸ declineRequest(url)

packages/@webex/plugin-meetings/src/interpretation/index.ts

decline the request of handoff

declineRequest(url: String): Promise

Parameters

url (String) the url get from last approval event

Returns

Promise:

AnnotationChannel

packages/@webex/plugin-meetings/src/annotation/index.ts

Annotation to handle LLM and Mercury message and locus API

new AnnotationChannel(args: ...any)

Extends WebexPlugin

Parameters

args (...any)

Instance Members

▸ locusUrlUpdate(locusUrl)

packages/@webex/plugin-meetings/src/annotation/index.ts

set locusUrl

locusUrlUpdate(locusUrl: string): void

Parameters

locusUrl (string)

Returns

void:

▸ approvalUrlUpdate(approvalUrl)

packages/@webex/plugin-meetings/src/annotation/index.ts

set approved url

approvalUrlUpdate(approvalUrl: string): void

Parameters

approvalUrl (string)

Returns

void:

▸ acceptRequest(approval)

packages/@webex/plugin-meetings/src/annotation/index.ts

accept request

acceptRequest(approval: object): Promise

Parameters

approval (object)

Returns

Promise:

▸ declineRequest(approval)

packages/@webex/plugin-meetings/src/annotation/index.ts

presenter declined request annotation

declineRequest(approval: approval): Promise

Parameters

approval (approval)

Returns

Promise:

▸ approveAnnotation(requestData)

packages/@webex/plugin-meetings/src/annotation/index.ts

request approved annotation

approveAnnotation(requestData: RequestData): Promise

Parameters

requestData (RequestData)

Returns

Promise:

▸ cancelApproveAnnotation(requestData, approval)

packages/@webex/plugin-meetings/src/annotation/index.ts

cancel approved annotation

cancelApproveAnnotation(requestData: object, approval: object): Promise

Parameters

requestData (object)

approval (object)

Returns

Promise:

▸ closeAnnotation(requestData)

packages/@webex/plugin-meetings/src/annotation/index.ts

close annotation

closeAnnotation(requestData: object): Promise

Parameters

requestData (object)

Returns

Promise:

▸ sendStrokeData

packages/@webex/plugin-meetings/src/annotation/index.ts

Sends stroke data to presenter

sendStrokeData

Parameters

strokeData (StrokeData)

Returns

void:

Webinar

packages/@webex/plugin-meetings/src/webinar/index.ts

new Webinar()

Static Members

▸ locusUrlUpdate(locusUrl)

packages/@webex/plugin-meetings/src/webinar/index.ts

Update the current locus url of the webinar

locusUrlUpdate(locusUrl: string): void

Parameters

locusUrl (string) // locus url

Returns

void:

▸ webcastUrlUpdate(webcastUrl)

packages/@webex/plugin-meetings/src/webinar/index.ts

Update the current webcast url of the meeting

webcastUrlUpdate(webcastUrl: string): void

Parameters

webcastUrl (string) // webcast url

Returns

void:

▸ webinarAttendeesSearchingUrlUpdate(webinarAttendeesSearchingUrl)

packages/@webex/plugin-meetings/src/webinar/index.ts

Update the current webinarAttendeesSearching url of the meeting

webinarAttendeesSearchingUrlUpdate(webinarAttendeesSearchingUrl: string): void

Parameters

webinarAttendeesSearchingUrl (string) // webinarAttendeesSearching url

Returns

void:

▸ updateCanManageWebcast(canManageWebcast)

packages/@webex/plugin-meetings/src/webinar/index.ts

Update whether self has capability to manage start/stop webcast (only host can manage it)

updateCanManageWebcast(canManageWebcast: boolean): void

Parameters

canManageWebcast (boolean)

Returns

void:

get

packages/@webex/plugin-meetings/src/webinar/collection.ts

get(id: String): Member

Parameters

id (String)

Returns

Member:

IInMeetingActions

packages/@webex/plugin-meetings/src/meeting/in-meeting-actions.ts

IInMeetingActions Type for In-Meeting Actions

IInMeetingActions

InMeetingActions

packages/@webex/plugin-meetings/src/meeting/in-meeting-actions.ts

new InMeetingActions()

Instance Members

▸ get

packages/@webex/plugin-meetings/src/meeting/in-meeting-actions.ts

Returns all meeting action options

get

Returns

packages/@webex/plugin-meetings/src/recording-controller/index.ts

setServiceUrl(url: string): void

packages/@webex/plugin-meetings/src/controls-options-manager/index.ts

new ControlsOptionsManager(request: MeetingRequest, options: {locusUrl: string, displayHints: Array<string>?}?)

Parameters

request (MeetingRequest)

options ({locusUrl: string, displayHints: Array<string>?}?)

Static Members

▸ set(options)

packages/@webex/plugin-meetings/src/controls-options-manager/index.ts

set(options: Object): void

Parameters

options (Object)

Returns

void:

▸ setLocusUrl(url)

packages/@webex/plugin-meetings/src/controls-options-manager/index.ts

setLocusUrl(url: string): void

Parameters

url (string)

Returns

void:

▸ setDisplayHints(hints)

packages/@webex/plugin-meetings/src/controls-options-manager/index.ts

setDisplayHints(hints: Array): void

Parameters

hints (Array)

Returns

void:

▸ getLocusUrl()

packages/@webex/plugin-meetings/src/controls-options-manager/index.ts

getLocusUrl(): string

Returns

string:

▸ getDisplayHints()

packages/@webex/plugin-meetings/src/controls-options-manager/index.ts

getDisplayHints(): Array

Returns

Array:

▸ setMuteOnEntry(enabled)

packages/@webex/plugin-meetings/src/controls-options-manager/index.ts

setMuteOnEntry(enabled: boolean): Promise

Parameters

enabled (boolean)

Returns

Promise:

▸ setDisallowUnmute(enabled)

packages/@webex/plugin-meetings/src/controls-options-manager/index.ts

setDisallowUnmute(enabled: boolean): Promise

Parameters

enabled (boolean)

Returns

Promise:

▸ setMuteAll(mutedEnabled, disallowUnmuteEnabled, muteOnEntryEnabled)

packages/@webex/plugin-meetings/src/controls-options-manager/index.ts

setMuteAll(mutedEnabled: boolean, disallowUnmuteEnabled: boolean, muteOnEntryEnabled: boolean): Promise

Parameters

mutedEnabled (boolean)

disallowUnmuteEnabled (boolean)

muteOnEntryEnabled (boolean)

Returns

Promise:

Instance Members

▸ update(controls)

packages/@webex/plugin-meetings/src/controls-options-manager/index.ts

Set controls for this meeting.

update(controls: Array<ControlConfig>): Promise<Array<any>>

Parameters

controls (Array<ControlConfig>) Spread Array of ControlConfigs

Returns

Promise<Array<any>>: Promise resolving if the request was successful.

InternalRequestInfo

packages/@webex/plugin-meetings/src/meeting/locusMediaRequest.ts

Class representing a single /media request being sent to Locus

new InternalRequestInfo(request: Request, pendingPromise: Defer, sendRequestFn: function (request: Request): Promise<RequestResult>)

Parameters

request (Request)

pendingPromise (Defer)

sendRequestFn (function (request: Request): Promise<RequestResult>)

Instance Members

▸ getPendingPromises()

packages/@webex/plugin-meetings/src/meeting/locusMediaRequest.ts

Returns the list of pending promises associated with this request

getPendingPromises()

▸ addPendingPromises(pendingPromises)

packages/@webex/plugin-meetings/src/meeting/locusMediaRequest.ts

Adds promises to the list of pending promises associated with this request

addPendingPromises(pendingPromises: Array<Defer>)

Parameters

pendingPromises (Array<Defer>)

▸ execute()

packages/@webex/plugin-meetings/src/meeting/locusMediaRequest.ts

Executes the request. Returned promise is resolved once the request is completed (no matter if it succeeded or failed).

execute(): Promise<void>

Returns

Promise<void>

isRequestAffectingConfluenceState

packages/@webex/plugin-meetings/src/meeting/locusMediaRequest.ts

Returns true if the request is triggering confluence creation in the server

isRequestAffectingConfluenceState(request: Request): boolean

Parameters

request (Request)

Returns

boolean

LocusMediaRequest

packages/@webex/plugin-meetings/src/meeting/locusMediaRequest.ts

This class manages all /media API requests to Locus. Every call to that Locus API has to go through this class.

new LocusMediaRequest(config: Config, options: any)

Extends WebexPlugin

Parameters

config (Config)

options (any)

Instance Members

▸ send(request)

packages/@webex/plugin-meetings/src/meeting/locusMediaRequest.ts

Sends a media request to Locus

send(request: Request): Promise<RequestResult>

Parameters

request (Request)

Returns

Promise<RequestResult>

▸ isConfluenceCreated()

packages/@webex/plugin-meetings/src/meeting/locusMediaRequest.ts

Returns true if a confluence on the server is already created

isConfluenceCreated()

state

packages/@webex/plugin-meetings/src/meeting/connectionStateHandler.ts

Current overall connection state

state

Type: ConnectionState

ConnectionStateHandler

packages/@webex/plugin-meetings/src/meeting/connectionStateHandler.ts

new ConnectionStateHandler()

ParameterError

packages/@webex/plugin-meetings/src/common/errors/parameter.ts

Extended Error object for general parameter errors

new ParameterError(message: String?, error: Object?)

Extends Error

Parameters

message

(String?
            = MEETINGCONSTANTS.ERROR_DICTIONARY.PARAMETER.MESSAGE)

error

(Object?
            = null)

message (string?) Error message

fileName (string?) Name of the script file where error was generated

lineNumber (number?) Line number of the script file where error was generated

Properties

code (number) : Error code

Instance Members

▸ toString()

packages/@webex/plugin-meetings/src/common/errors/webex-meetings-error.ts

Returns human readable string describing the error.

toString(): string

Returns

string:

JoinMeetingError

packages/@webex/plugin-meetings/src/common/errors/join-meeting.ts

Extended Error object to signify a join meeting error

new JoinMeetingError(options: Object?, message: String?, error: Object?)

Extends Error

Parameters

options

(Object?
            = {})

message

(String?
            = ERROR_DICTIONARY.JOIN_MEETING.MESSAGE)

error

(Object?
            = null)

LAYOUT_TYPES

packages/@webex/plugin-meetings/src/constants.ts

@description Layout type for remote video participants. Allowed values are: Single, Equal, ActivePresence, Prominent, OnePlusN

LAYOUT_TYPES

Type: array

IP_VERSION

packages/@webex/plugin-meetings/src/constants.ts

the values for IP_VERSION are fixed and defined in Orpheus API

IP_VERSION

StrokeData

packages/@webex/plugin-meetings/src/annotation/annotation.types.ts

Type for an StrokeData Object

StrokeData

Type: {deviceId: string, toUserId: string, requesterId: string, content: string, shareInstanceId: string, encryptionKeyUrl: string, version: string}

Properties

deviceId (string)

toUserId (string)

requesterId (string)

content (string)

shareInstanceId (string)

encryptionKeyUrl (string)

version (string)

AnnotationInfo

packages/@webex/plugin-meetings/src/annotation/annotation.types.ts

Type for an annotation Object include annotation version and privilege

AnnotationInfo

Type: {version: string, policy: ANNOTATION_POLICY}

Properties

version (string)

policy (ANNOTATION_POLICY)

MeetingInfoV2PasswordError

packages/@webex/plugin-meetings/src/meeting-info/meeting-info-v2.ts

Error to indicate that wbxappapi requires a password

new MeetingInfoV2PasswordError(wbxAppApiErrorCode: Number?, meetingInfo: Object?, message: String?)

Extends Error

Parameters

wbxAppApiErrorCode (Number?)

meetingInfo (Object?)

message

(String?
            = PASSWORD_ERROR_DEFAULT_MESSAGE)

MeetingInfoV2AdhocMeetingError

packages/@webex/plugin-meetings/src/meeting-info/meeting-info-v2.ts

Error generating a adhoc space meeting

new MeetingInfoV2AdhocMeetingError(wbxAppApiErrorCode: Number?, message: String?)

Extends Error

Parameters

wbxAppApiErrorCode (Number?)

message

(String?
            = ADHOC_MEETING_DEFAULT_ERROR)

MeetingInfoV2PolicyError

packages/@webex/plugin-meetings/src/meeting-info/meeting-info-v2.ts

Error preventing join because of a meeting policy

new MeetingInfoV2PolicyError(wbxAppApiErrorCode: Number?, meetingInfo: Object?, message: String?)

Extends Error

Parameters

wbxAppApiErrorCode (Number?)

meetingInfo (Object?)

message (String?)

MeetingInfoV2CaptchaError

packages/@webex/plugin-meetings/src/meeting-info/meeting-info-v2.ts

Error to indicate that preferred webex site not present to start adhoc meeting

new MeetingInfoV2CaptchaError(wbxAppApiErrorCode: Number?, captchaInfo: Object?, message: String?)

Extends Error

Parameters

wbxAppApiErrorCode (Number?)

captchaInfo (Object?)

message

(String?
            = CAPTCHA_ERROR_DEFAULT_MESSAGE)

MeetingInfoV2WebinarRegistrationError

packages/@webex/plugin-meetings/src/meeting-info/meeting-info-v2.ts

Error preventing join because of a webinar registration error

new MeetingInfoV2WebinarRegistrationError(wbxAppApiErrorCode: Number?, meetingInfo: Object?, message: String?)

Extends Error

Parameters

wbxAppApiErrorCode (Number?)

meetingInfo (Object?)

message (String?)

handlePolicyError

packages/@webex/plugin-meetings/src/meeting-info/meeting-info-v2.ts

Raises a MeetingInfoV2PolicyError for policy error codes

handlePolicyError

Parameters

err (any) the error from the request

Returns

void:

handleWebinarRegistrationError

packages/@webex/plugin-meetings/src/meeting-info/meeting-info-v2.ts

Raises a handleWebinarRegistrationError for webinar registration error codes

handleWebinarRegistrationError

Parameters

err (any) the error from the request

Returns

void:

Metrics

packages/@webex/plugin-meetings/src/metrics/index.ts

Metrics handles all the call metrics events

new Metrics()

Instance Members

▸ initialSetup(webex)

packages/@webex/plugin-meetings/src/metrics/index.ts

Initializes the Metrics singleton with a meeting Collection.

initialSetup(webex: Object): void

Parameters

webex (Object) webex SDK object

Returns

void:

▸ sendBehavioralMetric(metricName, metricFields, metricTags)

packages/@webex/plugin-meetings/src/metrics/index.ts

Uploads given metric to the Metrics service as an Behavioral metric. Metadata about the environment such as browser, OS, SDK and their versions are automatically added when the metric is sent.

The Metrics service will send an Behavioral metric to InfluxDB for aggregation. See https://confluence-eng-gpk2.cisco.com/conf/display/WBXT/Getting+started+with+Metrics+Service.

sendBehavioralMetric(metricName: string, metricFields: Object, metricTags: Object): void

Parameters

metricName (string) Name of the metric (measurement) to send

metricFields

(Object
            = {})

Key-valye pairs of data or values about this metric

metricTags

(Object
            = {})

Key-value pairs of metric metadata

Returns

void:

▸ prepareMetricFields(payload, prefix)

packages/@webex/plugin-meetings/src/metrics/index.ts

Flattens an object into one that has no nested properties. Each level of nesting is represented by "_" in the flattened object property names. This function is needed, because Amplitude doesn't allow passing nested objects as metricFields. Use this function for metricFields before calling sendBehavioralMetric() if you want to send nested objects in your metrics.

If the function is called with a literal, it returns an object with a single property "value" and the literal value in it.

prepareMetricFields(payload: any, prefix: string): Object

Parameters

payload

(any
            = {})

object you want to flatten

prefix

(string
            = '')

string prefix prepended to any property names in flatten object

Returns

Object:

getMaxFs

packages/@webex/plugin-meetings/src/multistream/remoteMedia.ts

Converts pane size into h264 maxFs

getMaxFs(paneSize: PaneSize): number

Parameters

paneSize (PaneSize)

Returns

number:

RemoteMedia

packages/@webex/plugin-meetings/src/multistream/remoteMedia.ts

Class representing a remote audio/video stream.

Internally it is associated with a specific receive slot and a media request for it.

new RemoteMedia(receiveSlot: ReceiveSlot, mediaRequestManager: MediaRequestManager, options: Options?)

Extends EventsScope

Parameters

receiveSlot (ReceiveSlot)

mediaRequestManager (MediaRequestManager)

options (Options?)

Instance Members

▸ setSizeHint(width, height)

packages/@webex/plugin-meetings/src/multistream/remoteMedia.ts

Supply the width and height of the video element to restrict the requested resolution to this size

setSizeHint(width: any, height: any)

Parameters

width (any) width of the video element

height (any) height of the video element

▸ stop(commit)

packages/@webex/plugin-meetings/src/multistream/remoteMedia.ts

Invalidates the remote media by clearing the reference to a receive slot and cancelling the media request. After this call the remote media is unusable.

stop(commit: boolean)

Parameters

commit

(boolean
            = true)

whether to commit the cancellation of the media request

▸ sendMediaRequest(csi, commit)

packages/@webex/plugin-meetings/src/multistream/remoteMedia.ts

Sends a new media request. This method can only be used for receiver-selected policy, because only in that policy we have a 1-1 relationship between RemoteMedia and MediaRequest and the request id is then stored in this RemoteMedia instance. For active-speaker policy, the same request is shared among many RemoteMedia instances, so it's managed through RemoteMediaGroup

sendMediaRequest(csi: CSI, commit: boolean)

Parameters

csi (CSI)

commit (boolean)

▸ cancelMediaRequest(commit)

packages/@webex/plugin-meetings/src/multistream/remoteMedia.ts

cancelMediaRequest(commit: boolean)

Parameters

commit (boolean)

▸ mediaType

packages/@webex/plugin-meetings/src/multistream/remoteMedia.ts

Getter for mediaType

mediaType

Type: MediaType

Returns

MediaType

▸ memberId

packages/@webex/plugin-meetings/src/multistream/remoteMedia.ts

Getter for memberId

memberId

▸ csi

packages/@webex/plugin-meetings/src/multistream/remoteMedia.ts

Getter for csi

csi

▸ sourceState

packages/@webex/plugin-meetings/src/multistream/remoteMedia.ts

Getter for source state

sourceState

Type: StreamState

Returns

StreamState

▸ stream

packages/@webex/plugin-meetings/src/multistream/remoteMedia.ts

Getter for remote media stream

stream

▸ getUnderlyingReceiveSlot()

packages/@webex/plugin-meetings/src/multistream/remoteMedia.ts

getUnderlyingReceiveSlot(): ReceiveSlot

Returns

ReceiveSlot:

EventsScope

packages/@webex/plugin-meetings/src/common/events/events-scope.ts

Events plugin-meetings local Used to emit events internally between modules specific to an object

new EventsScope()

Extends ChildEmitter

Instance Members

▸ emit(scope, eventName, args)

packages/@webex/plugin-meetings/src/common/events/events-scope.ts

Emits and logs an event

emit(scope: any, eventName: any, args: any): Function

Parameters

scope (any)

eventName (any)

args (any)

Returns

Function:

isEqual

packages/@webex/plugin-meetings/src/multistream/mediaRequestManager.ts

Returns true if two stream requests are the same, false otherwise.

isEqual(streamRequestA: StreamRequest, streamRequestB: StreamRequest): boolean

Parameters

streamRequestA (StreamRequest) Stream request A for comparison.

streamRequestB (StreamRequest) Stream request B for comparison.

Returns

boolean: Whether they are equal.

clearPreviousRequests

packages/@webex/plugin-meetings/src/multistream/mediaRequestManager.ts

Clears the previous stream requests.

clearPreviousRequests(): void

Returns

void:

ReceiveSlot

packages/@webex/plugin-meetings/src/multistream/receiveSlot.ts

Class representing a receive slot. A single receive slot is able to receive a single track for example some participant's main video or audio

new ReceiveSlot(mediaType: MediaType, mcReceiveSlot: ReceiveSlot, findMemberIdCallback: FindMemberIdCallback)

Extends EventsScope

Parameters

mediaType (MediaType)

mcReceiveSlot (ReceiveSlot)

findMemberIdCallback (FindMemberIdCallback) callback for finding memberId for given CSI

Instance Members

▸ memberId

packages/@webex/plugin-meetings/src/multistream/receiveSlot.ts

Getter for memberId

memberId

▸ csi

packages/@webex/plugin-meetings/src/multistream/receiveSlot.ts

Getter for csi

csi

▸ setMaxFs(newFs)

packages/@webex/plugin-meetings/src/multistream/receiveSlot.ts

Set the max frame size for this slot

setMaxFs(newFs: any)

Parameters

newFs (any) frame size

▸ sourceState

packages/@webex/plugin-meetings/src/multistream/receiveSlot.ts

Getter for sourceState

sourceState

▸ findMemberId()

packages/@webex/plugin-meetings/src/multistream/receiveSlot.ts

Tries to find the member id for this receive slot if it hasn't got one

findMemberId()

▸ logString

packages/@webex/plugin-meetings/src/multistream/receiveSlot.ts

logString

Returns

string: a log message used to identify the receive slot

▸ stream

packages/@webex/plugin-meetings/src/multistream/receiveSlot.ts

The MediaStream object associated with this slot.

stream

Type: MediaStream

Returns

MediaStream: The MediaStreamTrack.

▸ wcmeReceiveSlot

packages/@webex/plugin-meetings/src/multistream/receiveSlot.ts

The underlying WCME receive slot

wcmeReceiveSlot

Type: WcmeReceiveSlot

Returns

WcmeReceiveSlot

Presence

new Presence()

Type: IPresence

Extends WebexPlugin

Static Members

▸ initialize()

Initialize the presence plugin

initialize(): undefined

Returns

undefined:

▸ initializeWorker()

Initializes the presence worker.

initializeWorker(): undefined

Returns

undefined:

▸ emitEvent(event, payload)

Trigger an event.

emitEvent(event: string, payload: string): undefined

Parameters

event (string)

payload (string)

Returns

undefined:

▸ enable()

Enables presence feature

enable(): Promise<boolean>

Returns

Promise<boolean>: resolves with true, if successful

▸ disable()

Disables presence feature

disable(): Promise<boolean>

Returns

Promise<boolean>: resolves with false, if successful

▸ isEnabled()

Returns true if presence is enabled, false otherwise

isEnabled(): Promise<boolean>

Returns

Promise<boolean>: resolves with true if presence is enabled

▸ get(personId)

Gets the current presence status of a given person id

get(personId: string): Promise<PresenceStatusObject>

Parameters

personId (string)

Returns

Promise<PresenceStatusObject>: resolves with status object of person

▸ list(personIds)

Gets the current presence statuses of an array of people ids

list(personIds: Array): Promise<PresenceStatusesObject>

Parameters

personIds (Array)

Returns

Promise<PresenceStatusesObject>: resolves with an object with key of statusList array

▸ subscribe(personIds, subscriptionTtl)

Subscribes to a person's presence status updates Updates are sent via mercury events apheleia.subscription_update

subscribe(personIds: (string | Array), subscriptionTtl: number): Promise

Parameters

personIds ((string | Array))

subscriptionTtl

(number
            = defaultSubscriptionTtl)

Requested length of subscriptions in seconds.

Returns

Promise:

▸ unsubscribe(personIds)

Unsubscribes from a person or group of people's presence subscription

unsubscribe(personIds: (string | Array)): Promise

Parameters

personIds ((string | Array))

Returns

Promise:

▸ setStatus(status, ttl)

Sets the status of the current user

setStatus(status: string, ttl: number): Promise

Parameters

status (string) active | inactive | ooo | dnd

ttl (number) Time To Live for the event in seconds.

Returns

Promise:

▸ enqueue(id)

Retrieves and subscribes to a user's presence.

enqueue(id: string): undefined

Parameters

id (string)

Returns

undefined:

▸ dequeue(id)

Retract from subscribing to a user's presence.

dequeue(id: string): undefined

Parameters

id (string)

Returns

undefined:

PresenceStatusObject

The status object

PresenceStatusObject

Type: Object

Properties

url (string) : : Public resource identifier for presence

subject (string) : : User ID for the user the returned composed presence represents

status (string) : : Current composed presence state

statusTime (string) : : DateTime in RFC3339 format that the current status began

lastActive (string) : : DateTime in RFC3339 format that the service last saw activity from the user.

expires (string) : : DEPRECATED - DateTime in RFC3339 format that represents when the current status will expire. Will not exist if expiresTTL is -1.

expiresTTL (Number) : : TTL in seconds until the status will expire. If TTL is -1 the current status has no known expiration.

expiresTime (string) : : DateTime in RFC3339 format that the current status will expire. Missing field means no known expiration.

vectorCounters (Object) : : Used for packet ordering and tracking.

suppressNotifications (Boolean) : : Indicates if notification suppression is recommended for this status.

lastSeenDeviceUrl (string) : : Resource Identifier of the last device to post presence activity for this user.

PresenceStatusesObject