¿Cómo capturar la pantalla seleccionada de otra aplicación usando java?

Question

Estamos tratando de desarrollar una utilidad de captura de pantalla.

¿Cómo capturamos la pantalla seleccionada de otra aplicación usando Java? ¿Y cómo agregamos una llamada a la pantalla capturada?

Answer 1

Deberá proporcionar más información específica para recibir ayuda. Para empezar, ¿en qué sistemas operativos se debe trabajar? ¿Necesita capturar el contenido de ventanas individuales o pantallas enteras completas (utilizó el término ambiguo "pantalla seleccionada de otra aplicación" en su publicación original). ¿Qué desea ver específicamente cuando "agrega texto destacado a la pantalla capturada"?

Answer 2

Tal vez la clase java.awt.Robot ayudaría con las capturas de pantalla, aunque no creo que sea capaz de localizar ventanas individuales. En cuanto a estas "llamadas", la clase Robot también puede invocar clics del mouse y presionar teclas, si eso es lo que quiere decir.

Answer 3

Si desea tomar una captura de pantalla de una ventana específica de otro código de aplicación que no es Java, creo que tendrá que escribir algún código nativo (es decir, no Java). La interacción entre aplicaciones Java y aplicaciones que no son Java a ese nivel es difícil.

Answer 4

Robot r = new Robot(); 
Toolkit t = Toolkit.getDefaultToolkit(); 
Dimension d = t.getScreenSize(); 
Image i = r.createScreenCapture(0, 0, d.width, d.height); 

debe obtener una imagen completa de la pantalla completa. no estoy seguro de si eso le da todo si tiene múltiples monitores, aunque ...

Answer 5

Basado en Prajakta's description of the project, creo que es necesaria alguna explicación para manipular una captura de pantalla (creo que John hizo un excelente trabajo al explicar how to capture the screen shot using the java.awt.Robot class) Recuerde, como Steve McLeod said, es posible que Java no pueda ubicar automáticamente la ubicación de la ventana que desea capturar en la pantalla. Esto es importante, porque la clase Robot necesita conocer esta ubicación, ya sea automática o manualmente.

Llamadas, texto, imágenes, etc. se pueden agregar a la captura de pantalla mediante el objeto Graphics2D que recibe cuando llama al método createGraphics() de la captura de pantalla BufferedImage. Le recomiendo que consulte the Graphics2D's API para comprender mejor de lo que es capaz. También recomiendo encontrar algunos tutoriales, quizás comenzando con el the 2D Graphics Tutorial from Sun. El libro titulado "Filthy Rich Clients" también puede ser útil.

Cuando finalmente quiera guardar esta captura de pantalla modificada, puede usar uno de los métodos de "escritura" de la clase ImageIO.

Aquí hay un ejemplo muy simple y de principio a fin. Depende de usted completar los detalles necesarios.

Espero que esto ayude un poco!

Robot robot = new Robot(); 

// The hard part is knowing WHERE to capture the screen shot from 
BufferedImage screenShot = robot.createScreenCapture(x, y, width, height); 
Graphics2D graphics = screenShot.createGraphics(); 

// Add a label to the screen shot 
Color textColor = Color.RED; 
graphics.setColor(textColor); 
graphics.drawString("Some text", textX, textY); 

// Save your screen shot with its label 
ImageIO.save(screenShot, "png", new File("myScreenShot.png")); 

Answer 6

Probablemente se puede solucionar la falta de capacidad del robot para conocer los bordes de la ventana, permitiendo al usuario seleccionar el área que quiere imagen de las cámaras.

Tiene dos enfoques, si la opción es a pantalla completa no necesita preocuparse, siga el enfoque de Robot descrito anteriormente.

Si el Applicatin es para el área deseada:

1. Start desea el uso.

2. Tome una pantalla completa del escritorio.

3. Cree una aplicación a pantalla completa usando la captura de pantalla como fondo, SOLAMENTE para permitir al usuario seleccionar el área donde capturar la imagen (comienza con un cuadrado pequeño y deja que el usuario arrastre hasta que cree la captura de pantalla deseada)

4. Pase esta información a Robot y tome las capturas de pantalla de esa área.

Algo como esto:

alt text http://img136.imageshack.us/img136/8622/screencapturebb3.png

Si no te gusta la opción de usar una captura de pantalla completa como fondo, se puede utilizar un transparent window.

y hacer lo mismo: -)

segunda opción Aaahhh es tratar de identificar las fronteras, de las imágenes, pero sinceramente, no creo que valga la pena.

Hay una tercera opción, pero es un secreto.

Código

Answer 7

para la captura de pantalla en Java,

http://www.codinguide.com/2010/04/capture-screen-shot-from-java.html

Answer 8

Con este código que podría hacer pantallas de ciertas ventanas en Windows 10, no te olvides de la dependencia.

Los créditos van a: Windows: how to get a list of all visible windows?

<dependency> 
    <groupId>net.java.dev.jna</groupId> 
    <artifactId>jna</artifactId> 
    <version>4.5.0</version> 
</dependency> 

Código:

import java.awt.AWTException; 
import java.awt.Rectangle; 
import java.awt.Robot; 
import java.awt.image.BufferedImage; 
import java.io.File; 
import java.io.IOException; 
import java.util.ArrayList; 
import java.util.Collections; 
import java.util.Comparator; 
import java.util.List; 

import javax.imageio.ImageIO; 

import com.sun.jna.Native; 
import com.sun.jna.Structure; 
import com.sun.jna.win32.StdCallLibrary; 

public class Main { 
    public static void main(String[] args) throws AWTException, IOException { 

     int hWnd = User32.instance.FindWindowA(null, "Minesweeper X"); 
     WindowInfo w = getWindowInfo(hWnd); 
     User32.instance.SetForegroundWindow(w.hwnd); 
     BufferedImage createScreenCapture = new Robot().createScreenCapture(new Rectangle(w.rect.left, w.rect.top, w.rect.right - w.rect.left, w.rect.bottom - w.rect.top)); 
     ImageIO.write(createScreenCapture, "png", new File("screen.png")); 

     // listAllWindows(); 
    } 

    private static void listAllWindows() throws AWTException, IOException { 
     final List<WindowInfo> inflList = new ArrayList<WindowInfo>(); 
     final List<Integer> order = new ArrayList<Integer>(); 
     int top = User32.instance.GetTopWindow(0); 
     while (top != 0) { 
      order.add(top); 
      top = User32.instance.GetWindow(top, User32.GW_HWNDNEXT); 
     } 

     User32.instance.EnumWindows(new WndEnumProc() { 
      public boolean callback(int hWnd, int lParam) { 
       WindowInfo info = getWindowInfo(hWnd); 
       inflList.add(info); 
       return true; 
      } 

     }, 0); 
     Collections.sort(inflList, new Comparator<WindowInfo>() { 
      public int compare(WindowInfo o1, WindowInfo o2) { 
       return order.indexOf(o1.hwnd) - order.indexOf(o2.hwnd); 
      } 
     }); 
     for (WindowInfo w : inflList) { 
      System.out.println(w); 
     } 
    } 

    public static WindowInfo getWindowInfo(int hWnd) { 
     RECT r = new RECT(); 
     User32.instance.GetWindowRect(hWnd, r); 
     byte[] buffer = new byte[1024]; 
     User32.instance.GetWindowTextA(hWnd, buffer, buffer.length); 
     String title = Native.toString(buffer); 
     WindowInfo info = new WindowInfo(hWnd, r, title); 
     return info; 
    } 

    public static interface WndEnumProc extends StdCallLibrary.StdCallCallback { 
     boolean callback(int hWnd, int lParam); 
    } 

    public static interface User32 extends StdCallLibrary { 
     public static final String SHELL_TRAY_WND = "Shell_TrayWnd"; 
     public static final int WM_COMMAND = 0x111; 
     public static final int MIN_ALL = 0x1a3; 
     public static final int MIN_ALL_UNDO = 0x1a0; 

     final User32 instance = (User32) Native.loadLibrary("user32", User32.class); 

     boolean EnumWindows(WndEnumProc wndenumproc, int lParam); 

     boolean IsWindowVisible(int hWnd); 

     int GetWindowRect(int hWnd, RECT r); 

     void GetWindowTextA(int hWnd, byte[] buffer, int buflen); 

     int GetTopWindow(int hWnd); 

     int GetWindow(int hWnd, int flag); 

     boolean ShowWindow(int hWnd); 

     boolean BringWindowToTop(int hWnd); 

     int GetActiveWindow(); 

     boolean SetForegroundWindow(int hWnd); 

     int FindWindowA(String winClass, String title); 

     long SendMessageA(int hWnd, int msg, int num1, int num2); 

     final int GW_HWNDNEXT = 2; 
    } 

    public static class RECT extends Structure { 
     public int left, top, right, bottom; 

     @Override 
     protected List<String> getFieldOrder() { 
      List<String> order = new ArrayList<>(); 
      order.add("left"); 
      order.add("top"); 
      order.add("right"); 
      order.add("bottom"); 
      return order; 
     } 
    } 

    public static class WindowInfo { 
     int hwnd; 
     RECT rect; 
     String title; 

     public WindowInfo(int hwnd, RECT rect, String title) { 
      this.hwnd = hwnd; 
      this.rect = rect; 
      this.title = title; 
     } 

     public String toString() { 
      return String.format("(%d,%d)-(%d,%d) : \"%s\"", rect.left, rect.top, rect.right, rect.bottom, title); 
     } 
    } 
}