1. Nimm jetzt an unserem AGM - Gewinnspiel teil - Informationen zum M1, A2 und A8 findest Du hier, hier und hier!
  1. nao88, 10.07.2012 #1
    nao88

    nao88 Threadstarter Neuer Benutzer

    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


    Code:
    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();
        }
    }
    
     
  2. DieGoldeneMitte, 10.07.2012 #2
    DieGoldeneMitte

    DieGoldeneMitte Android-Lexikon

    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:

    Code:
    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 );
    }
     
  3. nao88, 10.07.2012 #3
    nao88

    nao88 Threadstarter Neuer Benutzer

    habe das ausprobiert und bekomme immer nur noch die ersten 4000 Zeichen
     
  4. DieGoldeneMitte, 10.07.2012 #4
    DieGoldeneMitte

    DieGoldeneMitte Android-Lexikon

    Zeig mal den neuen Inhalt von convertStreamToString.
     
  5. nao88, 10.07.2012 #5
    nao88

    nao88 Threadstarter Neuer Benutzer

    Da ist es
    Code:
        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;
        }
     
  6. DieGoldeneMitte, 10.07.2012 #6
    DieGoldeneMitte

    DieGoldeneMitte Android-Lexikon

    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.)
     
  7. nao88, 10.07.2012 #7
    nao88

    nao88 Threadstarter Neuer Benutzer

    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.
     
  8. DieGoldeneMitte, 10.07.2012 #8
    DieGoldeneMitte

    DieGoldeneMitte Android-Lexikon

    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...
     
  9. nao88, 11.07.2012 #9
    nao88

    nao88 Threadstarter Neuer Benutzer

    mhhh gibt es einen anderen weg einen Rest service aufzurufen wenn ja wie
     
  10. Hagbard235, 11.07.2012 #10
    Hagbard235

    Hagbard235 Android-Experte

    So hab ich es gebaut

    PHP:
    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.