Android Java套接字发送数据延迟

更新： 谢谢你的想法。我已经调试了这个问题，我相信这是android和ESP8266之间的连接。我相信ESP可能有问题，因为当我把安卓系统连接到我的电脑上时，它似乎能正常工作。有一些非常小的延迟，但与连接到ESP时完全不同。因此，我认为ESP导致了延迟。尽管如此，我不确定是什么原因造成了这一局面。我曾尝试使用Arduino IDE 1.6.8中的ESP8266 2.3.0版本的库，但似乎不明白为什么会延迟。我确实将android应用程序连接到我的内部路由器，然后发送到电脑，没有任何问题。然而，它似乎不工作的ESP。我不敢相信我是唯一一个看到这一点。。。如果其他人有这个工作，请让我知道你是怎么做到的。我永远感激你

以下是ESP Arduino代码：

WiFiServer server(2390); // TCP/IP
SoftwareSerial mySerial( 4, 5);    // RX, TX
void setup( ) 
{
    Serial.begin( 115200 );
    WiFi.mode(WIFI_STA);
    WiFi.softAP( "mySSID", "myPASS");

    server.begin();// START TCP/IP SERVER 
}
WiFiClient client;
void loop( ) 
{
    if (client) 
    {
        while (client.connected()) 
        {
            if (client.available()) 
            {
                char command = client.read();
                Serial.println(itoa(command,buffer,10));
            }
        }
    }
    else
    {
        client = server.available();
    }
}

我试图在android（Java）和ESP8266之间使用TCP/IP套接字实现几乎即时的通信。我看到的问题是，从我按下按钮到安卓实际发送数据之间有很大的延迟。当我点击Go按钮时，它似乎有时会正确发送，但在第一次之后，它在5-10秒内不会发送。当它被卡住时，我轻触Go按钮数次，在延迟之后，它们似乎都会立即发送或开始喷射发送。我在Android Studio中查看网络监视器，从我点击按钮到流量显示在监视器选项卡中的网络面板上，可以看到延迟

我正在使用Android Studio调试器测试代码

有什么我做得不对的吗？或者，是否有更好的实现设备间的近即时通信

提前感谢您的帮助

安卓设备： 三星Note 4-v5.1.1 Android v2.0

安卓工作室

ESP设备： ESP8266使用Arduino Studio 1.6.8

这是我的密码：

public class MainActivity extends AppCompatActivity 
{
    private Socket socket;


    @Override
    protected void onCreate(Bundle savedInstanceState) 
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    public void onClick(View view) 
    {
        try 
        {
            new AsyncTaskRunner().execute("");
        } 
        catch (Exception e) 
        {
            e.printStackTrace();
        }
    }

    private class AsyncTaskRunner extends AsyncTask<String, String, String> 
    {
        private String resp;
        ProgressDialog progressDialog;

        @Override
        protected String doInBackground(String... params) 
        {
            try 
            {
                DataOutputStream dataOut;
                Socket s = new Socket("192.168.4.1", 2390);

                dataOut=new DataOutputStream(s.getOutputStream());
                byte[] outputData = new byte[9];
                outputData[0] = 1;
                outputData[1] = 2;
                outputData[2] = 3;
                outputData[3] = 4;
                outputData[4] = 5;
                outputData[5] = 6;
                outputData[6] = 7;
                outputData[7] = 8;
                outputData[8] = 9;
                dataOut.write(outputData); // Red
                dataOut.flush();
                dataOut.close();
                s.close();
            }
            catch (UnknownHostException e)
            {
                e.printStackTrace();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }

            return resp;
        }

        @Override
        protected void onPostExecute(String result) {
        }

        @Override
        protected void onProgressUpdate(String... text) {
        }
    }
}

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="com.jered.networktest.MainActivity">

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Go"
        android:onClick="onClick"/>

</RelativeLayout>

public类MainActivity扩展了AppCompatActivity
{
专用插座；
@凌驾
创建时受保护的void（Bundle savedInstanceState）
{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
}
公共void onClick（视图）
{
尝试
{
新建AsyncTaskRunner（）.execute（“”）；
} 
捕获（例外e）
{
e、 printStackTrace（）；
}
}
私有类AsyncTaskRunner扩展了AsyncTask
{
私有字符串resp；
进行对话进行对话；
@凌驾
受保护的字符串doInBackground（字符串…参数）
{
尝试
{
数据输出流数据输出；
插座s=新插座（“192.168.4.1”，2390）；
dataOut=新的DataOutputStream（s.getOutputStream（））；
字节[]输出数据=新字节[9]；
outputData[0]=1；
输出数据[1]=2；
输出数据[2]=3；
输出数据[3]=4；
输出数据[4]=5；
输出数据[5]=6；
输出数据[6]=7；
输出数据[7]=8；
输出数据[8]=9；
dataOut.write（outputData）；//红色
dataOut.flush（）；
dataOut.close（）；
s、 close（）；
}
捕获（未知后异常e）
{
e、 printStackTrace（）；
}
捕获（IOE异常）
{
e、 printStackTrace（）；
}
返回响应；
}
@凌驾
受保护的void onPostExecute（字符串结果）{
}
@凌驾
受保护的void onProgressUpdate（字符串…文本）{
}
}
}

我认为没有人能确定问题出在哪里。 为了防止你（和其他人）追逐鬼魂，你真的想解决你的问题：

• 确保您的“doInBackground”没有延迟，例如登录到android日志系统、控制台、调试器，或者在ui中做一些简单的事情
• 确保Android端的发送不会延迟，用Java编写一个小型侦听器，并在PC上运行
• 通过在Java中创建一个微型发送器并在PC上运行，确保监听不会延迟

---

通过这种方式将问题分开，直到找到根本原因：）

我在本案例中遇到了这个问题，当时我想将一些数据传输到接入点Esp8266-01。我认为这种延迟是由于

if（client.available（））

内部

而（client.connected（））

循环等待接收数据，直到客户端可用。因此，进行了延迟（正好是5秒）。为了避免这种不愉快的行为，我在android MainActivity.java文件中的AsyncTask的write命令中附加了一个回车符

'\r'

，然后修改了Arduino草图以等待服务器收到回车符，我指的是类似以下代码

String request=client.readStringUntil（'\r'）
最后，android应用程序中称为btn1和btn2的两个按钮分别发送两个字符串
/led/on
和
/led/off
。到目前为止，ESP8266立即接收回车并刷新客户端，这样就不会延迟执行程序的其他部分。
以下程序根据Android应用程序中按下的按钮打开或关闭一个led（ESP8266-01的GPIO 0引脚）。但编程时不要忘记设置ESP8266-01的地面GPIO 0，也不要忘记先将移动wifi连接到ESP wifi网络，但您也可以使用wifi配置自动连接到ESP wifi（参见此）

Arduino代码：

#include<ESP8266WiFi.h>
// WiFi Definitions
const char* ssid = "Esp8266TestNet";
const char* password = "Esp8266Test"; // has to be longer than 7 chars
const char* value = "";

int ledPin = 0; // GPIO 0
WiFiServer server(80);

void setup() {

   Serial.begin(115200);
   delay(10);
   pinMode(ledPin, OUTPUT);
   digitalWrite(ledPin, HIGH); // turn on

   WiFi.mode(WIFI_AP);
   WiFi.softAP(ssid, password, 1, false);
  
   server.begin();
}

void loop() {
  // Check of client has connected
  WiFiClient client = server.available();
  if(!client) {
    return;
  }

  // Read the request line
  String request = client.readStringUntil('\r');
  Serial.println(request);
  client.flush();
  
  // Match request
  if(request.indexOf("/led/on") != -1) {
     digitalWrite(ledPin, HIGH);
     value = "on";
  } else if (request.indexOf("/led/off") != -1) {
     digitalWrite(ledPin, LOW);
      value = "off";
  }
  else {
    Serial.println("not validate");
    }
  
  client.flush();
   
  // JSON response
  String s = "HTTP/1.1 200 OK\r\n";
  s += "Content-Type: application/json\r\n\r\n";
  s += "{\"data\":{\"message\":\"success\",\"value\":\"";
  s += value;
  s += "\"}}\r\n";
  s += "\n";

  // Send the response to the client
  client.print(s);
  delay(1);
  Serial.println("Client disconnected");

  // The client will actually be disconnected when the function returns and the client object is destroyed
}

#包括
//WiFi定义
const char*ssid=“Esp8266TestNet”；
const char*password=“Esp8266Test”；//必须大于7个字符
骗局
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.myhgrtest">
    <uses-permission android:name="android.permission.INTERNET"/>

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">
    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/btn1"
        android:text="btn1"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        ></Button>
    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/btn2"
        android:text="btn2"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        ></Button>
</androidx.constraintlayout.widget.ConstraintLayout>

package com.example.myhgrtest;

import androidx.appcompat.app.AppCompatActivity;

import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.HttpURLConnection;
import java.net.Socket;
import java.net.URL;

public class MainActivity extends AppCompatActivity {
    Button btn1,btn2;
    TcpClient mTcpClient;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btn1=findViewById(R.id.btn1);
        btn2=findViewById(R.id.btn2);
        btn1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {

                send_request1();
            }
        });
        btn2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                send_request2();
            }
        });
    }
    public class ConnectTask extends AsyncTask<String, String, TcpClient> {

        @Override
        protected TcpClient doInBackground(String... message) {

            //we create a TCPClient object
            mTcpClient = new TcpClient(new TcpClient.OnMessageReceived() {
                @Override
                //here the messageReceived method is implemented
                public void messageReceived(String message) {
                    //this method calls the onProgressUpdate
                    publishProgress(message);
                }
            });
            mTcpClient.run();

            return null;
        }

        @Override
        protected void onProgressUpdate(String... values) {
            super.onProgressUpdate(values);
            //response received from server
            Log.d("test", "response " + values[0]);
            //process server response here....

        }
    }
    public void send_request1() {
        send_request1 sr = new send_request1();
        sr.execute();
    }
    public void send_request2() {
        send_request2 sr = new send_request2();
        sr.execute();
    }
    class send_request1 extends AsyncTask<Void, Void, String> {

        @Override
        protected String doInBackground(Void... voids) {
            try {             /*note : ip address must be in Quotation mark*/
                /*note : port doesn't need to be inside the Quotation mark*/
                Socket s = new Socket(/*ip address :*/"192.168.4.1",/*port :*/ 80);
                PrintWriter printWriter = new PrintWriter(s.getOutputStream());
                printWriter.write("/led/on"+"\r");
                printWriter.flush();
                printWriter.close();
                s.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }

        @Override
        public void onPostExecute(final String Data) {
            /*Data is what you receive from your server*/
            Log.e("my_Data","Data is : " + Data);
        }
    }
    class send_request2 extends AsyncTask<Void, Void, String> {

        @Override
        protected String doInBackground(Void... voids) {
            try {
                /*note : ip address must be in Quotation mark*/
                /*note : port doesn't need to be inside the Quotation mark*/
                Socket s = new Socket(/*ip address :*/"192.168.4.1",/*port :*/ 80);
                PrintWriter printWriter = new PrintWriter(s.getOutputStream());
                printWriter.write("/led/off"+"\r");
                printWriter.flush();
                printWriter.close();
                s.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }

        @Override
        public void onPostExecute(final String Data) {
            /*Data is what you receive from your server*/
            Log.e("my_Data","Data is : " + Data);
            //Toast.makeText(MainActivity.this, Data, Toast.LENGTH_SHORT).show();
        }
    }

}