# Bild über Socket schicken - Client/Server



## Ghorki (20. Mrz 2012)

Hallo Leute,

ich möchte mich in der Netzwerkprogrammierung ein bisschen weiterbilden.
Mein Ziel ist es ein kleines Tool zu schreiben, dass die funktionsweiße des Teamviewer hat.

Der Server macht einen Screenshot vom Desktop und soll diese über den Socket an den Client schicken. 
Momentan sieht meine Methode auf dem Server so aus:


```
public void screenshotErstellenUndVerschicken(BufferedImage imgage) {   
     try {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();	
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();	
        Rectangle screenRectangle = new Rectangle(screenSize); 			
        Robot robot = new Robot();
        imgage=robot.createScreenCapture(new Rectangle(screenRectangle));
        ImageIO.write(imgage,"png",byteArrayOutputStream);			
     } catch (Exception e) {
        e.printStackTrace();
     }
}
```

Mein Problem liegt darin, dass ich nicht genau weiß 
(habe schon vieles versucht, aber bisher ohne Erfolg), :rtfm:
wie ich das Bild auf dem Client wiederherstellen und abspeichern kann.

Leider hat mir Google bisher nicht weitergeholfen.
Ich hoffe ihr könnt mir weiterhelfen. :toll:

Viele Grüße
Ghorki


----------



## annonymous (20. Mrz 2012)

Hallo,
wenn ich dich richtig verstanden habe, versuchst du einen SocketServer zu programmieren.
Anbei ein kleines Beispiel:

Server:

```
public class SocketServer{
    public static void main(String[] args) throws Exception {
	ServerSocket serverSocket = new ServerSocket(10000);

	while (true) {
	    Socket socket = serverSocket.accept();
	    System.out.println("Connection established with " + socket);
	    ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
	    Object object = ois.readObject();
        MyObject myObject = (MyObject) object;
            // Bild uebertragen
        }
    }
}
```

Client:

```
public class Client {
    public static void main(String[] args) throws Exception{
        Socket socket = new Socket("localhost", 10000);
        ObjectOutputStream os = new ObjectOutputStream(socket.getOutputStream());
	    os.writeObject(myObject);
	    socket.close();
    }
```


----------



## Ghorki (20. Mrz 2012)

Die Verbindung zwischen Server und Client steht ja schon, 
es geht mir ausschließlich nur darum, 
das ByteArray auf dem Client wieder in ein png zu wandeln und abzuspeichern.


----------



## SlaterB (20. Mrz 2012)

es gab kürzlich mindestens zwei Themen dazu, da ist vielleicht was für dich dabei:
http://www.java-forum.org/netzwerkprogrammierung/132733-senden-abspeichern.html
http://www.java-forum.org/netzwerkp...ons-beim-ubertragen-bildern-ueber-socket.html
(edit: ok, vielleicht nur der zweite)


----------



## annonymous (20. Mrz 2012)

Hallo,

ich konnte meine Lösung gerade nicht ausprobieren, aber theoretisch sollte das so funktionieren:


```
public class NewClass {
    public static void main(String[] args) throws Exception{
        byte[] bytes = new byte[]{};
        ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
        ImageInputStream iis = ImageIO.createImageInputStream(bis);
        
        Iterator itr = ImageIO.getImageReadersByFormatName("png");
        ImageReader imageReader = (ImageReader) itr.next();        
        imageReader.setInput(iis);
 
        Image image = imageReader.read(0);
        BufferedImage bufferedImage = new BufferedImage(image.getWidth(null), image.getHeight(null), BufferedImage.TYPE_INT_RGB);
        ImageIO.write(bufferedImage, "png", new File("C:\\newImage.png"));
    }
}
```

PS: Würdest du den ObjectStream anstelle des ByteArrayStreams verwenden, solltest du auf der Gegenseite das Bild einfach wieder in BufferedImage casten können und speicherst es, indem du die folgende Zeile verwendest:


```
ImageIO.write(bufferedImage, "png", new File("C:\\newImage.png"));
```


----------



## Ghorki (20. Mrz 2012)

Mein Programm wirft eine Exception:
javax.imageio.IIOException: I/O error reading PNG header!

Und auf meinem Bildschirm bekomme ich folgende Mitteilung von meinem Server:
Directupload.net - Dch4gxrwr.jpg
(Sieht aus wie eine Serialisierte Datei?)


----------



## annonymous (20. Mrz 2012)

vielleicht noch einfacherer ist, den ByteArrayInputStream in ImageIO.read packen ...
Wenn du das lokal testest geht es ...  es scheint so, als wenn deine generierter dann nicht den korrekten png Header besitzt.



```
BufferedImage bufferedImage = ImageIO.read(new FileInputStream("c:\\Temp\\Screen.PNG"));
        ImageIO.write(bufferedImage, "png", new File("c:\\Temp\\newImage.png"));
```


----------



## annonymous (20. Mrz 2012)

Ich habe das ganze nachgestellt, folgender Code funktioniert auf jeden Fall ohne Socket.
Ist es möglich, das du die Bytes nicht vollständig oder verändert über die Leitung schickst?!


```
public static void main(String[] args) throws Exception{        
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize(); 
        BufferedImage screenshot = new Robot().createScreenCapture(new Rectangle(screenSize));
        ImageIO.write(screenshot,"png",new File("c:\\Temp\\myScreen.png"));
        
        BufferedImage bufferedImage = ImageIO.read(new FileInputStream("c:\\Temp\\myScreen.png"));
        ImageIO.write(bufferedImage, "png", new File("c:\\Temp\\newImage.png"));
    }
```


----------



## Ghorki (20. Mrz 2012)

Ich glaube ich bin gerade ein wenig durcheinander gekommen (noch schlimmer als vorher ;( ).
Jedenfalls hab ich die Exception wegbekommen:
Die Übertragung vom Server auf den Client sollte doch so funktionieren oder?

Server:


```
public void screenshotErstellen(){   
     try {
          ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
          Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();    
          BufferedImage screenshot = new Robot().createScreenCapture(new Rectangle(screenSize));
          Rectangle screenRectangle = new Rectangle(screenSize); 	
          Robot robot = new Robot();
          screenshot = robot.createScreenCapture(new Rectangle(screenRectangle));
          ImageIO.write(screenshot,"png",oos);			
     } catch (Exception e) {
          e.printStackTrace();
     }
}
```

Client:


```
public class ErwarteScreenShotVomServer_Thread implements Runnable {
     public void run() {
          try {
               while(true){
                     // 
               }
          } catch (Exception e) {
               e.printStackTrace();  
          }
}
```


** Jedenfalls speichert er auf der ServerSeite das Bild ab, nur soll das ganze auf der ClientSeite gespeichert werden.
ImageIO.write(screenshot, "png", new File("d:\\*\\Desktop\\tool\\newImage.png"));

** Ich habe ja schon eine Verbindung vom Client --> Server, um Nachrichten zu verschicken.
Kann es sein das ich da iwie in eine Komplikation mit dem Socket komme?


----------



## annonymous (21. Mrz 2012)

Hallo,

dann solltest du auf dem Server den Screenshot machen und auf den OutputStream legen, so dass der Client die Daten an seinem InputStream lesen kann.
Alternativ kann der Client gezielt eine Anfrage nach einem Screenshot stellen und der Server sendet diesen zurück.

Vielleicht hilft dir der Link weiter: http://www.digilife.be/quickreferences/pt/java%20sockets.pdf

Der Client-Code wäre alternativ auch nicht schlecht, dann kann man das durchaus mal ausprobieren ...


----------



## JohannisderKaeufer (26. Mrz 2012)

Ich persönlich würde folgendes machen.

Zuerst würde ich das erstellen des Screenshots in einer Klasse zusammenfassen, das mir Screenshots als byte[] zurückliefert.


```
import java.awt.AWTException;
import java.awt.Dimension;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import javax.imageio.ImageIO;

/** Hilfsklasse zum erstellen von Screenshots */
public class Screenshottool {
	/** @return Bild als png in Form eines byte[] */
	public static byte[] getScreenshot() {
		Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
		try {
			BufferedImage image = new Robot().createScreenCapture(new Rectangle(screenSize));
			ByteArrayOutputStream bos = new ByteArrayOutputStream();
			ImageIO.write(image, "png", bos);

			return bos.toByteArray();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (AWTException e) {
			e.printStackTrace();
		}
		return null;
	}
}
```

Als nächstes würde ich, wenn es möglich ist einfach Messages schicken. Das hat zwar mehr Overhead als die bytes direkt zu schicken, finde ich aber um einiges wartbarer, nachvollziehbarer.


```
import java.io.Serializable;

public class ImageMessage implements Serializable {

	private byte[] image;

	public ImageMessage() {
	}

	public ImageMessage(byte[] image) {
		super();
		this.image = image;
	}

	public byte[] getImage() {
		return image;
	}

	public void setImage(byte[] image) {
		this.image = image;
	}
}
```

Wenn der Server die Screenshots bei sich auf dem Rechner machen soll, dann kann das so aussehen

```
private void sendScreenshotToAllClients(){
	byte[] data = Screenshottool.getScreenshot();
	ImageMessage message = new ImageMessage(data);
	for(Client c: clients){
		ObjectOutputStream out = c.getObjectOutputStream();
		sendScreenshot(message, out);
	}
}

private void sendScreenshot(ImageMessage message, ObjectOutputStream out){
	try{
		out.writeObject(message);
		out.flush();
	} catch (IOException e) {
		e.printStackTrace();
	}
}
```

Und auf dem Client kann man dann einen Thread laufen lassen, der die Nachrichten entgegennimmt.

```
@Override
public void run() {
	try {
		ObjectInputStream stream = new ObjectInputStream(socket.getInputStream());
		Message message = null;
		while ((message = (Message) stream.readObject()) != null) {
			if(message instanceof ImageMessage){
				processImageMessage((ImageMessage) message);
			}
		}
	} catch (IOException e) {
		e.printStackTrace();
	} catch (ClassNotFoundException e) {
		e.printStackTrace();
	}
}

private void processImageMessage(ImageMessage message){
	//Add Image to gui
	ImageIcon icon = new ImageIcon(message.getImage());
	gui.add(new JLabel(icon));
	//Save image timestamp.png
	FileOutputStream fos;
	try {
			fos = new FileOutputStream(System.currentTimeMillis()+".png");
			fos.write(message.getImage());
	} catch (FileNotFoundException e) {
		e.printStackTrace();
	} catch (IOException e) {
		e.printStackTrace();
	}
}
```


----------

