Como definir o tempo limite do HttpResponse para Android em Java

333

Eu criei a seguinte função para verificar o status da conexão:

private void checkConnectionStatus() {
    HttpClient httpClient = new DefaultHttpClient();

    try {
      String url = "http://xxx.xxx.xxx.xxx:8000/GaitLink/"
                   + strSessionString + "/ConnectionStatus";
      Log.d("phobos", "performing get " + url);
      HttpGet method = new HttpGet(new URI(url));
      HttpResponse response = httpClient.execute(method);

      if (response != null) {
        String result = getResponse(response.getEntity());
        ...

Quando eu desligo o servidor para testar, a execução aguarda muito tempo na linha

HttpResponse response = httpClient.execute(method);

Alguém sabe como definir o tempo limite para evitar a espera por muito tempo?

Obrigado!

Niko Gamulin
fonte

Respostas:

625

No meu exemplo, dois tempos limite são definidos. O tempo limite da conexão é disparado java.net.SocketTimeoutException: Socket is not connectede o tempo limite do soquete java.net.SocketTimeoutException: The operation timed out.

HttpGet httpGet = new HttpGet(url);
HttpParams httpParameters = new BasicHttpParams();
// Set the timeout in milliseconds until a connection is established.
// The default value is zero, that means the timeout is not used. 
int timeoutConnection = 3000;
HttpConnectionParams.setConnectionTimeout(httpParameters, timeoutConnection);
// Set the default socket timeout (SO_TIMEOUT) 
// in milliseconds which is the timeout for waiting for data.
int timeoutSocket = 5000;
HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket);

DefaultHttpClient httpClient = new DefaultHttpClient(httpParameters);
HttpResponse response = httpClient.execute(httpGet);

Se você deseja definir os Parâmetros de qualquer HTTPClient existente (por exemplo, DefaultHttpClient ou AndroidHttpClient), você pode usar a função setParams () .

httpClient.setParams(httpParameters);
kuester2000
fonte
1
@Thomas: Eu editei a minha resposta com uma solução para o seu caso de uso
kuester2000
3
O que o HttpResponse retornará se a conexão atingir o tempo limite? No momento em que minha solicitação HTTP é feita, eu verifico o código de status após a chamada retornar, no entanto, recebo uma NullPointerException ao verificar esse código se a chamada expirou ... basicamente, como lidar com a situação quando a chamada o tempo limite? (Eu estou usando um código muito semelhante à sua resposta dada) #
277 Tim Tim
10
@jellyfish - Apesar da documentação, o AndroidHttpClient não estende o DefaultHttpClient; em vez disso, implementa HttpClient. Você precisará usar DefaultHttpClient para disponibilizar o método setParams (HttpParams).
precisa
3
Ei, pessoal, espero pela excelente resposta. Mas, gostaria de mostrar um brinde aos usuários no tempo limite da conexão ... alguma maneira de detectar quando a conexão atinge o tempo limite?
Arnab Chakraborty
2
Não funciona Eu testei na minha Sony e Moto, todas elas ficam dobradas.
8135 thecr0w
13

Para definir configurações no cliente:

AndroidHttpClient client = AndroidHttpClient.newInstance("Awesome User Agent V/1.0");
HttpConnectionParams.setConnectionTimeout(client.getParams(), 3000);
HttpConnectionParams.setSoTimeout(client.getParams(), 5000);

Eu usei isso com sucesso no JellyBean, mas também deve funcionar para plataformas mais antigas ....

HTH


fonte
qual é a relação com o HttpClient?
Sazzad Hissain Khan 19/03/19
8

Se você estiver usando a biblioteca cliente http de Jacarta, poderá fazer algo como:

        HttpClient client = new HttpClient();
        client.getParams().setParameter(HttpClientParams.CONNECTION_MANAGER_TIMEOUT, new Long(5000));
        client.getParams().setParameter(HttpClientParams.SO_TIMEOUT, new Integer(5000));
        GetMethod method = new GetMethod("http://www.yoururl.com");
        method.getParams().setParameter(HttpMethodParams.SO_TIMEOUT, new Integer(5000));
        method.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,
        int statuscode = client.executeMethod(method);
Pablo Santa Cruz
fonte
5
HttpClientParams.CONNECTION_MANAGER_TIMEOUT é desconhecido
Tawani
Você deve usar client.getParams () setIntParameter (..) para os parâmetros * _TIMEOUT.
loafoe
Como encontrar? O dispositivo está conectado ao wifi, mas não há dados realmente ativos que passam pelo wifi.
precisa saber é o seguinte
7

Se você estiver usando o cliente http padrão, veja como fazê-lo usando os parâmetros HTTP padrão:

HttpClient client = new DefaultHttpClient();
HttpParams params = client.getParams();
HttpConnectionParams.setConnectionTimeout(params, 3000);
HttpConnectionParams.setSoTimeout(params, 3000);

O crédito original está disponível em http://www.jayway.com/2009/03/17/configuring-timeout-with-apache-httpclient-40/

Learn OpenGL ES
fonte
5

Para aqueles que dizem que a resposta de @ kuester2000 não funciona, lembre-se de que as solicitações HTTP, primeiro tente encontrar o IP do host com uma solicitação DNS e, em seguida, faça a solicitação HTTP real para o servidor, portanto, você também pode precisar definir um tempo limite para a solicitação de DNS.

Se seu código funcionou sem o tempo limite para a solicitação de DNS, é porque você pode acessar um servidor DNS ou está atingindo o cache DNS do Android. A propósito, você pode limpar esse cache reiniciando o dispositivo.

Este código estende a resposta original para incluir uma pesquisa DNS manual com um tempo limite personalizado:

//Our objective
String sURL = "http://www.google.com/";
int DNSTimeout = 1000;
int HTTPTimeout = 2000;

//Get the IP of the Host
URL url= null;
try {
     url = ResolveHostIP(sURL,DNSTimeout);
} catch (MalformedURLException e) {
    Log.d("INFO",e.getMessage());
}

if(url==null){
    //the DNS lookup timed out or failed.
}

//Build the request parameters
HttpParams params = new BasicHttpParams();
HttpConnectionParams.setConnectionTimeout(params, HTTPTimeout);
HttpConnectionParams.setSoTimeout(params, HTTPTimeout);

DefaultHttpClient client = new DefaultHttpClient(params);

HttpResponse httpResponse;
String text;
try {
    //Execute the request (here it blocks the execution until finished or a timeout)
    httpResponse = client.execute(new HttpGet(url.toString()));
} catch (IOException e) {
    //If you hit this probably the connection timed out
    Log.d("INFO",e.getMessage());
}

//If you get here everything went OK so check response code, body or whatever

Método usado:

//Run the DNS lookup manually to be able to time it out.
public static URL ResolveHostIP (String sURL, int timeout) throws MalformedURLException {
    URL url= new URL(sURL);
    //Resolve the host IP on a new thread
    DNSResolver dnsRes = new DNSResolver(url.getHost());
    Thread t = new Thread(dnsRes);
    t.start();
    //Join the thread for some time
    try {
        t.join(timeout);
    } catch (InterruptedException e) {
        Log.d("DEBUG", "DNS lookup interrupted");
        return null;
    }

    //get the IP of the host
    InetAddress inetAddr = dnsRes.get();
    if(inetAddr==null) {
        Log.d("DEBUG", "DNS timed out.");
        return null;
    }

    //rebuild the URL with the IP and return it
    Log.d("DEBUG", "DNS solved.");
    return new URL(url.getProtocol(),inetAddr.getHostAddress(),url.getPort(),url.getFile());
}   

Esta classe é desta postagem do blog . Vá e verifique as observações se você vai usá-lo.

public static class DNSResolver implements Runnable {
    private String domain;
    private InetAddress inetAddr;

    public DNSResolver(String domain) {
        this.domain = domain;
    }

    public void run() {
        try {
            InetAddress addr = InetAddress.getByName(domain);
            set(addr);
        } catch (UnknownHostException e) {
        }
    }

    public synchronized void set(InetAddress inetAddr) {
        this.inetAddr = inetAddr;
    }
    public synchronized InetAddress get() {
        return inetAddr;
    }
}
David Darias
fonte
1
HttpParams httpParameters = new BasicHttpParams();
            HttpProtocolParams.setVersion(httpParameters, HttpVersion.HTTP_1_1);
            HttpProtocolParams.setContentCharset(httpParameters,
                    HTTP.DEFAULT_CONTENT_CHARSET);
            HttpProtocolParams.setUseExpectContinue(httpParameters, true);

            // Set the timeout in milliseconds until a connection is
            // established.
            // The default value is zero, that means the timeout is not used.
            int timeoutConnection = 35 * 1000;
            HttpConnectionParams.setConnectionTimeout(httpParameters,
                    timeoutConnection);
            // Set the default socket timeout (SO_TIMEOUT)
            // in milliseconds which is the timeout for waiting for data.
            int timeoutSocket = 30 * 1000;
            HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket);
Sandeep
fonte
Incompleto. Qual é a relação com HttpClient?
Sazzad Hissain Khan 19/03/19
1

você pode criar uma instância HttpClient a propósito com Httpclient-android-4.3.5, ele pode funcionar bem.

 SSLContext sslContext = SSLContexts.createSystemDefault();
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
                sslContext,
                SSLConnectionSocketFactory.STRICT_HOSTNAME_VERIFIER);
                RequestConfig.Builder requestConfigBuilder = RequestConfig.custom().setCircularRedirectsAllowed(false).setConnectionRequestTimeout(30*1000).setConnectTimeout(30 * 1000).setMaxRedirects(10).setSocketTimeout(60 * 1000);
        CloseableHttpClient hc = HttpClients.custom().setSSLSocketFactory(sslsf).setDefaultRequestConfig(requestConfigBuilder.build()).build();
foxundermon
fonte
1

Uma opção é usar o cliente OkHttp , da Square.

Adicione a dependência da biblioteca

No build.gradle, inclua esta linha:

compile 'com.squareup.okhttp:okhttp:x.x.x'

Onde x.x.xestá a versão da biblioteca desejada.

Defina o cliente

Por exemplo, se você deseja definir um tempo limite de 60 segundos, faça o seguinte:

final OkHttpClient okHttpClient = new OkHttpClient();
okHttpClient.setReadTimeout(60, TimeUnit.SECONDS);
okHttpClient.setConnectTimeout(60, TimeUnit.SECONDS);

ps: Se sua minSdkVersion for maior que 8, você poderá usar TimeUnit.MINUTES. Então, você pode simplesmente usar:

okHttpClient.setReadTimeout(1, TimeUnit.MINUTES);
okHttpClient.setConnectTimeout(1, TimeUnit.MINUTES);

Para mais detalhes sobre as unidades, consulte TimeUnit .

androidevil
fonte
Na versão atual do OkHttp, os intervalos devem ser definidos de maneira diferente: https://github.com/square/okhttp/blob/master/samples/guide/src/main/java/okhttp3/recipes/ConfigureTimeouts.java
thijsonline
1

Se você estiver usando o HttpURLConnection, chame setConnectTimeout()como descrito aqui :

URL url = new URL(myurl);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setConnectTimeout(CONNECT_TIMEOUT);
Bruno Peres
fonte
A descrição é mais parecida com o tempo limite para estabelecer a conexão, em vez da solicitação http?
usar o seguinte comando
0
public boolean isInternetWorking(){
    try {
        int timeOut = 5000;
        Socket socket = new Socket();
        SocketAddress socketAddress = new InetSocketAddress("8.8.8.8",53);
        socket.connect(socketAddress,timeOut);
        socket.close();
        return true;
    } catch (IOException e) {
        //silent
    }
    return false;
}
Eco4ndly
fonte
Qual servidor ele representa? "8.8.8.8", 53
Junaed