/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License") + you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.openmeetings.screen.webstart;
import java.awt.MouseInfo;
import java.awt.Point;
import java.awt.PointerInfo;
import java.awt.Robot;
import java.awt.Toolkit;
import java.awt.datatransfer.Clipboard;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.StringSelection;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.apache.openmeetings.screen.webstart.gui.ScreenDimensions;
import org.apache.openmeetings.screen.webstart.gui.ScreenSharerFrame;
import org.red5.client.net.rtmp.INetStreamEventHandler;
import org.red5.io.utils.ObjectMap;
import org.red5.server.api.event.IEvent;
import org.red5.server.api.service.IPendingServiceCall;
import org.red5.server.api.service.IPendingServiceCallback;
import org.red5.server.net.rtmp.Channel;
import org.red5.server.net.rtmp.RTMPConnection;
import org.red5.server.net.rtmp.codec.RTMP;
import org.red5.server.net.rtmp.event.Notify;
import org.red5.server.net.rtmp.message.Header;
import org.red5.server.net.rtmp.status.StatusCodes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class CoreScreenShare implements IPendingServiceCallback, INetStreamEventHandler {
private static final Logger logger = LoggerFactory.getLogger(CoreScreenShare.class);
private IScreenShare instance = null;
private String host;
private String app;
private int port;
public String publishName;
private CaptureScreen capture = null;
private RTMPClientPublish publishClient = null;
private ScreenSharerFrame frame;
public int defaultQuality = 1;
public Long organization_id = 0L;
public Long user_id = null;
private boolean allowRecording = true;
private boolean allowPublishing = true;
private boolean startStreaming = false;
private boolean startRecording = false;
private boolean startPublishing = false;
public float Ampl_factor = 1f;
public boolean isConnected = false;
private boolean readyToRecord = false;
public Map<Integer, Boolean> currentPressedKeys = new HashMap<Integer, Boolean>();
private CaptureScreen getCapture() {
if (capture == null) {
capture = new CaptureScreen(this, instance, host, app, port);
}
return capture;
}
// ------------------------------------------------------------------------
//
// Main
//
// ------------------------------------------------------------------------
public CoreScreenShare(IScreenShare instance, String[] args) {
this.instance = instance;
try {
for (String arg : args) {
logger.debug("arg: " + arg);
}
String[] textArray = null;
if (args.length > 8) {
host = args[0];
app = args[1];
port = Integer.parseInt(args[2]);
publishName = args[3];
String labelTexts = args[4];
organization_id = Long.parseLong(args[5]);
defaultQuality = Integer.parseInt(args[6]);
user_id = Long.parseLong(args[7]);
allowRecording = Boolean.valueOf(args[8]);
allowPublishing = Boolean.valueOf(args[9]);
if (labelTexts.length() > 0) {
textArray = labelTexts.split(";");
logger.debug("labelTexts :: " + labelTexts);
logger.debug("textArray Length " + textArray.length);
for (int i = 0; i < textArray.length; i++) {
logger.debug(i + " :: " + textArray[i]);
}
}
logger.debug("host: " + host + ", app: "
+ app + ", port: " + port + ", publish: "
+ publishName);
} else {
System.exit(0);
}
createWindow(textArray);
} catch (Exception err) {
logger.error("", err);
}
}
// ------------------------------------------------------------------------
//
// GUI
//
// ------------------------------------------------------------------------
public void createWindow(String[] textArray) {
try {
frame = new ScreenSharerFrame(this, textArray);
frame.setVisible(true);
frame.setRecordingTabEnabled(allowRecording);
frame.setPublishingTabEnabled(allowPublishing);
logger.debug("initialized");
} catch (Exception err) {
logger.error("createWindow Exception: ", err);
err.printStackTrace();
}
}
synchronized public void sendCursorStatus() {
try {
PointerInfo a = MouseInfo.getPointerInfo();
Point mouseP = a.getLocation();
float scaleFactor = (1.0f * ScreenDimensions.resizeX) / ScreenDimensions.spinnerWidth;
// Real size: Real mouse position = Resize : X
int x = (int)(Ampl_factor * (mouseP.getX() - ScreenDimensions.spinnerX) * scaleFactor);
int y = (int)(Ampl_factor * (mouseP.getY() - ScreenDimensions.spinnerY) * scaleFactor);
HashMap<String, Object> cursorPosition = new HashMap<String, Object>();
cursorPosition.put("publicSID", this.publishName);
cursorPosition.put("cursor_x", x);
cursorPosition.put("cursor_y", y);
if (instance.getConnection() != null) {
instance.invoke("setNewCursorPosition", new Object[] { cursorPosition }, this);
}
} catch (NullPointerException npe) {
//noop
} catch (Exception err) {
System.out.println("captureScreenStart Exception: ");
System.err.println(err);
frame.setStatus("Exception: " + err);
logger.error("[sendCursorStatus]", err);
}
}
synchronized public void setConnectionAsSharingClient() {
try {
logger.debug("########## setConnectionAsSharingClient");
HashMap<Object, Object> map = new HashMap<Object, Object>();
map.put("screenX", ScreenDimensions.spinnerX);
map.put("screenY", ScreenDimensions.spinnerY);
int scaledWidth = (int)(Ampl_factor * ScreenDimensions.resizeX);
int scaledHeight = (int)(Ampl_factor * ScreenDimensions.resizeY);
map.put("screenWidth", scaledWidth);
map.put("screenHeight", scaledHeight);
map.put("publishName", this.publishName);
map.put("startRecording", startRecording);
map.put("startStreaming", startStreaming);
map.put("startPublishing", startPublishing);
map.put("publishingHost", frame.getPublishHost());
map.put("publishingApp", frame.getPublishApp());
map.put("publishingId", frame.getPublishId());
map.put("organization_id", this.organization_id);
map.put("user_id", this.user_id);
instance.invoke("setConnectionAsSharingClient", new Object[] { map }, this);
} catch (Exception err) {
logger.error("setConnectionAsSharingClient Exception: ", err);
frame.setStatus("Error: " + err.getLocalizedMessage());
logger.error("[setConnectionAsSharingClient]", err);
}
}
/**
* @param startStreaming flag denoting the streaming is started
* @param startRecording flag denoting the recording is started
*/
public void captureScreenStart(boolean startStreaming, boolean startRecording) {
captureScreenStart(startStreaming, startRecording, false);
}
public void captureScreenStart(boolean startStreaming, boolean startRecording, boolean startPublishing) {
try {
logger.debug("captureScreenStart");
this.startStreaming = startStreaming;
this.startRecording= startRecording;
this.startPublishing = startPublishing;
if (!isConnected) {
instance.connect(host, port, app, this);
} else {
setConnectionAsSharingClient();
}
} catch (Exception err) {
logger.error("captureScreenStart Exception: ", err);
frame.setStatus("Exception: " + err);
}
}
public void sendCaptureScreenStop(boolean stopStreaming, boolean stopRecording) {
try {
logger.debug("INVOKE screenSharerAction" );
Map<String, Object> map = new HashMap<String, Object>();
map.put("stopStreaming", stopStreaming);
map.put("stopRecording", stopRecording);
instance.invoke("screenSharerAction", new Object[] { map }, this);
} catch (Exception err) {
logger.error("captureScreenStop Exception: ", err);
frame.setStatus("Exception: " + err);
}
}
public void sendStopPublishing() {
Map<String, Object> map = new HashMap<String, Object>();
map.put("stopPublishing", true);
instance.invoke("screenSharerAction", new Object[] { map }, this);
}
public void stopStreaming() {
startStreaming = false;
frame.setSharingStatus(false, !startPublishing && !startRecording && !startStreaming);
}
public void stopRecording() {
startRecording = false;
frame.setRecordingStatus(false, !startPublishing && !startRecording && !startStreaming);
}
public void stopPublishing() {
startPublishing = false;
frame.setPublishingStatus(false, !startPublishing && !startRecording && !startStreaming);
if (publishClient != null) {
publishClient.disconnect();
publishClient = null;
}
}
synchronized public boolean isReadyToRecord() {
return readyToRecord;
}
synchronized private void setReadyToRecord(boolean readyToRecord) {
this.readyToRecord = readyToRecord;
}
protected void onInvoke(RTMPConnection conn, Channel channel,
Header source, Notify invoke, RTMP rtmp) {
if (invoke.getType() == IEvent.Type.STREAM_DATA) {
return;
}
String method = invoke.getCall().getServiceMethodName();
if ("stopStream".equals(method)) {
stopStream();
} else if ("sendRemoteCursorEvent".equals(method)) {
sendRemoteCursorEvent(invoke.getCall().getArguments()[0]);
} else if ("screenSharerAction".equals(method)) {
Object[] args = invoke.getCall().getArguments();
if (args != null && args.length > 0) {
@SuppressWarnings("unchecked")
HashMap<String, Object> params = (HashMap<String, Object>)args[0];
if (params.containsKey("stopPublishing")
&& Boolean.valueOf("" + params.get("stopPublishing"))) {
stopPublishing();
}
if (params.containsKey("error")) {
frame.setStatus("" + params.get("error"));
}
}
}
}
public void stopStream() {
try {
logger.debug("ScreenShare stopStream");
stopStreaming();
stopRecording();
stopPublishing();
isConnected = false;
instance.disconnect();
setReadyToRecord(false);
getCapture().setStartPublish(false);
getCapture().release();
capture = null;
} catch (Exception e) {
logger.error("ScreenShare stopStream exception " + e);
}
}
public void onStreamEvent(Notify notify) {
logger.debug( "onStreamEvent " + notify );
@SuppressWarnings("rawtypes")
ObjectMap map = (ObjectMap) notify.getCall().getArguments()[0];
String code = (String) map.get("code");
if (StatusCodes.NS_PUBLISH_START.equals(code)) {
logger.debug( "onStreamEvent Publish start" );
getCapture().setStartPublish(true);
setReadyToRecord(true);
}
}
public void sendRemoteCursorEvent(Object obj) {
try {
logger.trace("#### sendRemoteCursorEvent ");
logger.trace("Result Map Type "+obj.getClass().getName());
@SuppressWarnings("rawtypes")
Map returnMap = (Map) obj;
String action = "" + returnMap.get("action");
if (action.equals("onmouseup")) {
Robot robot = new Robot();
Float scaleFactor = Float
.valueOf(ScreenDimensions.spinnerWidth)
/ Float.valueOf(ScreenDimensions.resizeX);
Float part_x1 = ((Float.valueOf(returnMap.get("x").toString())
.floatValue() * scaleFactor) / Float
.valueOf(Ampl_factor));
Integer x = Math.round(part_x1 + ScreenDimensions.spinnerX);
Integer y = Math
.round(((Float.valueOf(returnMap.get("y").toString())
.floatValue()
* ScreenDimensions.spinnerHeight / ScreenDimensions.resizeY) / Ampl_factor)
+ ScreenDimensions.spinnerY);
robot.mouseMove(x, y);
robot.mouseRelease(InputEvent.BUTTON1_MASK);
} else if (action.equals("onmousedown")) {
Robot robot = new Robot();
Float scaleFactor = Float
.valueOf(ScreenDimensions.spinnerWidth)
/ Float.valueOf(ScreenDimensions.resizeX);
Float part_x1 = ((Float.valueOf(returnMap.get("x").toString())
.floatValue() * scaleFactor) / Float
.valueOf(Ampl_factor));
Integer x = Math.round(part_x1
+ ScreenDimensions.spinnerX);
Integer y = Math
.round(((Float.valueOf(returnMap.get("y").toString())
.floatValue()
* ScreenDimensions.spinnerHeight / ScreenDimensions.resizeY) / Ampl_factor)
+ ScreenDimensions.spinnerY);
robot.mouseMove(x, y);
robot.mousePress(InputEvent.BUTTON1_MASK);
} else if (action.equals("mousePos")) {
Robot robot = new Robot();
Float scaleFactor = Float
.valueOf(ScreenDimensions.spinnerWidth)
/ Float.valueOf(ScreenDimensions.resizeX);
Float part_x1 = ((Float.valueOf(returnMap.get("x").toString())
.floatValue() * scaleFactor) / Float
.valueOf(Ampl_factor));
Integer x = Math.round(part_x1
+ ScreenDimensions.spinnerX);
Integer y = Math
.round(((Float.valueOf(returnMap.get("y").toString())
.floatValue()
* ScreenDimensions.spinnerHeight / ScreenDimensions.resizeY) / Ampl_factor)
+ ScreenDimensions.spinnerY);
robot.mouseMove(x, y);
} else if (action.equals("onkeydown")) {
Robot robot = new Robot();
Integer key = Integer.valueOf(returnMap.get("k").toString())
.intValue();
// logger.debug("key onkeydown -1 "+key);
boolean doAction = true;
if (key == 221) {
key = 61;
} else if (key == -1) {
String charValue = returnMap.get("c").toString();
// key = KeyEvent.VK_ADD;
doAction = false;
for (Iterator<Integer> iter = this.currentPressedKeys
.keySet().iterator(); iter.hasNext();) {
Integer storedKey = iter.next();
robot.keyRelease(storedKey);
}
this.currentPressedKeys = new HashMap<Integer, Boolean>();
this.pressSpecialSign(charValue, robot);
} else if (key == 188) {
key = 44;
} else if (key == 189) {
key = 109;
} else if (key == 190) {
key = 46;
} else if (key == 191) {
key = 47;
} else if (key == 13) {
key = KeyEvent.VK_ENTER;
}
// logger.debug("key onkeydown -2 "+key);
if (doAction) {
this.currentPressedKeys.put(key, true);
robot.keyPress(key);
}
} else if (action.equals("onkeyup")) {
Robot robot = new Robot();
Integer key = Integer.valueOf(returnMap.get("k").toString())
.intValue();
// logger.debug("key onkeyup 1- "+key);
boolean doAction = true;
if (key == 221) {
key = 61;
} else if (key == -1) {
doAction = false;
} else if (key == 188) {
key = 44;
} else if (key == 189) {
key = 109;
} else if (key == 190) {
key = 46;
} else if (key == 191) {
key = 47;
} else if (key == 13) {
key = KeyEvent.VK_ENTER;
}
// logger.debug("key onkeyup 2- "+key);
if (doAction) {
if (this.currentPressedKeys.containsKey(key)) {
this.currentPressedKeys.remove(key);
robot.keyRelease(key);
}
}
} else if (action.equals("paste")) {
Robot robot = new Robot();
String paste = returnMap.get("paste").toString();
this.pressSpecialSign(paste, robot);
} else if (action.equals("copy")) {
Robot robot = new Robot();
String paste = this.getHighlightedText(robot);
HashMap<Integer, String> map = new HashMap<Integer, String>();
map.put(0, "copiedText");
map.put(1, paste);
String clientId = returnMap.get("clientId").toString();
// public synchronized int sendMessageWithClientById(Object
// newMessage, String clientId)
instance.invoke("sendMessageWithClientById", new Object[]{map, clientId}, this);
} else if (action.equals("show")) {
String paste = this.getClipboardText();
HashMap<Integer, String> map = new HashMap<Integer, String>();
map.put(0, "copiedText");
map.put(1, paste);
String clientId = returnMap.get("clientId").toString();
// public synchronized int sendMessageWithClientById(Object
// newMessage, String clientId)
instance.invoke("sendMessageWithClientById", new Object[]{map, clientId}, this);
}
// KeyEvent.VK
// KeyEvent.
} catch (Exception err) {
logger.error("[sendRemoteCursorEvent]", err);
}
}
public String getClipboardText() {
try {
// get the system clipboard
Clipboard systemClipboard = Toolkit.getDefaultToolkit()
.getSystemClipboard();
// get the contents on the clipboard in a
// transferable object
Transferable clipboardContents = systemClipboard.getContents(null);
// check if clipboard is empty
if (clipboardContents == null) {
// Clipboard is empty!!!
return ("");
// see if DataFlavor of
// DataFlavor.stringFlavor is supported
} else if (clipboardContents
.isDataFlavorSupported(DataFlavor.stringFlavor)) {
// return text content
String returnText = (String) clipboardContents
.getTransferData(DataFlavor.stringFlavor);
return returnText;
}
return "";
} catch (UnsupportedFlavorException ufe) {
ufe.printStackTrace();
} catch (IOException ioe) {
ioe.printStackTrace();
}
return "";
}
private String getHighlightedText(Robot instance) {
try {
// clippy.setContents( selection,selection );
// logger.debug("os.name :: "+System.getProperty("os.name"));
if (System.getProperty("os.name").toUpperCase().indexOf("WINDOWS") >= 0) {
// logger.debug("IS WINDOWS");
// pressing STRG+C == copy
instance.keyPress(KeyEvent.VK_CONTROL);
Thread.sleep(200);
instance.keyPress(KeyEvent.VK_C);
Thread.sleep(200);
instance.keyRelease(KeyEvent.VK_C);
Thread.sleep(200);
instance.keyRelease(KeyEvent.VK_CONTROL);
Thread.sleep(200);
} else {
// logger.debug("IS MAC");
// Macintosh simulate Copy
instance.keyPress(157);
Thread.sleep(200);
instance.keyPress(67);
Thread.sleep(200);
instance.keyRelease(67);
Thread.sleep(200);
instance.keyRelease(157);
Thread.sleep(200);
}
String charValue = this.getClipboardText();
return charValue;
} catch (Exception ex) {
ex.printStackTrace();
}
return "";
}
private void pressSpecialSign(String charValue, Robot instance) {
Clipboard clippy = Toolkit.getDefaultToolkit().getSystemClipboard();
try {
Transferable transferableText = new StringSelection(charValue);
clippy.setContents(transferableText, null);
// logger.debug("os.name :: "+System.getProperty("os.name"));
if (System.getProperty("os.name").toUpperCase().indexOf("WINDOWS") >= 0) {
// logger.debug("IS WINDOWS");
// pressing STRG+V == insert-mode
instance.keyPress(KeyEvent.VK_CONTROL);
Thread.sleep(100);
instance.keyPress(KeyEvent.VK_V);
Thread.sleep(100);
instance.keyRelease(KeyEvent.VK_V);
Thread.sleep(100);
instance.keyRelease(KeyEvent.VK_CONTROL);
Thread.sleep(100);
} else {
// logger.debug("IS MAC");
// Macintosh simulate Insert
instance.keyPress(157);
Thread.sleep(100);
instance.keyPress(86);
Thread.sleep(100);
instance.keyRelease(86);
Thread.sleep(100);
instance.keyRelease(157);
Thread.sleep(100);
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
public void resultReceived(IPendingServiceCall call) {
try {
logger.trace( "service call result: " + call );
String method = call == null ? null : call.getServiceMethodName();
logger.trace("call ### get Method Name " + method);
if ("connect".equals(method)) {
isConnected = true;
setConnectionAsSharingClient();
} else if ("setConnectionAsSharingClient".equals(method)) {
Object o = call.getResult();
@SuppressWarnings("unchecked")
Map<String, Object> returnMap = (Map<String, Object>) o;
if (o == null || !Boolean.valueOf("" + returnMap.get("alreadyPublished")).booleanValue()) {
logger.trace("Stream not yet started - do it ");
instance.createStream(this);
} else {
getCapture().resetBuffer();
logger.trace("The Stream was already started ");
}
if (returnMap != null) {
Object modus = returnMap.get("modus");
if ("startStreaming".equals(modus)) {
frame.setSharingStatus(true, false);
}
if ("startRecording".equals(modus)) {
frame.setRecordingStatus(true, false);
}
if ("startPublishing".equals(modus)) {
frame.setPublishingStatus(true, false);
publishClient = new RTMPClientPublish(
this
, frame.getPublishHost()
, frame.getPublishApp()
, frame.getPublishId());
publishClient.connect();
}
} else {
throw new Exception(
"Could not aquire modus for event setConnectionAsSharingClient");
}
} else if ("createStream".equals(method)) {
if (startRecording || startStreaming) {
if (call.getResult() != null) {
getCapture().setStreamId((Integer)call.getResult());
}
logger.debug("createPublishStream result stream id: " + getCapture().getStreamId());
logger.debug("publishing video by name: " + publishName);
instance.publish(getCapture().getStreamId(), publishName, "live", this);
logger.debug("setup capture thread");
logger.debug("setup capture thread vScreenSpinnerWidth "
+ ScreenDimensions.spinnerWidth);
logger.debug("setup capture thread vScreenSpinnerHeight "
+ ScreenDimensions.spinnerHeight);
getCapture().setSendCursor(true);
getCapture().start();
}
} else if ("screenSharerAction".equals(method)) {
Object o = call.getResult();
logger.trace("Result Map Type " + o.getClass().getName());
@SuppressWarnings("unchecked")
Map<String, Object> returnMap = (Map<String, Object>)o;
Object result = returnMap.get("result");
if ("stopAll".equals(result)) {
logger.trace("Stopping to stream, there is neither a Desktop Sharing nor Recording anymore");
stopStream();
} else if ("stopSharingOnly".equals(result)) {
stopStreaming();
} else if ("stopRecordingOnly".equals(result)) {
stopRecording();
} else if ("stopPublishingOnly".equals(result)) {
stopPublishing();
}
} else if ("setNewCursorPosition".equals(method)) {
// Do not do anything
} else {
logger.debug("Unknown method " + method);
}
} catch (Exception err) {
logger.error("[resultReceived]", err);
}
}
}