PCast™ API

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

pcast.start(
  authToken,
  function authenticationCallback(pcast, status, sessionId) {
    // Upon success, called with status="ok" and a valid "sessionId"
    // At any time when authentication is required with status="unauthorized"
  },
  function onlineCallback(pcast) {
    // Called when connected to the streaming platform
  },
  function offlineCallback(pcast) {
    // Called when disconnected from the streaming platform
  }
);

pcast.stop();

var options = {
  audio: true,
  video: true,
};
 
pcast.getUserMedia(
  options,
  function userMediaCallback(pcast, status, userMediaStream, error) {
    // status="ok" with a userMediaStream matching the provided options
    // status="failed" otherwise with error
  }
);

var tags = ['my-tag'];
 
pcast.publish(
  streamToken,
  userMediaStream,
  function publishCallback(pcast, status, publisher) {
    // status="ok" with "publisher" object to control the stream
    // The "streamId" of the publisher
    var streamId = publisher.getStreamId();
 
    if (publisher.hasEnded()) {
      // Checks if the publisher has ended
    }
 
    publisher.setPublisherEndedCallback(
      function publisherEndedCallback(publisher, reason, reasonDescription) {
        // Called when the stream has ended
      }
    );
 
    // To stop later
    publisher.stop('I-am-done-publishing');
  },
  tags
);

currentPublisher.monitor(
  { conditionCountForNotificationThreshold: 8 },
  function (publisher, reason, description) {
    if (currentPublisher === publisher) {
      switch (reason) {
        case 'client-side-failure':
          // handle failure event, redo stream
          break;
        default:
          // no failure has occurred, handle monitor event
          break;
      }
    }
  }
);

pcast.subscribe(
  streamToken,
  function subscribeCallback(pcast, status, mediaStream) {
    // status="ok" with "mediaStream" object to control the stream
 
    mediaStream.setStreamEndedCallback(
      function streamEndedCallback(mediaStream, reason, reasonDescription) {
        // Called when the stream has ended
      }
    );
 
    // To stop later
    mediaStream.stop('I-am-done-watching');
  },
  subscriberOptions
);

currentMediaStream.monitor({}, function (mediaStream, reason, description) {
  if (currentMediaStream === mediaStream) {
    switch (reason) {
      case 'client-side-failure':
        // handle failure event, redo stream
        break;
      default:
        // no failure has occurred, handle monitor event
        break;
    }
  }
});

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

// Media stream acquired with pcast.subscribe(...)
var renderer = mediaStream.createRenderer();
var elementToAttachTo = document.getElementById('<ELEMENT_ID>');
 
renderer.start(elementToAttachTo);
 
// To stop later
renderer.stop();

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

var renderer = ...
renderer.start(...);
 
var stats = renderer.getStats();
 
console.log(stats.lag);