implement getDisplayMedia

js/getDisplayMedia.js

@@ -0,0 +1,55 @@
+/**
+ * Expose the getDisplayMedia function.
+ */
+module.exports = getDisplayMedia;
+
+/**
+ * Dependencies.
+ */
+var debug = require('debug')('iosrtc:getDisplayMedia'),
+	debugerror = require('debug')('iosrtc:ERROR:getDisplayMedia'),
+	exec = require('cordova/exec'),
+	MediaStream = require('./MediaStream'),
+	Errors = require('./Errors');
+
+function getDisplayMedia(constraints) {
+	// Detect callback usage to assist 5.0.1 to 5.0.2 migration
+	// TODO remove on 6.0.0
+	Errors.detectDeprecatedCallbaksUsage('cordova.plugins.iosrtc.getDisplayMedia', arguments);
+
+	debug('[original constraints:%o]', constraints);
+
+	var newConstraints = {};
+
+	if (
+		typeof constraints !== 'object' ||
+		(!constraints.hasOwnProperty('audio') && !constraints.hasOwnProperty('video'))
+	) {
+		return new Promise(function (resolve, reject) {
+			reject(
+				new Errors.MediaStreamError(
+					'constraints must be an object with at least "audio" or "video" keys'
+				)
+			);
+		});
+	}
+
+	debug('[computed constraints:%o]', newConstraints);
+
+	return new Promise(function (resolve, reject) {
+		function onResultOK(data) {
+			debug('getDisplayMedia() | success');
+			var stream = MediaStream.create(data.stream);
+			resolve(stream);
+			// Emit "connected" on the stream.
+			stream.emitConnected();
+		}
+
+		function onResultError(error) {
+			debugerror('getDisplayMedia() | failure: %s', error);
+			reject(new Errors.MediaStreamError('getDisplayMedia() failed: ' + error));
+		}
+
+		exec(onResultOK, onResultError, 'iosrtcPlugin', 'getDisplayMedia', [newConstraints]);
+	});
+}

js/iosrtc.js

@@ -17,6 +17,7 @@ var // Dictionary of MediaStreamRenderers.
 	exec = require('cordova/exec'),
 	domready = require('domready'),
 	getUserMedia = require('./getUserMedia'),
+	getDisplayMedia = require('./getDisplayMedia'),
 	enumerateDevices = require('./enumerateDevices'),
 	RTCPeerConnection = require('./RTCPeerConnection'),
 	RTCSessionDescription = require('./RTCSessionDescription'),
@@ -33,6 +34,7 @@ var // Dictionary of MediaStreamRenderers.
 module.exports = {
 	// Expose WebRTC classes and functions.
 	getUserMedia: getUserMedia,
+	getDisplayMedia: getDisplayMedia,
 	enumerateDevices: enumerateDevices,
 	getMediaDevices: enumerateDevices, // TMP
 	RTCPeerConnection: RTCPeerConnection,
@@ -190,6 +192,8 @@ function registerGlobals(doNotRestoreCallbacksSupport) {
 		restoreCallbacksSupport();
 	}
 
+	navigator.getDisplayMedia = getDisplayMedia;
+	navigator.mediaDevices.getDisplayMedia = getDisplayMedia;
 	navigator.getUserMedia = getUserMedia;
 	navigator.webkitGetUserMedia = getUserMedia;
 

plugin.xml

@@ -71,6 +71,7 @@
 		<source-file src="src/PluginMediaStream.swift" />
 		<source-file src="src/PluginMediaStreamTrack.swift" />
 		<source-file src="src/PluginGetUserMedia.swift" />
+		<source-file src="src/PluginGetDisplayMedia.swift" />
 		<source-file src="src/PluginEnumerateDevices.swift" />
 		<source-file src="src/PluginUtils.swift" />
 		<source-file src="src/PluginMediaStreamRenderer.swift" />

src/PluginGetDisplayMedia.swift

@@ -0,0 +1,94 @@
+import Foundation
+import AVFoundation
+import ReplayKit
+
+class PluginGetDisplayMedia {
+
+	var rtcPeerConnectionFactory: RTCPeerConnectionFactory
+
+	init(rtcPeerConnectionFactory: RTCPeerConnectionFactory) {
+		NSLog("PluginGetDisplayMedia#init()")
+		self.rtcPeerConnectionFactory = rtcPeerConnectionFactory
+	}
+
+	deinit {
+		NSLog("PluginGetDisplayMedia#deinit()")
+	}
+
+	func call(
+		_ constraints: NSDictionary,
+		callback: @escaping (_ data: NSDictionary) -> Void,
+		errback: @escaping (_ error: String) -> Void,
+		eventListenerForNewStream: @escaping (_ pluginMediaStream: PluginMediaStream) -> Void
+	) {
+
+		NSLog("PluginGetDisplayMedia#call()")
+		if #available(iOS 11.0, *) {
+
+			let recorder = RPScreenRecorder.shared()
+
+			if (recorder.isRecording) {
+				recorder.stopCapture(handler: {(error) in
+					if (error != nil) {
+						errback(error!.localizedDescription)
+					} else {
+						self.startCapture(recorder: recorder, callback: callback, errback: errback, eventListenerForNewStream: eventListenerForNewStream)
+					}
+				})
+			} else if (recorder.isAvailable) {
+				self.startCapture(recorder: recorder, callback: callback, errback: errback, eventListenerForNewStream: eventListenerForNewStream)
+			} else {
+				errback("Screen recorder is not available!")
+			}
+
+		} else {
+			errback("Screen recorder is not available!")
+		}
+	}
+
+	@available(iOS 11.0, *)
+	func startCapture(
+		recorder: RPScreenRecorder,
+		callback: @escaping (_ data: NSDictionary) -> Void,
+		errback: @escaping (_ error: String) -> Void,
+		eventListenerForNewStream: @escaping (_ pluginMediaStream: PluginMediaStream) -> Void
+	) {
+
+		let rtcVideoSource: RTCVideoSource = self.rtcPeerConnectionFactory.videoSource()
+		let videoCapturer: RTCVideoCapturer = RTCVideoCapturer(delegate: rtcVideoSource)
+		let rtcMediaStream: RTCMediaStream = self.rtcPeerConnectionFactory.mediaStream(withStreamId: UUID().uuidString)
+		let rtcVideoTrack: RTCVideoTrack = self.rtcPeerConnectionFactory.videoTrack(
+			with: rtcVideoSource, trackId: UUID().uuidString)
+
+		let videoCaptureController: PluginRTCScreenCaptureController = PluginRTCScreenCaptureController(capturer: videoCapturer, recorder: recorder, source: rtcVideoSource)
+		rtcVideoTrack.videoCaptureController = videoCaptureController
+
+		// TODO use startCapture completionHandler
+		let captureStarted = videoCaptureController.startCapture()
+		if (!captureStarted) {
+			errback("constraints failed")
+			return
+		}
+
+		// If videoSource state is "ended" it means that constraints were not satisfied so
+		// invoke the given errback.
+		if (rtcVideoSource.state == RTCSourceState.ended) {
+		  NSLog("PluginGetDisplayMedia() | rtcVideoSource.state is 'ended', constraints not satisfied")
+
+		  errback("constraints not satisfied")
+		  return
+		}
+
+		rtcMediaStream.addVideoTrack(rtcVideoTrack)
+
+		let pluginMediaStream: PluginMediaStream = PluginMediaStream(rtcMediaStream: rtcMediaStream)
+		pluginMediaStream.run()
+
+		// Let the plugin store it in its dictionary.
+		eventListenerForNewStream(pluginMediaStream)
+
+		callback([
+			"stream": pluginMediaStream.getJSON()
+		])
+	}
+}

src/PluginGetUserMedia.swift

@@ -98,7 +98,7 @@ class PluginGetUserMedia {
 // Ignore Simulator cause does not support Camera
 #if !targetEnvironment(simulator)
 			let videoCapturer: RTCCameraVideoCapturer = RTCCameraVideoCapturer(delegate: rtcVideoSource!)
-			let videoCaptureController: PluginRTCVideoCaptureController = PluginRTCVideoCaptureController(capturer: videoCapturer)
+			let videoCaptureController: PluginRTCCameraCaptureController = PluginRTCCameraCaptureController(capturer: videoCapturer)
 			rtcVideoTrack!.videoCaptureController = videoCaptureController
 
 			let constraintsSatisfied = videoCaptureController.setConstraints(constraints: videoConstraints)

src/PluginMediaStreamTrack.swift

@@ -106,9 +106,11 @@ class PluginMediaStreamTrack : NSObject {
 		}
 	}
 
+	/*
 	func switchCamera() {
 		self.rtcMediaStreamTrack.videoCaptureController?.switchCamera()
 	}
+	*/
 
 	func registerRender(render: PluginMediaStreamRenderer) {
 		if let exist = self.renders[render.id] {

src/PluginRTCVideoCaptureController.swift

@@ -1,5 +1,6 @@
 import Foundation
 import AVFoundation
+import ReplayKit
 
 import func ObjectiveC.objc_getAssociatedObject
 import func ObjectiveC.objc_setAssociatedObject
@@ -52,22 +53,123 @@ extension RTCMediaStreamTrack {
 
 class PluginRTCVideoCaptureController : NSObject {
 
+	var isCapturing: Bool = false;
+
+	// Default to the front camera.
+	var device: AVCaptureDevice?
+	var deviceFormat: AVCaptureDevice.Format?
+	var deviceFrameRate: Int?
+
+	var constraints: NSDictionary = [:]
+
+	func startCapture(completionHandler: ((Error?) -> Void)? = nil) -> Bool {
+		return isCapturing;
+	}
+
+	func stopCapture() {
+
+	}
+}
+
+class PluginRTCScreenCaptureController : PluginRTCVideoCaptureController {
+
+	var capturer: RTCVideoCapturer
+	var source: RTCVideoSource
+	var recorder: RPScreenRecorder
+
+	init(capturer: RTCVideoCapturer, recorder: RPScreenRecorder, source: RTCVideoSource) {
+		self.capturer = capturer
+		self.recorder = recorder;
+		self.source = source;
+	}
+
+	override func startCapture(completionHandler: ((Error?) -> Void)? = nil) -> Bool {
+
+		// Stop previous capture in case of setConstraints, followed by startCapture
+		// aka future applyConstraints
+		if (isCapturing) {
+			stopCapture();
+		}
+
+		if #available(iOS 11.0, *) {
+			recorder.isMicrophoneEnabled = false
+			recorder.startCapture(handler: {(sampleBuffer, bufferType, error) in
+				if (bufferType == RPSampleBufferType.video) {
+					self.handleSourceBuffer(
+						source: self.source,
+						sampleBuffer: sampleBuffer,
+						sampleType: bufferType
+					)
+				}
+				if (completionHandler != nil && error != nil) {
+					completionHandler!(error)
+				}
+			}) { (error) in
+				if (completionHandler != nil && error != nil) {
+					completionHandler!(error)
+				} else {
+					// TODO Optional closure parameter
+					//completionHandler!()
+				}
+			}
+
+			isCapturing = true
+
+			NSLog("PluginRTCScreenCaptureController#startCapture Capture started");
+		}
+
+		return isCapturing;
+	}
+
+	override func stopCapture() {
+		// TODO: stopCaptureWithCompletionHandler with DispatchSemaphore
+		if (isCapturing) {
+			if #available(iOS 11.0, *) {
+				recorder.stopCapture {(error) in
+					// TODO debug error
+				}
+				isCapturing = false
+
+				NSLog("PluginRTCScreenCaptureController#stopCapture Capture stopped");
+			}
+		}
+	}
+
+	func handleSourceBuffer(source: RTCVideoSource, sampleBuffer: CMSampleBuffer, sampleType: RPSampleBufferType) {
+		if (CMSampleBufferGetNumSamples(sampleBuffer) != 1 || !CMSampleBufferIsValid(sampleBuffer) ||
+			!CMSampleBufferDataIsReady(sampleBuffer)) {
+			return;
+		}
+
+		let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
+		if (pixelBuffer == nil) {
+			return;
+		}
+
+		let width = CVPixelBufferGetWidth(pixelBuffer!);
+		let height = CVPixelBufferGetHeight(pixelBuffer!);
+
+		source.adaptOutputFormat(toWidth: Int32(width/2), height: Int32(height/2), fps: 8)
+
+		let rtcPixelBuffer = RTCCVPixelBuffer(pixelBuffer: pixelBuffer!)
+		let timeStampNs =
+			CMTimeGetSeconds(CMSampleBufferGetPresentationTimeStamp(sampleBuffer)) * Float64(NSEC_PER_SEC)
+		let videoFrame =  RTCVideoFrame(buffer: rtcPixelBuffer, rotation: RTCVideoRotation._0, timeStampNs: Int64(timeStampNs))
+		source.capturer(capturer, didCapture: videoFrame)
+	}
+}
+
+class PluginRTCCameraCaptureController : PluginRTCVideoCaptureController {
+
 	private let DEFAULT_HEIGHT : Int32 = 480
 	private let DEFAULT_WIDTH : Int32 = 640
+
 	private let DEFAULT_FPS : Int = 15
 	private let DEFAULT_ASPECT_RATIO : Float32 = 4/3
 	private let FACING_MODE_USER : String = "user";
 	private let FACING_MODE_ENV : String = "environment";
 
 	var capturer: RTCCameraVideoCapturer
-	var isCapturing: Bool = false;
-
-	// Default to the front camera.
-	var device: AVCaptureDevice?
-	var deviceFormat: AVCaptureDevice.Format?
-	var deviceFrameRate: Int?
-
-	var constraints: NSDictionary = [:]
 
 	init(capturer: RTCCameraVideoCapturer) {
 		self.capturer = capturer
@@ -139,7 +241,7 @@ class PluginRTCVideoCaptureController : NSObject {
 		return device != nil;
 	}
 
-	func startCapture() -> Bool {
+	override func startCapture(completionHandler: ((Error?) -> Void)? = nil) -> Bool {
 
 		// Stop previous capture in case of setConstraints, followed by startCapture
 		// aka future applyConstraints
@@ -167,10 +269,10 @@ class PluginRTCVideoCaptureController : NSObject {
 
 		NSLog("PluginRTCVideoCaptureController#startCapture Capture started, device:%@, format:%@", device!, deviceFormat!);
 
-		return true;
+		return isCapturing;
 	}
 
-	func stopCapture() {
+	override func stopCapture() {
 		// TODO: stopCaptureWithCompletionHandler with DispatchSemaphore
 		if (isCapturing) {
 			capturer.stopCapture()
@@ -294,6 +396,7 @@ class PluginRTCVideoCaptureController : NSObject {
 		return captureDevices.firstObject as? AVCaptureDevice
 	}
 
+	/*
 	func switchCamera() -> Bool {
 
 		if (self.capturer.captureSession.isRunning) {
@@ -306,6 +409,7 @@ class PluginRTCVideoCaptureController : NSObject {
 
 		return self.startCapture()
 	}
+	*/
 
 	fileprivate func findAlternativeDevicePosition(currentDevice: AVCaptureDevice?) -> AVCaptureDevice? {
 		let captureDevices: NSArray = RTCCameraVideoCapturer.captureDevices() as NSArray
@@ -468,7 +572,7 @@ class PluginRTCVideoCaptureController : NSObject {
 
 		return selectedFormat
 	}
-	
+
 	//
 	// constraints parsers
 	//