json String wird nicht Komplet übertagen

[nao88]

Hallo liebe Android Gemeinde
Momentan stehe ich vor einem Problem hier mal die Eckdaten
Abfragen eines Rest Service welcher eine json String liefert eine Zeile mit knapp 30000 Zeichen.
Abfragen findet im 3g Netz statt
Nun zum Problem der String hört nach ungefähr 4000 Zeichen auf und ich weiß nicht wo der Rest ist

package com.example.myfirstapp;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URLEncoder;
import java.util.ArrayList;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;


public class RestClient {

    private ArrayList <NameValuePair> params;
    private ArrayList <NameValuePair> headers;

    private String url;

    private int responseCode;
    private String message;

    private String response;

    public String getResponse() {
        return response;
    }

    public String getErrorMessage() {
        return message;
    }

    public int getResponseCode() {
        return responseCode;
    }

    public RestClient(String url)
    {
        this.url = url;
        params = new ArrayList<NameValuePair>();
        headers = new ArrayList<NameValuePair>();
    }

    public void AddParam(String name, String value)
    {
        params.add(new BasicNameValuePair(name, value));
    }

    public void AddHeader(String name, String value)
    {
        headers.add(new BasicNameValuePair(name, value));
    }

    public void Execute(RequestMethod method) throws Exception
    {
        switch(method) {
            case GET:
            {
                //add parameters
                String combinedParams = "";
                if(!params.isEmpty()){
                    combinedParams += "?";
                    for(NameValuePair p : params)
                    {
                        String paramString = p.getName() + "=" + URLEncoder.encode(p.getValue(),"UTF-8");
                        if(combinedParams.length() > 1)
                        {
                            combinedParams  +=  "&" + paramString;
                        }
                        else
                        {
                            combinedParams += paramString;
                        }
                    }
                }

                HttpGet request = new HttpGet(url + combinedParams);

                //add headers
                for(NameValuePair h : headers)
                {
                    request.addHeader(h.getName(), h.getValue());
                }
                
                executeRequest(request, url);
                break;
            }
            case POST:
            {
                HttpPost request = new HttpPost(url);

                //add headers
                for(NameValuePair h : headers)
                {
                    request.addHeader(h.getName(), h.getValue());
                }

                if(!params.isEmpty()){
                    request.setEntity(new UrlEncodedFormEntity(params, HTTP.UTF_8));
                }

                executeRequest(request, url);
                break;
            }
        }
    }

    private void executeRequest(HttpUriRequest request, String url)
    {
        request.setHeader("Authorization", "Basic sssss");
    	HttpClient client = new DefaultHttpClient();
        HttpResponse httpResponse;

        try {
            httpResponse = client.execute(request);
            
            responseCode = httpResponse.getStatusLine().getStatusCode();
            message = httpResponse.getStatusLine().getReasonPhrase();

            HttpEntity entity = httpResponse.getEntity();

            if (entity != null) {

                InputStream instream = entity.getContent();
                response = convertStreamToString(instream);

                // Closing the input stream will trigger connection release
                instream.close();
            }

        } catch (ClientProtocolException e)  {
            client.getConnectionManager().shutdown();
            e.printStackTrace();
        } catch (IOException e) {
            client.getConnectionManager().shutdown();
            e.printStackTrace();
        }
    }

    private static String convertStreamToString(InputStream is) {

        BufferedReader reader = new BufferedReader(new InputStreamReader(is),8 * 1024);
        StringBuilder sb = new StringBuilder();

        String line = null;
        try {
            while ((line = reader.readLine()) != null) {
                sb.append(line + "\n");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return sb.toString();
    }
}

 

[DieGoldeneMitte]

Dein BufferedReader kann nur 8*1024 bytes (=4096 UCS2 Buchstaben) halten, also kann er maximal 4000 Zeichen lange Zeilen liefern.

Lösung: Nicht zeilenweise lesen. Beispielsweise so:

Reader reader = new InputStreamReader(is,"UTF-8");
char[] tmp = new char[4096];
int read = 0;
while( (read=reader.read(tmp))>0 ) {
  sb.append( tmp, 0, read );
}

 

[nao88]

habe das ausprobiert und bekomme immer nur noch die ersten 4000 Zeichen

 

[DieGoldeneMitte]

Zeig mal den neuen Inhalt von convertStreamToString.

 

[nao88]

Da ist es

    private static String convertStreamToString(InputStream is) throws IOException {

        StringBuilder sb = new StringBuilder();
        Reader reader = new InputStreamReader(is,"UTF-8");
        char[] tmp = new char[4096];
        int read = 0;
        while( (read=reader.read(tmp))>0 ) {
          sb.append( tmp, 0, read );
        }
        String str = sb.toString();
        System.out.println(str);
        return str;
    }

 

[DieGoldeneMitte]

Komisch, das sieht eigentlich richtig aus.
Bist du sicher, dass der Server das json richtig liefert?
(Irgendwelche Proxies involviert?)
Bist du sicher, dass das auf dem Androiden nicht eine alte Version des Codes liegt?

Ansonsten versuch mal >=0 anstatt >0 (wäre aber der erste Fall, den ich sehe, in dem read() 0 liefert.)

 

[nao88]

Wenn ich den Service mit der Seite aufrufe klappt alles und der json String ist vollständig.
Gibt es eine Möglichkeit das zu überprüfen ?
Ne es werden keine Proxys verwendet. Ich greife mittels 3g auf den Server zu und bekomme 5919 Zeichen zurück von 30000 Zeichen.
Wie kann ich sicher gehen das die neue ausgeführt wird ?? Aber ich glaube stark das es die neue ist.

 

[DieGoldeneMitte]

Ich wüde mit dem Gerät mal zum Vergleich über normales Internet (WLAN-Router) gehen. Bei 3G würde ich transparente Proxies erwarten, aber so ein Verhalten ist mir neu.

Ob die aktuelle Version auf dem Gerät ist, teste ich, indem ich den Debuggingoutput variiere und gucke, ob die Variation erscheint.

Kannst du vielelicht im Serverlog Auffälligkeiten entdecken?

Ansonsten bin ich mit meinem Latein auch am Ende...

 

[nao88]

mhhh gibt es einen anderen weg einen Rest service aufzurufen wenn ja wie

 

[Hagbard235]

So hab ich es gebaut

try {
    				BufferedReader reader = new BufferedReader(new InputStreamReader(
    						is, "UTF-8"), 8);
    				sb = new StringBuilder();
    				sb.append(reader.readLine() + "\n");
    				String line = "0";

    				while ((line = reader.readLine()) != null) {
    					sb.append(line + "\n");
    				}

    				is.close();
    				result = sb.toString();

Geht bei mir auch über 3G wunderbar.