Discussion :

[elmaestro]

Bonjour,

Je voudrais tester le fonctionnement des Sockets et pour cela je souhaiterais mettre en oeuvre un Activity Android Client qui appelle un Activity Serveur via un Socket.

Est-il possible dans Eclipse de démarrer simultanément 2 Activity Android qui tournent donc dans des process séparés et donc des Thread séparés ?

Merci d'avance pour vos lumières.

[nicroman]

Oui et Non....

Il ne faut pas confondre activité, application et thread....

Un "Activité" est une fenêtre de ton application. Tu ne peux pas avoir deux fenêtres en même temps.
Pour ce qui est de l'application, les applications en "arriere-plan" peuvent être fermées par Android à tout moment.

Par contre, il y a deux choses possibles:
* Démarrer deux thread dans ton activité, et ainsi tester dans la même application (et la même activité).
* Avoir deux applications, et dans ce cas passer par les "services" (ce sont des contexts android sans interface) pour générer les threads.

[elmaestro]

....Il ne faut pas confondre activité, application et thread....

Je te suis nicroman, il faut être précis sur ces sujets pointus.

En fait, je voudrais pouvoir disposer d'un environnement de développement qui me permette de tester facilement l'appli client (à installer sur Tablet S) et l'appli serveur (à installer sur Xroid).

Il s'agit principalement, dans un premier temps, de tester la communication entre les 2 dispositifs, et je pars à priori sur les Sockets :

• L'appli client possedera une activité qui devra démarrer un nouveaux thread pour implémenter le socket.
• L'appli serveur possedera une activité ou un service qui devra démarrer un nouveau thread pour implémenter le socket.

Pour l'instant, j'ai monté un proof of concept basé sur une seule application possédant une seule activité. Cette dernière gère 2 classes, une pour le new thread client, une autre pour le new thread serveur. Sauf que tout cela ne reflètera pas bien la réalité car l'ensemble tourne dans le même processus...me trompes-je, nicroman ?

Raison pour laquelle je cogite sur une autre stratégie et je pense à :

1. Créer 2 applications distinctes (je suppose 2 projets Eclipse) et les lancer simultanément,
2. ou bien monter un autre environnement Eclipse dans une VM (ex : Oracle VM VirtualBox), mais là ça devient un peut compliqué...

Quoi qu'il en soit, voici le code du proof of concept qui me permet de comprendre comment fonctionnent les sockets :

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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
package com.tuto.android;
 
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.util.Enumeration;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;
 
public class ClientActivity extends Activity implements OnClickListener {
 
    // Mes variables globales
    public static final int SERVER_PORT = 8080;
    public String SERVER_IP;
    private TextView _serverStatus;
    private Button _connectPhones;
    private Button _disconnectPhones;
    private boolean _isConnected = false;
    private Handler _handler = new Handler();
    private ServerSocket _serverSocket;
    private Socket _socket;
 
    // Initialisation de l'activité
    @Override
    protected void onCreate(Bundle savedInstanceState) {
 
	Thread _serverThread;
 
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
 
        _serverStatus = (TextView) findViewById(R.id.server_status);
 
        _disconnectPhones = (Button) findViewById(R.id.disconnect_phones);
        _disconnectPhones.setOnClickListener(this);
 
        _connectPhones = (Button) findViewById(R.id.connect_phones);
        _connectPhones.setOnClickListener(this);
 
        SERVER_IP = getLocalIpAddress();
 
        _serverThread = new Thread(new CServerThread());
        _serverThread.start();
 
    }
 
    // Destruction de l'activité
    @Override
    protected void onStop() {
 
        super.onStop();
 
        try {
 
             _serverSocket.close();
 
         } catch (IOException e) {
			e.printStackTrace();
         }
 
    }
 
    // Le gestionnaire d’évènement des boutons de l'IHM
    @Override
    public void onClick(View v) {
 
    	Thread _secondThread; 
 
		switch(v.getId())
	    {
 
	    	case R.id.connect_phones :
 
				if (!_isConnected) {
					_secondThread = new Thread(new CClientThread());
					_secondThread.start();
				}
				break;
 
	    	case R.id.disconnect_phones :
 
				try {
					_serverSocket.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
 
				try {
					_socket.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
				break;
	    }
 
    }
 
    // La classe qui simule le Thread client
    public class CClientThread implements Runnable {
 
        public void run() {
 
        	PrintWriter _out;
        	InetAddress _serverAddr;
 
            try {
 
                _serverAddr = InetAddress.getByName(SERVER_IP);
                _socket = new Socket(_serverAddr, SERVER_PORT);
                _isConnected = true;
 
                while (_isConnected) {
 
                    try {
 
                    	_out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(_socket.getOutputStream())), true);
                        _out.println("Message qui va dans le scket !");
 
                    } catch (Exception e) {
						e.printStackTrace();
                    }
                }
 
                _socket.close();
 
                _mycount+=1;
 
            } catch (Exception e) {
				e.printStackTrace();
                _isConnected = false;
            }
        }
    }
 
    // La classe qui simule le Thread serveur
    public class CServerThread implements Runnable {
 
        public void run() {
 
            try {
 
                if (SERVER_IP != null) {
 
                    _handler.post(new Runnable() {
 
                        @Override
                        public void run() {
                            _serverStatus.setText("Listening on IP: " + SERVER_IP);
                        }
 
                    });
 
                    _serverSocket = new ServerSocket(SERVER_PORT);
 
                    while (true) {
 
                        Socket _client = _serverSocket.accept();
 
                        _handler.post(new Runnable() {
 
                            @Override
                            public void run() {
                                _serverStatus.setText("Connected.");
                            }
 
                        });
 
                        try {
 
                            BufferedReader in = new BufferedReader(new InputStreamReader(_client.getInputStream()));
                            String line = null;
 
                            while ((line = in.readLine()) != null) {
 
                                Log.d("ServerActivity", line);
 
                                _handler.post(new Runnable() {
 
                                    @Override
                                    public void run() {
										// do whatever you want to the front end
                                        // this is where you can be creative
                                    	_serverStatus.setText("AKECOUCOU!");
                                    }
 
                                });
 
                            }
 
                            break;
 
                        } catch (Exception e) {
 
                            _handler.post(new Runnable() {
 
                                @Override
                                public void run() {
                                    _serverStatus.setText("Oops. Connection interrupted. Please reconnect your phones.");
                                }
 
                            });
 
                            e.printStackTrace();
                        }
                    }
 
                } else {
 
                    _handler.post(new Runnable() {
 
                        @Override
                        public void run() {
                            _serverStatus.setText("Couldn't detect internet connection.");
                        }
 
                    });
 
                }
 
            } catch (Exception e) {
 
                _handler.post(new Runnable() {
 
                    @Override
                    public void run() {
                        _serverStatus.setText("Error");
                    }
 
                });
 
                e.printStackTrace();
 
            }
        }
 
    }
 
    // Méthode privée qui détermine l'adresse IP du serveur (J'ai pas tout capté encore !)
    private String getLocalIpAddress() {
 
    	NetworkInterface _intf;
    	InetAddress _inetAddress;
 
        try {
 
            for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements();) {
 
                _intf = en.nextElement();
 
                for (Enumeration<InetAddress> enumIpAddr = _intf.getInetAddresses(); enumIpAddr.hasMoreElements();) {
 
                    _inetAddress = enumIpAddr.nextElement();
 
                    if (!_inetAddress.isLoopbackAddress()) {
                    	return _inetAddress.getHostAddress().toString(); 
                    }
                }
            }
 
        } catch (SocketException ex) {
		e.printStackTrace();
        }
 
        return null;
 
    }
 
}

La suite au prochain épisode

[nicroman]

En fait tu peux utiliser les services pour etre sur que ton application ne sera pas "supprimée" parcequ'en arriere plan trop longtemps....

L'interface ne servant qu'à appeler les services pour démarrer / arreter le thread "serveur"

Ensuite le client, à priori, est plus "lâche" dans sa gestion de l'avant-plan arriere-plan...