El ejemplo de este artículo describe cómo Java implementa la transmisión de pantalla controlando el mouse. Compártelo con todos para tu referencia. El análisis específico es el siguiente:
En el artículo anterior "Análisis de ejemplos de implementación de la función de compartir pantalla en Java", se mencionó que no hay mouse al capturar la pantalla. Para ver el mouse en la interfaz del maestro, puede acercar el mouse a cada captura de pantalla. Sin embargo, dado que las capturas de pantalla se toman una por una, el mouse que ve inevitablemente estará un poco atascado. Escribí un subprograma de control del mouse de Java antes, y puede ver la demostración del mouse de esta manera.
El método de implementación también es bastante simple. Los dos artículos anteriores implementaron funciones de control del mouse y uso compartido de pantalla sin mouse, respectivamente. Analicemos brevemente las dos a continuación.
En el lado del servidor, SendScreenImg y SendMouseMessage se consideran dos clases de herramientas, que escuchan puertos diferentes respectivamente. Ambas implementan la clase Thread y usamos la clase ExecutorService del grupo de subprocesos para controlarlas.
Se utilizan dos puertos porque todavía no sé cómo enviar la información del mouse y la información de la imagen juntas. Tal vez pueda convertir la imagen en una matriz de bytes y colocar las coordenadas del mouse delante de la matriz, pero en este caso. Es posible que el mouse no sea coherente, porque la velocidad de transmisión de las coordenadas del mouse será más rápida que la de las imágenes. Bueno, inténtalo de nuevo cuando tengas tiempo.
La analogía del cliente es la misma que la anterior.
Aquí está el código:
Servidor:
Programa principal:
Copie el código de código de la siguiente manera:/*
* La clase de transmisión de pantalla llama a dos clases de herramientas: una clase para enviar información de captura de pantalla y una clase para enviar información del mouse, utilizando el grupo de subprocesos.
*/
clase pública BroderCast {
principal vacío estático público (String [] argumentos)
{
nuevo BroderCast();
System.out.println("Inicio");
}
BroderCast público()
{
ExecutorService ejecutor = Executors.newFixedThreadPool(2);
ejecutor.execute(nuevo SendScreenImg());
ejecutor.execute(nuevo SendMouseMessage());
}
}
Enviar código de captura de pantalla:
Copie el código de la siguiente manera: import java.awt.Dimension;
importar java.awt.Rectangle;
importar java.awt.Robot;
importar java.awt.Toolkit;
importar java.awt.image.BufferedImage;
importar java.io.DataOutputStream;
importar java.io.IOException;
importar java.net.ServerSocket;
importar java.net.Socket;
importar java.util.zip.ZipEntry;
importar java.util.zip.ZipOutputStream;
importar javax.imageio.ImageIO;
/*
* Herramientas: envía información de captura de pantalla desde el lado del profesor al lado del estudiante. No hay información del mouse y se utiliza el puerto 8002.
* La información del mouse se puede dibujar en el componente de la imagen enviada, de modo que la información del mouse se pueda ver en la interfaz del estudiante. Esta función aún no se ha implementado.
*
*/
la clase pública SendScreenImg extiende el hilo
{
puerto de servidor público int = 8002;
serverSocket privado serverSocket;
robot privado;
pantalla de dimensión pública;
rectángulo público rect;
toma de corriente privada;
principal vacío estático público (argumentos de cadena [])
{
nuevo SendScreenImg().start();
}
cambio de vacío públicoServerPort (int serverPort)
{
if(this.serverPort == serverPort) retorno;
intentar{
this.serverSocket.close(); //Es necesario cerrar primero el puerto actual
this.serverPort = servidorPort;
serverSocket = nuevo ServerSocket(this.serverPort);
serverSocket.setSoTimeout(8000000);
}captura(Excepción e){}
}
//Método de construcción para abrir el robot de conexión de socket y obtener el tamaño de la pantalla
EnviarScreenImg público()
{
intentar {
serverSocket = nuevo ServerSocket(getServerPort());
serverSocket.setSoTimeout(864000000);
robot = nuevo robot();
} captura (Excepción e) {
e.printStackTrace();
}
screen = Toolkit.getDefaultToolkit().getScreenSize() //Obtener el tamaño de la pantalla principal
rect = new Rectángulo(pantalla); //Construye un rectángulo del tamaño correspondiente
}
@Anular
ejecución pública vacía()
{
//Esperando en tiempo real recibir mensajes de captura de pantalla
mientras (verdadero) {
intentar {
socket = serverSocket.accept();
ZipOutputStream zip = nuevo ZipOutputStream(nuevo DataOutputStream(socket.getOutputStream()));
zip.setLevel(9); //Establece el nivel de compresión
intentar{
BufferedImage img = robot.createScreenCapture(rect);
zip.putNextEntry(new ZipEntry("prueba.jpg"));
ImageIO.write(img, "jpg", zip);
si(zip!=null)zip.close();
System.out.println("El puerto de estudiantes está conectado");
} captura (IOException ioe) {
System.out.println("terminal controlado: desconectar");
}
} captura (IOException ioe) {
System.out.println("Error de conexión");
} finalmente {
si (zócalo! = nulo) {
intentar {
socket.cerrar();
} captura (IOException e) {
}
}
}
}
}
}
Enviar información del ratón:
Copie el código de código de la siguiente manera:/*
* Clase de herramienta: obtenga información del mouse y envíela al terminal del estudiante
*/
la clase pública SendMouseMessage extiende Thread{
privado int OPERATE_PORT = 8001;
servidor privado ServerSocket;
toma de corriente privada;
cadena privada operarStr;
principal vacío estático público (String [] argumentos)
{
nuevo SendMouseMessage().start();
}
público EnviarMouseMessage(){
intentar {
servidor = nuevo ServerSocket(OPERATE_PORT);
//JOptionPane.showMessageDialog(null, "ha comenzado a escuchar");
} captura (IOException e1) {
e1.printStackTrace();
}
}
//Múltiples subprocesos monitorean al cliente en un bucle inalámbrico
ejecución pública vacía()
{
mientras (verdadero) {
Punto punto = MouseInfo.getPointerInfo().getLocation();
operarStr = "Movemouse,"+point.x+","+point.y;
intentar {
socket = servidor.aceptar();
socket.setSoTimeout(1000000);
Salida de DataOutputStream =new DataOutputStream(socket.getOutputStream());
salida.write(operateStr.getBytes());
output.flush(); // Vacía el flujo de salida y escribe todos los bytes de salida almacenados en el búfer.
output.close(); //Cerrar el flujo de salida y liberar recursos
System.out.println("INFO: "+operateStr);
} captura (IOException e) {
System.out.println("La conexión se ha detenido");
break; //Detiene el bucle inalámbrico al desconectar
}
}
}
}
Cliente:
Programa principal:
Copie el código de la siguiente manera: import java.util.concurrent.ExecutorService;
importar java.util.concurrent.Executors;
importar com.Tool.OperateMouse;
importar com.Tool.ReceiveImages;
clase pública RecibirBroderCast {
ejecutor públicoExecutorService;
Cadena estática pública IP="202.216.60.9";
principal vacío estático público (String [] argumentos)
{
nuevo RecibirBroderCast(IP);
}
RecibirBroderCast público (IP de cadena) {
ejecutor = Ejecutores.newFixedThreadPool(2);
ejecutor.execute (nuevas recibir imágenes (IP));
ejecutor.execute(nuevo OperateMouse(IP));
}
}
Recibir código de captura de pantalla:
Copie el código de código de la siguiente manera:/*
* julio 2014-11-20
* Esta clase se utiliza para recibir información de pantalla desde el lado del profesor, excluyendo el mouse.
* Usar conector()
*/
clase pública RecibirImages extiende Thread{
marco público BorderInit;
toma de corriente pública;
IP de cadena pública;
principal vacío estático público (String [] argumentos) {
nueva RecibirImagenes("202.216.60.7").start();
}
publicReceiveImages (IP de cadena)
{
marco=nuevo BorderInit();
esta.IP=IP;
}
ejecución pública vacía() {
mientras(frame.getFlag()){
System.out.println("Conectado"+(System.currentTimeMillis()/1000)%24%60+"segundos");
intentar {
conector = nuevo conector (IP, 8002);
DataInputStream ImgInput = nuevo DataInputStream(socket.getInputStream());
ZipInputStream imgZip = nuevo ZipInputStream(ImgInput);
Imagen img = nula;
intentar{
imgZip.getNextEntry(); //Ir al principio de la secuencia del archivo Zip
img = ImageIO.read(imgZip); //Lee las imágenes en el flujo de imágenes Zip según los bytes
frame.jlbImg.setIcon(nuevo ImageIcon(img));
marco.validar();
}catch (IOException e) {e.printStackTrace();}
intentar{
imgZip.close();
} captura (IOException e) {
System.out.println("Conexión desconectada");
}
intentar {
TimeUnit.MILLISECONDS.sleep(50);//Intervalo de tiempo para recibir imágenes
} catch (Excepción interrumpida, es decir) {
es decir, printStackTrace();
}
} captura (IOException e) {
e.printStackTrace();
}finalmente{
intentar {
socket.cerrar();
} captura (IOException e) {}
}
}
}
}
clase BorderInit extiende JFrame
{
serialVersionUID largo final estático privado = 1L;
público JLabel jlbImg;
bandera booleana privada;
getFlag público booleano(){
devolver esta.bandera;
}
publicBorderInit()
{
this.flag=verdadero;
this.jlbImg = nuevo JLabel();
this.setTitle("Monitoreo remoto--IP:" + "--Tema:");
this.setSize(400, 400);
//this.setUndecorated(true);
//this.setAlwaysOnTop(true); //Siempre arriba
this.add(jlbImg);
this.setLocationRelativeTo(nulo);
this.setExtendedState(Frame.MAXIMIZED_BOTH);
this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
this.setVisible(verdadero);
this.validar();
//evento de cierre de ventana
this.addWindowListener(nuevo WindowAdapter() {
ventana vacía públicaClosing(WindowEvent e) {
bandera = falso;
BorderInit.this.dispose();
System.out.println("Formulario cerrado");
System.gc(); //recolección de basura
}
});
}
}
Reciba información del mouse y controle el movimiento del mouse:
Copie el código de la siguiente manera: import java.awt.AWTException;
importar java.awt.Robot;
importar java.io.BufferedInputStream;
importar java.io.BufferedReader;
importar java.io.DataInputStream;
importar java.io.IOException;
importar java.io.InputStream;
importar java.net.Socket;
importar javax.swing.JOptionPane;
/*
* El control del mouse en el lado del estudiante es el mismo que en el lado del profesor.
* Esta clase es responsable de recibir información del mouse y controlar el movimiento del mouse usando la función robot.mouseMove()
*/
La clase pública OperateMouse extiende Thread{
principal vacío estático público (String [] argumentos)
{
nuevo OperateMouse("202.116.60.7").start();
}
toma de corriente privada;
IP de cadena pública;
privado int OPERATE_PORT = 8001;
robot privado;
OperateMouse público (IP de cadena)
{
esta.IP = IP;
}
ejecución pública vacía() {
mientras (verdadero) {
intentar {
socket = nuevo Socket(IP,OPERATE_PORT);
robot = nuevo robot();
//Obtener información del movimiento del mouse
DataInputStream dataIn = nuevo DataInputStream(socket.getInputStream());
Cadena de información="";
int r;
mientras((r=dataIn.read()) != -1){
info +=""+(char)r; //Convierte todos los elementos de la matriz de bytes al tipo de carácter
}
datosIn.close();
System.out.println("Flujo de datos desconectado"+info);
si(información!=nulo){
Cadena s[] = info.trim().split(",");
if("Movemouse".equals(s[0].trim()));
{
si (s. longitud == 3) {
int x = Integer.parseInt(s[1].trim());
int y = Integer.parseInt(s[2].trim());
System.out.println("Salida de información del mouse"+x+" "+ y);
robot.mouseMove(x, y);
}
}
}
} captura (IOException e) {
System.out.println("Desconectado");
romper;
} captura (AWTException e) {
e.printStackTrace();
}
}
}
}
Espero que este artículo sea útil para la programación Java de todos.