Cómo respuestas fragmentadas recibidos en HTTP / 1.1, mientras que el envío de datos al mismo tiempo con el servidor en Java / Android

JLT:

Estamos construyendo y aplicación en la que se registra la voz del usuario en tiempo real y envía los datos registrados en el servidor a través de una petición HTTP. Mientras el servidor procesa los datos en tiempo real que también está enviando respuestas de vuelta en fragmentada. Para decirlo simple, la aplicación es el envío de datos por partes al servidor, y al mismo tiempo, también está recibiendo pieza a pieza las respuestas del servidor.

Por favor, no me digas que esto es imposible porque tengo un ejemplo de trabajo en IOS que utiliza el URLSessioncon uploadTaskel uso de un par corriente para enviar los datos en tiempo real al servidor y luego recibir respuestas trozo por trozo de esta devolución de llamada urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data).

A continuación se muestra el código en Java. Me dieron el trabajo de enviar, pero la única respuesta se recibe cuando se realiza el envío.

RequestBody body = new RequestBody() 
{
    @Override 
    public MediaType contentType() 
    {
        return MediaType.get("application/octet-stream");
    }

    @Override 
    public void writeTo(BufferedSink sink) throws IOException 
    {
        String filename = "/path/spoken.pcm";

        try 
        {
            InputStream inputStream = new DataInputStream(new FileInputStream(new File(filename)));

            byte[] cacheBytes = new byte[320];

            int length;

            while((length = inputStream.read(cacheBytes, 0, cacheBytes.length)) != -1) 
            {
                System.out.println("write thread name: " + Thread.currentThread());

                sink.write(cacheBytes, 0, length);

                Thread.sleep(10);
            }

            inputStream.close();
        } 

        catch(IOException | InterruptedException e) 
        {
            e.printStackTrace();
        }
    }
};

Request request = new Request.Builder()
            .url("www.server.com")
            .post(body)
            .build();

Interceptor interceptor = new Interceptor()
{
    @Override
    public Response intercept(Chain chain) throws IOException 
    {
        System.out.println("intercept!!!");

        CountDownLatch latch = new CountDownLatch(1);

        Response response = chain.proceed(chain.request());
        BufferedSource source = response.body().source();

        System.out.println("got response body !!!!");

        new Thread(new Runnable()
        {
            @Override
            public void run() 
            {
                byte[] cachedBytes = new byte[512];

                try 
                {
                    while(!source.exhausted())
                    {
                        int length = source.read(cachedBytes);
                        byte[] partialBytes = new byte[length];

                        System.arraycopy(cachedBytes, 0, partialBytes, 0, length);

                        System.out.println("partial response received: " + getHexString(partialBytes));
                    }
                } 

                catch (IOException e) 
                {
                    e.printStackTrace();
                }

                latch.countDown();
            }
        }).start();

        try 
        {
            latch.await();
        } 

        catch (InterruptedException e) 
        {
            e.printStackTrace();
        }

        return response;
    }
};

httpClient = new OkHttpClient.Builder()
            .addInterceptor(interceptor)
            .build();

httpClient.newCall(request).enqueue(new Callback() 
{
    @Override
    public void onFailure(Call call, IOException e) 
    {
        e.printStackTrace();
    }

    @Override
    public void onResponse(Call call, Response response) throws IOException 
    {
        try(ResponseBody responseBody = response.body()) 
        {
            if(!response.isSuccessful()) throw new IOException("Unexpected code " + response);

            System.out.println("all responses received!");
        }
    }
});

Este registro: System.out.println("got response body !!!!");sólo aparece cuando he terminado de enviar todos los datos al servidor. Lo que significa que, cuando writeTo(BufferedSink sink)vuelve, me da la respuesta dentro del interceptor de devolución de llamada en trozos y luego la devolución de llamada onResponse(Call call, Response response)se llama.

Lo que necesito es, cuando envío de datos, quiero ser capaz de obtener las respuestas fragmentadas al mismo tiempo.

JLT:

OK, mirando por todas partes, esta aplicación no es la forma estándar como otros dicen para HTTP. Aunque HTTP no lo limita a hacer un envío y recibir simultáneamente en una única solicitud, como he conseguido esto ya utilizando una aplicación para iOS como cliente con un servlet de Java HTTP, el problema es, la mayoría de las bibliotecas no es compatible con este comportamiento. Usted puede escribir su propio SDK para esto en el lado del cliente, pero también se debe considerar el riesgo en el futuro si tiene previsto utilizar equilibradores de carga y proxy inverso para su servidor, y puede ser que no soporta este comportamiento tampoco.

Por lo tanto, mi solución más rápida para lograr el mismo efecto está utilizando HTTP para enviar la solicitud, pero la respuesta se envía al cliente a través MQTT.