Discussion :

[Invité]

Je me permets de reposter ce sujet, car je ne l'avais pas mis dans la bonne section à l'origine (Android). Ce n'est plus un problème spécifique Android comme je le croyais au début.

Je veux réaliser un mini serveur web qui ne fournit qu'un seul fichier, quelle que soit la requête.
J'ai à ma disposition tous les packages org.apache.http.*

Voilà ce que j'ai pour le moment :

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
 
        try
        {
            while (true)
            {
                Socket socket = this.serverSocket.accept();
                DefaultHttpServerConnection conn = new DefaultHttpServerConnection();
                conn.bind(socket, new BasicHttpParams());
                HttpResponse response = new BasicHttpResponse(new BasicStatusLine(HttpVersion.HTTP_1_1, HttpStatus.SC_OK, null));
                HttpEntity entity = new InputStreamEntity(this.application.getResources().openRawResource(R.raw.zip), 100000);
                response.setEntity(entity);
                conn.sendResponseEntity(response);
                conn.flush();
                conn.shutdown();
            }
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        catch (HttpException e)
        {
            e.printStackTrace();
        }

La méthode openRawResource() me retourne un InputStream, et c'est la seule manière dont je peux accéder à mon fichier.

Les problèmes que j'ai actuellement :
- Le serveur ne me répond que très aléatoirement
- Quand il veut bien me répondre, il ne me retourne que 1ko du fichier, alors qu'il fait au moins 10ko

Quelqu'un a une idée ?

Merci !

[Invité]

en fait j'ai adapté un exemple existant
http://svn.apache.org/repos/asf/http...ttpServer.java

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
 
package org.pierre.remotedroid.client.http;
 
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
 
import org.apache.http.HttpException;
import org.apache.http.HttpRequest;
import org.apache.http.HttpResponse;
import org.apache.http.entity.InputStreamEntity;
import org.apache.http.impl.DefaultConnectionReuseStrategy;
import org.apache.http.impl.DefaultHttpResponseFactory;
import org.apache.http.impl.DefaultHttpServerConnection;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.CoreConnectionPNames;
import org.apache.http.params.CoreProtocolPNames;
import org.apache.http.params.HttpParams;
import org.apache.http.protocol.BasicHttpContext;
import org.apache.http.protocol.BasicHttpProcessor;
import org.apache.http.protocol.HttpContext;
import org.apache.http.protocol.HttpRequestHandler;
import org.apache.http.protocol.HttpRequestHandlerRegistry;
import org.apache.http.protocol.HttpService;
import org.apache.http.protocol.ResponseConnControl;
import org.apache.http.protocol.ResponseContent;
import org.apache.http.protocol.ResponseDate;
import org.apache.http.protocol.ResponseServer;
import org.pierre.remotedroid.client.R;
import org.pierre.remotedroid.client.application.PRemoteDroidApp;
import org.pierre.remotedroid.protocol.PRemoteDroidConnection;
 
public class HttpServer implements Runnable, HttpRequestHandler
{
    private PRemoteDroidApp application;
 
    private ServerSocket serverSocket;
    private HttpService httpService;
    private HttpParams httpParams;
 
    public HttpServer(PRemoteDroidApp application) throws IOException
    {
        this.application = application;
        this.serverSocket = new ServerSocket(PRemoteDroidConnection.DEFAULT_PORT);
 
        BasicHttpProcessor httpproc = new BasicHttpProcessor();
        httpproc.addInterceptor(new ResponseDate());
        httpproc.addInterceptor(new ResponseServer());
        httpproc.addInterceptor(new ResponseContent());
        httpproc.addInterceptor(new ResponseConnControl());
 
        HttpRequestHandlerRegistry reqistry = new HttpRequestHandlerRegistry();
        reqistry.register("*", this);
 
        this.httpParams = new BasicHttpParams();
        this.httpParams.setIntParameter(CoreConnectionPNames.SO_TIMEOUT, 5000);
        this.httpParams.setIntParameter(CoreConnectionPNames.SOCKET_BUFFER_SIZE, 8 * 1024);
        this.httpParams.setBooleanParameter(CoreConnectionPNames.STALE_CONNECTION_CHECK, false);
        this.httpParams.setBooleanParameter(CoreConnectionPNames.TCP_NODELAY, true);
        this.httpParams.setParameter(CoreProtocolPNames.ORIGIN_SERVER, "HttpComponents/1.1");
 
        this.httpService = new HttpService(httpproc, new DefaultConnectionReuseStrategy(), new DefaultHttpResponseFactory());
        this.httpService.setParams(this.httpParams);
        this.httpService.setHandlerResolver(reqistry);
 
        (new Thread(this)).start();
    }
 
    public void run()
    {
        try
        {
            while (true)
            {
                Socket socket = this.serverSocket.accept();
                DefaultHttpServerConnection conn = new DefaultHttpServerConnection();
                conn.bind(socket, new BasicHttpParams());
                this.httpService.handleRequest(conn, new BasicHttpContext());
            }
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        catch (HttpException e)
        {
            e.printStackTrace();
        }
    }
 
    public int getPort()
    {
        return this.serverSocket.getLocalPort();
    }
 
    public void handle(HttpRequest request, HttpResponse response, HttpContext context) throws HttpException, IOException
    {
        response.setEntity(new InputStreamEntity(this.application.getResources().openRawResource(R.raw.zip), -1));
    }
}

ça marche presque, le fichier est bien transmit, mais il reste quelques détails