PCast™ API

1import com.phenixrts.pcast.PCast;
2import com.phenixrts.pcast.PCastInitializeOptions;
3import com.phenixrts.pcast.android.AndroidPCastFactory;
4
5PCast pcast = AndroidPCastFactory.createPCast(this);
6
7// #1 Default initialization options
8pcast.initialize();
9
10// OR
11
12// #2 Custom initialization options (initialized by constructor)
13final boolean enableProcessTerminationSignalHandling = false;
14PCastInitializeOptions initOptions = new PCastInitializeOptions(
15    enableProcessTerminationSignalHandling);
16
17pcast.initialize(initOptions);

1import com.phenixrts.pcast.PCastInitializeOptions;
2import com.phenixrts.pcast.StreamingSourceMapping;
3
4final String patternToReplace = "https:\\/\\/phenixrts\\.com\\/video";
5final String replacement = "https://myown.cdn.com";
6final StreamingSourceMapping streamingSourceMapping = new StreamingSourceMapping(
7    patternToReplace, replacement);
8
9final boolean enableProcessTerminationSignalHandling = false;
10final boolean configureLogging = true;
11
12final PCastInitializeOptions pcastInitOptions = new PCastInitializeOptions(
13    enableProcessTerminationSignalHandling,
14    configureLogging,
15    streamingSourceMapping);

1import android.util.Log;
2import com.phenixrts.pcast.PCast;
3import com.phenixrts.pcast.RequestStatus;
4
5// Created via EdgeAuth library
6String authenticationToken = ...;
7// Previously initialized
8PCast pcast = ...;
9
10pcast.start(
11    authenticationToken,
12    new PCast.AuthenticationCallback() {
13        @Override
14        public void onEvent(
15            PCast pcast,
16            RequestStatus requestStatus,
17            String sessionId) {
18                if (requestStatus == RequestStatus.OK) {
19                    Log.i("Phenix SDK Example", "PCast started...");
20                } else {
21                    Log.e("Phenix SDK Example", "Failed to start PCast...");
22                }
23        }
24    },
25    new PCast.OnlineCallback() {
26        @Override
27        public void onEvent(PCast pcast) {
28            Log.i("Phenix SDK Example", "We are online...");
29        }
30    },
31    new PCast.OfflineCallback() {
32        @Override
33        public void onEvent(PCast pcast) {
34            Log.i("Phenix SDK Example", "We are offline...");
35        }
36    });

1import com.phenixrts.pcast.PCast;
2import com.phenixrts.pcast.RequestStatus;
3
4// Previously initialized and started
5PCast pcast = ...;
6
7pcast.stop();
8
9// Once you are done using PCast (e.g. exiting the app)
10pcast.shutdown();

1import com.phenixrts.pcast.FacingMode;
2import com.phenixrts.pcast.PCast;
3import com.phenixrts.pcast.UserMediaOptions;
4import com.phenixrts.pcast.UserMediaStream;
5import com.phenixrts.pcast.android.AndroidPCastFactory;
6
7// Previously initialized and started
8PCast pcast = ...;
9
10UserMediaOptions gumOptions = new UserMediaOptions();
11
12// Customize options if desired
13gumOptions.getVideoOptions().capabilityConstraints.put(
14    DeviceCapability.FACING_MODE, Arrays.asList(new DeviceConstraint(FacingMode.USER)));
15gumOptions.getAudioOptions().enabled = false;
16
17pcast.getUserMedia(
18    gumOptions,
19    new PCast.UserMediaCallback() {
20        @Override
21        public void onEvent(
22            PCast pcast,
23            RequestStatus status,
24            UserMediaStream userMediaStream) {
25                // Check status and store 'userMediaStream'
26        }
27    });

1import com.phenixrts.pcast.UserMediaOptions;
2import com.phenixrts.pcast.UserMediaStream;
3
4// Previously obtained via 'getUserMedia'
5UserMediaStream userMediaStream = ...;
6
7// Previously initialized and used with 'getUserMedia'
8UserMediaOptions gumOptions = new UserMediaOptions();
9
10gumOptions.getVideoOptions().capabilityConstraints.put(
11    DeviceCapability.FACING_MODE, Arrays.asList(new DeviceConstraint(FacingMode.ENVIRONMENT)));
12gumOptions.getVideoOptions().capabilityConstraints.put(
13    DeviceCapability.FLASH_MODE, Arrays.asList(new DeviceConstraint(FlashMode.ALWAYS_ON)));
14gumOptions.getVideoOptions().capabilityConstraints.put(
15    DeviceCapability.HEIGHT,
16    Arrays.asList(new DeviceConstraint(720, ConstraintType.EXACT)));
17gumOptions.getVideoOptions().capabilityConstraints.put(
18    DeviceCapability.WIDTH,
19    Arrays.asList(
20        new DeviceConstraint(800, ConstraintType.MIN),
21        new DeviceConstraint(1500, ConstraintType.MAX)));
22
23userMediaStream.applyOptions(gumOptions);

1import android.util.Log;
2import com.phenixrts.pcast.MediaType;
3import com.phenixrts.pcast.PCast;
4import com.phenixrts.pcast.SourceDeviceInfo;
5
6// Previously initialized and started
7PCast pcast = ...;
8
9pcast.enumerateSourceDevices(
10    MediaType.VIDEO,
11    new PCast.EnumerateSourceDevicesCallback() {
12        @Override
13        public void onEvent(PCast pcast, SourceDeviceInfo[] devices) {
14            // Store devices as needed
15        }
16    });

1import android.util.Log;
2import com.phenixrts.pcast.MediaType;
3import com.phenixrts.pcast.PCast;
4import com.phenixrts.pcast.SourceDeviceInfo;
5import com.phenixrts.pcast.SourceDeviceType;
6
7// Previously initialized and started
8PCast pcast = ...;
9
10pcast.enumerateSourceDevices(
11    MediaType.VIDEO,
12    new PCast.EnumerateSourceDevicesCallback() {
13        @Override
14        public void onEvent(PCast pcast, SourceDeviceInfo[] devices) {
15            for (SourceDeviceInfo info : devices) {
16                if (info.sourceDeviceType == SourceDeviceType.SYSTEM_OUTPUT) {
17                    Log.i("Phenix SDK Example", "Screencasting is available");
18                    String screenCaptureDeviceId = info.id;
19                    // Store screenCaptureDeviceId
20                }
21            }
22        }
23    });
24
25pcast.enumerateSourceDevices();

1import android.media.projection.MediaProjection;
2import com.phenixrts.pcast.android.AndroidPCastFactory;
3
4// Previously obtained by calling
5// android.media.projection.MediaProjectionManager.getMediaProjection(),
6// see Android API reference.
7MediaProjection mediaProjection = ...;
8
9AndroidPCastFactory.setMediaProjection(mediaProjection);

1import com.phenixrts.pcast.FacingMode;
2import com.phenixrts.pcast.PCast;
3import com.phenixrts.pcast.UserMediaOptions;
4import com.phenixrts.pcast.UserMediaStream;
5
6// Previously initialized and started
7PCast pcast = ...;
8
9// Found by calling enumerateSourceDevices() as described above
10String screenCaptureDeviceId = ...;
11
12UserMediaOptions gumOptions = new UserMediaOptions();
13
14gumOptions.getVideoOptions().capabilityConstraints.put(
15    DeviceCapability.DEVICE_ID, Arrays.asList(new DeviceConstraint(screenCaptureDeviceId)));
16
17pcast.getUserMedia(
18    gumOptions,
19    new PCast.UserMediaCallback() {
20        @Override
21        public void onEvent(
22            PCast pcast,
23            RequestStatus status,
24            UserMediaStream userMediaStream) {
25                // Check status and store 'userMediaStream'
26        }
27    });

1import android.util.Log;
2import com.phenixrts.pcast.MediaStream;
3import com.phenixrts.pcast.PCast;
4import com.phenixrts.pcast.Publisher;
5import com.phenixrts.pcast.RequestStatus;
6import com.phenixrts.pcast.StreamEndedReason;
7import com.phenixrts.pcast.UserMediaOptions;
8import com.phenixrts.pcast.UserMediaStream;
9
10// Previously initialized and started
11PCast pcast = ...;
12// Previously created via EdgeAuth library
13String streamToken = ...;
14// Previously obtained via either PCast.subscribe()
15// or UserMediaStream.getMediaStream()
16MediaStream mediaStream = ...;
17
18String[] tags = { "my-tag" };
19
20pcast.publish(
21    streamToken,
22    mediaStream,
23    new PCast.PublishCallback() {
24        @Override
25        public void onEvent(
26            PCast pcast,
27            RequestStatus requestStatus,
28            Publisher publisher) {
29                // Check status and store 'publisher'
30
31                // The "streamId" of the publisher
32                String streamId = publisher.getStreamId();
33
34                if (publisher.hasEnded()) {
35                    // Checks if the publisher has ended
36                }
37
38                // Attach publisher ended callback
39                publisher.setPublisherEndedCallback(
40                    new Publisher.PublisherEndedCallback() {
41                        @Override
42                        public void onEvent(
43                            Publisher publisher,
44                            StreamEndedReason reason,
45                            String reasonDescription) {
46                                // Called when the stream has ended
47                                Log.i("Phenix SDK Example",
48                                    "Publish stream ended with reason ["
49                                    + reasonDescription + "]");
50                        }
51                    });
52
53                // To stop later
54                publisher.stop("I-am-done-publishing");
55        }
56    },
57    tags);

1import android.graphics.Bitmap;
2import com.phenixrts.media.audio.android.AndroidAudioFrame;
3import com.phenixrts.media.video.android.AndroidVideoFrame;
4import com.phenixrts.pcast.FrameNotification;
5import com.phenixrts.pcast.MediaStreamTrack;
6import com.phenixrts.pcast.PCast;
7import com.phenixrts.pcast.UserMediaStream;
8import com.phenixrts.pcast.android.AndroidReadAudioFrameCallback;
9import com.phenixrts.pcast.android.AndroidReadVideoFrameCallback;
10
11// Previously obtained via PCast.getUserMedia
12final UserMediaStream userMediaStream = ...;
13
14final MediaStreamTrack[] videoTracks = userMediaStream.getMediaStream().getVideoTracks();
15
16for (MediaStreamTrack videoTrack : videoTracks) {
17  userMediaStream.setFrameReadyCallback(videoTrack,
18      (frameNotification) -> {
19        frameNotification.read(new AndroidReadVideoFrameCallback() {
20          @Override
21          public void onVideoFrameEvent(AndroidVideoFrame videoFrame) {
22            final Bitmap pixelBuffer = videoFrame.bitmap;
23            final int displayHeightInPixels = pixelBuffer.getHeight();
24            final int displayWidthInPixels = pixelBuffer.getWidth();
25
26            // Manipulate bitmap as needed
27            ...
28
29            frameNotification.write(videoFrame);
30          }
31        });
32      });
33}
34
35final MediaStreamTrack[] audioTracks = userMediaStream.getMediaStream().getAudioTracks();
36
37for (MediaStreamTrack audioTrack : audioTracks) {
38  userMediaStream.setFrameReadyCallback(audioTrack,
39      (frameNotification) -> {
40        frameNotification.read(new AndroidReadAudioFrameCallback() {
41          @Override
42          public void onAudioFrameEvent(AndroidAudioFrame audioFrame) {
43            // Attenuate audio:
44            for (int sampleIndex = 0; sampleIndex < audioFrame.audioSamples.length; ++sampleIndex) {
45              audioFrame.audioSamples[sampleIndex] *= 0.1;
46            }
47
48            frameNotification.write(audioFrame);
49          }
50        });
51      });
52}

1import com.phenixrts.common.Disposable;
2import com.phenixrts.pcast.Publisher;
3
4// Previously obtained
5Publisher publisher = ...;
6
7Disposable disposable = publisher.limitBandwidth(200000);
8
9// ... after some time: force dispose to cancel bandwidth limitation:
10disposable.close();

1import android.util.Log;
2import com.phenixrts.pcast.MediaStream;
3import com.phenixrts.pcast.PCast;
4import com.phenixrts.pcast.RequestStatus;
5import com.phenixrts.pcast.StreamEndedReason;
6
7// Previously initialized and started
8PCast pcast = ...;
9// Previously created via EdgeAuth library
10String streamToken = ...;
11
12pcast.subscribe(
13    streamToken,
14    new PCast.SubscribeCallback() {
15        @Override
16        public void onEvent(
17            PCast pcast,
18            RequestStatus requestStatus,
19            MediaStream mediaStream) {
20                // Check status and store 'mediaStream'
21
22                // Attach stream ended callback
23                mediaStream.setStreamEndedCallback(
24                    new MediaStream.StreamEndedCallback() {
25                        @Override
26                        public void onEvent(
27                            MediaStream mediaStream,
28                            StreamEndedReason reason,
29                            String reasonDescription) {
30                                Log.i("Phenix SDK Example",
31                                    "Subscriber stream ended with reason ["
32                                    + reasonDescription + "]");
33                        }
34                    }
35                });
36
37                // To stop later
38                mediaStream.stop();
39        }
40    });

1import com.phenixrts.pcast.MediaStream;
2import com.phenixrts.pcast.Renderer;
3import com.phenixrts.pcast.RendererStartStatus;
4import com.phenixrts.pcast.android.AndroidVideoRenderSurface;
5
6// Previously obtained via either PCast.subscribe
7// or PhenixUserMediaStream.mediaStream
8MediaStream mediaStream = ...;
9
10// Previously obtained, e.g., from a SurfaceView
11Surface renderSurface = ...;
12
13Renderer renderer = mediaStream.createRenderer();
14
15RendererStartStatus status =
16    renderer.start(new AndroidVideoRenderSurface(renderSurface));
17
18if (status == RendererStartStatus.OK) {
19    Log.i("Phenix SDK Example", "Renderer started successfully");
20} else {
21    Log.e("Phenix SDK Example", "Renderer start failed");
22}
23
24// To stop later
25renderer.stop();

1import com.phenixrts.pcast.AspectRatioMode;
2import com.phenixrts.pcast.MediaStream;
3import com.phenixrts.pcast.Renderer;
4import com.phenixrts.pcast.RendererOptions;
5
6// Previously obtained via either PCast.subscribe or UserMediaStream.mediaStream
7MediaStream mediaStream = ...;
8
9RendererOptions options = new RendererOptions();
10options.aspectRatioMode = AspectRatioMode.FILL;
11
12Renderer renderer = mediaStream.createRenderer(options);

1import com.phenixrts.pcast.Renderer;
2import com.phenixrts.pcast.UserMediaStream;
3
4// Previously obtained via 'getUserMedia'
5UserMediaStream userMediaStream = ...;
6
7Renderer renderer = userMediaStream.getMediaStream().createRenderer();

1import com.phenixrts.pcast.Renderer;
2
3// Previously obtained from media stream
4Renderer renderer = ...;
5
6boolean isMuted = renderer.isAudioMuted();
7renderer.muteAudio();
8renderer.unmuteAudio();

1import com.phenixrts.pcast.Renderer;
2import com.phenixrts.android.AndroidLastFrameRenderedCallback;
3
4// Previously obtained from media stream and started
5Renderer renderer = ...;
6
7renderer.setLastVideoFrameRenderedReceivedCallback(
8    new AndroidLastFrameRenderedCallback() {
9        @override
10        public void onEvent(Renderer renderer, Bitmap videoFrame) {
11            // Process the frame as needed
12        }
13    });
14
15renderer.requestLastVideoFrameRendered();

1import com.phenixrts.pcast.UserMediaStream;
2import com.phenixrts.android.AndroidLastFrameCapturedCallback;
3
4// Previously obtained via 'getUserMedia'
5UserMediaStream userMediaStream = ...;
6
7userMediaStream.setLastVideoFrameCapturedReceivedCallback(
8    new AndroidLastFrameCapturedCallback() {
9        @override
10        public void onEvent(Renderer renderer, Bitmap videoFrame) {
11            // Process the frame as needed
12        }
13    });
14
15userMediaStream.requestLastVideoFrameCaptured();

1import com.phenixrts.pcast.DataQualityReason;
2import com.phenixrts.pcast.DataQualityStatus;
3import com.phenixrts.pcast.Publisher;
4import com.phenixrts.pcast.Renderer;
5
6// Previously obtained from media stream and started
7Renderer renderer = ...;
8
9renderer.setDataQualityChangedCallback(
10    new Renderer.DataQualityChangedCallback() {
11        @Override
12        public void onEvent(
13            Renderer renderer,
14            DataQualityStatus quality,
15            DataQualityReason reason) {
16                // Inform user, take action based on status and reason
17        }
18    });
19
20// Previously obtained via PCast.publish
21Publisher publisher = ...;
22
23publisher.setDataQualityChangedCallback(
24    new Publisher.DataQualityChangedCallback() {
25        @Override
26        public void onEvent(
27            Publisher publisher,
28            DataQualityStatus quality,
29            DataQualityReason reason) {
30                // Inform user, take action based on status and reason
31        }
32    });

1import com.phenixrts.pcast.Dimensions;
2import com.phenixrts.pcast.Renderer;
3
4// Previously obtained from media stream
5Renderer renderer = ...;
6
7renderer.setVideoDisplayDimensionsChangedCallback(
8    new Renderer.VideoDisplayDimensionsChangedCallback() {
9        @Override
10        public void onEvent(
11            Renderer renderer,
12            Dimensions displayDimensions) {
13                // Can get called multiple times while rendering a stream
14                // Values in displayDimensions.width, displayDimensions.height
15        }
16    });