Discussion :

[itsmii]

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

[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 :

[itsmii]

est ce que je dois ecrire le tableau byte par byte dans la socket?

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[bulbo]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[itsmii]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[itsmii]

il est à noté que j'utilise le protocole TCP IP,

[bulbo]

La doc de OutputStream:

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:

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

[itsmii]

merci bulbo !!

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

[Tofuw]

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

[thelvin]

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.

[Tofuw]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

private PrintWriter serverout

par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

private OutputStream serverout

Or, quand je fais

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 !

[thelvin]

Or, quand je fais

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Tofuw]

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

CLIENT

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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.

[thelvin]

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 ?

[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 ^^