[Socket][File] Envoyer un tableau de byte

Version imprimable

06/05/2004, 13h03
itsmii

[Socket][File] Envoyer un tableau de byte

Bonjour,
y a pas un moyen pour communiquer un fichier d'une taille importante via une socket en mode connecté? sinon un tableau de byte?

en fait je veux bien que mon client lit le maximum possible de ce fichier l'ecrire dans la socket directement et bloque la lecture jusqu' à ce que le serveur ait lu les données??

Merci
06/05/2004, 15h53
bulbo

Ce que tu peux faire:

lire ton fichier avec un tableau de byte de taille XX

Tu ecris ce meme tableau sur la socket

A la fin du fichier tu fermes la socket.

Tu boucles sur la lecture de ta socket tant que le serveur ne ferme pas la socket et tu ecris les bytes recu dans un fichier ..

Ou est le probleme je ne comprends pas ?

Bulbo :?:
06/05/2004, 15h58
itsmii
est ce que je dois ecrire le tableau byte par byte dans la socket?

c'es tà dire :
un truc comme ça :
Code:

1 2 3 4 5 for(int i = 0; i<tableauDeByte.length;i++) { out.print(tableauDeByte.length) }
ou plus tot soumettre tout le tableau directement?
Si c'est possible de proceder directement, est ce que tu pe me dire comment lire et ecrire un tableau à la fois?
merci

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
InputStream fichier = new FileInputStream....
 
OutputStream socket = sock.getOutputStream....
 
byte tab[1024];
int read = 0;
while (fichier.available() != 0)
{
read = fichier.read(tab);
socket.write(tab, 0, read);
}

Voila c'est aussi simple que ca, il suffit de lire les APIs comme souvent ..

Bulbo :roll:

Citation:
Envoyé par bulbo
Code:

1 2 3 4 5 6 7 8 9 10 11 12 InputStream fichier = new FileInputStream.... OutputStream socket = sock.getOutputStream.... byte tab[1024]; int read = 0; while (fichier.available() != 0) { read = fichier.read(tab); socket.write(tab, 0, read); }
socket.write n'accepte pas un tableau de byte, et fichier.read n'ecrit pas dans un tableau de char :(

Voila c'est aussi simple que ca, il suffit de lire les APIs comme souvent ..

Bulbo :roll:

06/05/2004, 16h57
itsmii

il est à noté que j'utilise le protocole TCP IP,
06/05/2004, 17h00
bulbo

La doc de OutputStream:

Citation:

write(byte[] b, int off, int len)
Writes len bytes from the specified byte array starting at offset off to this output stream.

Et la doc de InputStream:

Citation:

read(byte[] b)
Reads some number of bytes from the input stream and stores them into the buffer array b.

Je ne sais pas pourquoi tu veux ecrire dans un tableau de char, un tableau de bytes fait aussi bien l'affaire le plus souvent ...

Le bout de code que je t'ai file ne concerne que l'emission mais pour la reception il suffit de lire tes donnees et d'ecrire le buffer dans un fichier ou n'importe ou ailleurs ..

Bulbo :roll:
06/05/2004, 17h08
itsmii

merci bulbo !!

ça ne marchait pas parceque j'utilisait un PrintWriter !!
29/01/2014, 11h55
Tofuw

Citation:

Envoyé par itsmii

merci bulbo !!

ça ne marchait pas parceque j'utilisait un PrintWriter !!

Bonjour,

J'ai un serveur qui envoi des données au format texte à un client.
L'envoi et la réception se font correctement.

Je souhaiterai maintenant faire la même chose avec des Bytes.
Apparemment, cela ne fonctionne pas de la même manière. Pourriez vous développer ce que vous disiez avec le "PrintWritter" s'il vous plait ?

Merci beaucoup ^^

Tofuw
29/01/2014, 12h07
thelvin

Citation:

Envoyé par Tofuw

Pourriez vous développer ce que vous disiez avec le "PrintWritter" s'il vous plait ?

Dix ans plus tard ça m'étonnerait.

Un PrintWriter sert à envoyer du texte et pas des octets arbitraires, c'est tout.
Pour envoyer des octets, il suffit d'utiliser juste le OutputStream tout simple, au lieu de s'embêter avec un PrintWriter.

Bonjour thelvin, merci pour votre réponse malgré les 10 ans de ce sujet :)

Voici mon code concernant l'envoi des données textes :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
public static final int SERVERPORT=42000;
	private boolean running=false;
	private OutputStream serverout;
	private OnMessageReceived messagelistener;
 
	/** LAUNCHING TCP SERVER **/
	public void run()
	{
		super.run();		
		running=true;
 
		try
		{
			System.out.println("SERVER : Connecting...");
 
			// Server socket creation
			ServerSocket serversocket=new ServerSocket(SERVERPORT);
			/* Client socket creation
			   accept() is listening for a client connexion */
			Socket clientsocket=serversocket.accept();
			System.out.println("SERVER : Receiving...");
 
			try
			{
				// Send message to client
				serverout=new PrintWriter(new BufferedWriter(new OutputStreamWriter(clientsocket.getOutputStream())),true);
				// Read client message
				BufferedReader in=new BufferedReader(new InputStreamReader(clientsocket.getInputStream()));
 
				while(running)
				{
					String message=in.readLine();
					if(message!=null && messagelistener!=null)
					{
						messagelistener.messageReceived(message);
					}
				}
			}
			catch(Exception e){ System.out.println("Can't send coordinates"); e.printStackTrace(); }
			finally
			{
				clientsocket.close();
				System.out.println("Server : Done");
			}
		}
		catch(Exception e)
		{
			System.out.println("SERVER : SERVER PORT "+SERVERPORT+" already in use");
		}
	}

Et voici comment je reçois ces données, côté client :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
	/** RUNNING CLIENT **/ 
	public void runClient()
	{
		running=true;
 
		try
		{
			InetAddress serverip=InetAddress.getByName(SERVERIP);
			Log.i("TCP CLIENT", "Client : Connecting...");
			// Creation of a socket to connect with the server
			Socket clientsocket=new Socket(serverip,SERVERPORT);			
			try
			{
				// Send message to server
				out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(clientsocket.getOutputStream())),true);
				// Receive message from server
				in=new BufferedReader(new InputStreamReader(clientsocket.getInputStream()));
				// LOOP : client is listening the server
				while(running)
				{
					servermessage=in.readLine();
					// Call messageReceived from MAINACTIVITY
					if(servermessage!=null && messagelistener!=null)
					{
						messagelistener.messageReceived(servermessage);
					}
					servermessage=null;
				}
				Log.i("SERVER MESSAGE","Server received message : '"+servermessage+"'");
			}
			catch(Exception e){ Log.i("TCP CLIENT", "Client : Connecting..."); }
			// The socket must be closed. It'll be impossible to reconnect it. We have to launch another one.
			finally{ clientsocket.close(); }
		}
		catch(Exception e){ Log.e("TCP","SERVER : Error",e); }
	}

Pour envoyer des octets arbitraires (depuis le SERVEUR), il faut donc que je remplace

Code:

private PrintWriter serverout

par

Code:

private OutputStream serverout

Or, quand je fais

Code:

1
2
// Send message to client
	serverout=new OutputStream(new BufferedWriter(new OutputStreamWriter(clientsocket.getOutputStream())));

, cela me dit "Cannot instantiate the type OutputStream.

Pourriez vous me guider s'il vous plait ?

Je vous remercie par avance pour votre aide !

29/01/2014, 14h31
thelvin
Citation:
Envoyé par Tofuw

Or, quand je fais

Code:

1 2 // Send message to client serverout=new OutputStream(new BufferedWriter(new OutputStreamWriter(clientsocket.getOutputStream())));

, cela me dit "Cannot instantiate the type OutputStream.

Pourriez vous me guider s'il vous plait ?
clientsocket.getOutputStream() te donne déjà le OutputStream dont tu as besoin.
À quoi ça sert d'en créer un nouveau, ou de mettre du BufferedWriter ou du OutputStreamWriter là-dedans ? Si tu veux échanger des octets, ne touche pas aux writers, dédiés aux textes.
Enlève tout ça et ça fonctionnera très bien :

Code:

serverout = clientsocket.getOutputStream();

Bien entendu c'est la même chose côté client : les Reader doivent être supprimés et il faut juste garder l'InputStream tout simple.

J'ai fait ce que vous venez de me conseiller. Mais un problème persiste du côté client :

CLIENT

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
public class TCPClient 
{
	private String servermessage;
	// Adresse IP de la machine a laquelle on veut se connecter
	public static final String SERVERIP="10.57.230.50";
	public static final int SERVERPORT=42;
	private OnMessageReceived messagelistener=null;
	private boolean running=false;
 
	PrintWriter out;
	InputStream in;
 
	/*
	 * CONSTRUCTEUR
	 * OnMessageReceived est a l'ecoute des messages du serveur		
	 */
	public TCPClient(OnMessageReceived listener)
	{
		messagelistener=listener;
	}
 
	// Envoi le message que le client a tape
	public void sendMessage(String message)
	{
		if(out!=null && !out.checkError())
		{
			out.println(message);
			out.flush();
		}
	}
 
	// On arrete le client
	public void stopClient()
	{
		running=false;
	}
 
	public void runClient()
	{
		running=true;
 
		try
		{
			InetAddress serverip=InetAddress.getByName(SERVERIP);
			Log.e("TCP CLIENT", "CLIENT : Connecting...");
			// Creation d'un socket pour faire la connection avec le serveur
			Socket clientsocket=new Socket(serverip, SERVERPORT);
 
			try
			{
				// On envoi le message au serveur
				out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(clientsocket.getOutputStream())),true);
 
				Log.e("TCP CLIENT", "CLIENT : Sent");
				Log.e("TCP CLIENT","CLIENT : Done");
 
				// Recevoir le message que le serveur a renvoye
				in=clientsocket.getInputStream();
 
				//BOUCLE : le client est a l'ecoute des messages envoyes par le serveur
				while(running)
				{
					servermessage=in.read();
 
					if(servermessage!=null && messagelistener!=null)
					{
						// On appelle la methode messageReceived de MAINACTIVITY
						messagelistener.messageReceived(servermessage);
					}
					servermessage=null;
				}
				Log.e("RESPONSE FROM SERVER", "SERVER : Received Message : '"+servermessage+"'");
			}
			catch(Exception e)
			{
				Log.e("TCP", "SERVER : Error", e);
			}
 
			finally
			{
				/*
				 * Le socket doit etre fermer
				 * Il sera impossible de s'y reconnecter. Il faudra en relancer un autre
				 */
				clientsocket.close();
			}		
		}
		catch(Exception e)
		{
			Log.e("TCP", "CLIENT : Error", e);
		}
	}
 
	// Declaration de l'interface OnMessageReceived
	// La methode messageReceived(String message) doit etre implementer dans MAINACTIVITY (dans asunckTask doInBackgroung)
	public interface OnMessageReceived
	{
		public void messageReceived(String message);
	}
}

SERVEUR

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
public class TCPServer extends Thread // =======> TO SERVERBOARD.JAVA
{
	// SERVERPORT IS A TCP/IP PORT
	public static final int SERVERPORT=42000;
	private boolean running=false;
	private OutputStream serverout;
	private OnMessageReceived messagelistener;
 
 
	/** CONSTRUCTOR **/
	public TCPServer(OnMessageReceived messagelistener)
	{
		this.messagelistener=messagelistener;
	}	
 
	/** LAUNCHING TCP SERVER **/
	public void run()
	{
		super.run();		
		running=true;
 
		try
		{
			System.out.println("SERVER : Connecting...");
 
			// Server socket creation
			ServerSocket serversocket=new ServerSocket(SERVERPORT);
			/* Client socket creation
			   accept() is listening for a client connexion */
			Socket clientsocket=serversocket.accept();
			System.out.println("SERVER : Receiving...");
 
			try
			{
				// Send message to client
				serverout=clientsocket.getOutputStream();
				// Read client message
				BufferedReader in=new BufferedReader(new InputStreamReader(clientsocket.getInputStream()));
 
				while(running)
				{
					String message=in.readLine();
					if(message!=null && messagelistener!=null)
					{
						messagelistener.messageReceived(message);
					}
				}
			}
			catch(Exception e){ System.out.println("Can't send coordinates"); e.printStackTrace(); }
			finally
			{
				clientsocket.close();
				System.out.println("Server : Done");
			}
		}
		catch(Exception e)
		{
			System.out.println("SERVER : SERVER PORT "+SERVERPORT+" already in use");
		}
	}
 
 
/*******************************************************
******************** METHODES ****************************/	
	// SEND MESSAGE TO CLIENT
	public void sendAudio(Byte mybyte)
	{
		try 
		{
			serverout.write(mybyte);
			serverout.flush();
		} 
		catch (IOException e) 
 
		{
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
 
	// Implemented on ServerBoard class
	public interface OnMessageReceived
	{
		public void messageReceived(String message);
	}
}

Du côté client, lorsque je fais

Citation:

servermessage=in.read();

j'ai l'erreur suivante : Type mismatch: cannot convert from int to String.

Pourriez vous m'expliquer quel est le problème s'il vous plait ?
Et pourriez vous me dire si les codes sont corrects ?

Je vous en remercie par avance.

29/01/2014, 17h09
thelvin

Citation:

Envoyé par Tofuw

Pourriez vous m'expliquer quel est le problème s'il vous plait ?

Tu ne peux pas lire une String alors que tu reçois du binaire.
Que doit-il arriver au binaire reçu ?
30/01/2014, 09h10
Tofuw

J'envoi un flux radio en fait. J'aimerai le lire sur le client, qui est un support Android.

Je vais revoir mon code selon vos suggestions ^^