PCast™ API

1const pcast = new sdk.lowLevel.PCast(options);

1pcast.start(
2  authToken,
3  function authenticationCallback(pcast, status, sessionId) {
4    // Upon success, called with status="ok" and a valid "sessionId"
5    // At any time when authentication is required with status="unauthorized"
6  },
7  function onlineCallback(pcast) {
8    // Called when connected to the streaming platform
9  },
10  function offlineCallback(pcast) {
11    // Called when disconnected from the streaming platform
12  }
13);

1pcast.stop();

1var options = {
2  audio: true,
3  video: true,
4};
5
6pcast.getUserMedia(
7  options,
8  function userMediaCallback(pcast, status, userMediaStream, error) {
9    // status="ok" with a userMediaStream matching the provided options
10    // status="failed" otherwise with error
11  }
12);

1var tags = ['my-tag'];
2
3pcast.publish(
4  streamToken,
5  userMediaStream,
6  function publishCallback(pcast, status, publisher) {
7    // status="ok" with "publisher" object to control the stream
8    // The "streamId" of the publisher
9    var streamId = publisher.getStreamId();
10
11    if (publisher.hasEnded()) {
12      // Checks if the publisher has ended
13    }
14
15    publisher.setPublisherEndedCallback(function publisherEndedCallback(
16      publisher,
17      reason,
18      reasonDescription
19    ) {
20      // Called when the stream has ended
21    });
22
23    // To stop later
24    publisher.stop('I-am-done-publishing');
25  },
26  tags
27);

1currentPublisher.monitor(
2  { conditionCountForNotificationThreshold: 8 },
3  function (publisher, reason, description) {
4    if (currentPublisher === publisher) {
5      switch (reason) {
6        case 'client-side-failure':
7          // handle failure event, redo stream
8          break;
9        default:
10          // no failure has occurred, handle monitor event
11          break;
12      }
13    }
14  }
15);

1pcast.subscribe(
2  streamToken,
3  function subscribeCallback(pcast, status, mediaStream) {
4    // status="ok" with "mediaStream" object to control the stream
5
6    mediaStream.setStreamEndedCallback(function streamEndedCallback(
7      mediaStream,
8      reason,
9      reasonDescription
10    ) {
11      // Called when the stream has ended
12    });
13
14    // To stop later
15    mediaStream.stop('I-am-done-watching');
16  },
17  subscriberOptions
18);

1currentMediaStream.monitor({}, function (mediaStream, reason, description) {
2  if (currentMediaStream === mediaStream) {
3    switch (reason) {
4      case 'client-side-failure':
5        // handle failure event, redo stream
6        break;
7      default:
8        // no failure has occurred, handle monitor event
9        break;
10    }
11  }
12});

1var childMediaStream = mediaStream.select(function (track, index) {
2  return track.kind === 'video';
3});

1// Media stream acquired with pcast.subscribe(...)
2var renderer = mediaStream.createRenderer();
3var elementToAttachTo = document.getElementById('<ELEMENT_ID>');
4
5renderer.start(elementToAttachTo);
6
7// To stop later
8renderer.stop();

1var renderer = ...
2renderer.start(...);
3
4// subscribe to dimension changed event
5renderer.setVideoDisplayDimensionsChangedCallback(function (renderer, displayDimensions) {
6    // Can get called multiple times while rendering a stream
7    // Values in displayDimensions.width, displayDimensions.height
8}, options);

1var renderer = ...
2renderer.start(...);
3
4var stats = renderer.getStats();
5
6console.log(stats.lag);