Java 客户端和服务器在同一个应用程序中发送和接收字节

我正在尝试用WiFi连接替换蓝牙连接。我最初的项目有一个PIC微控制器，用于记录时间、日期和温度，并控制一些输出。我很久以前写过一个应用程序（3年了，从那以后就没有做过！），它使用蓝牙从Android向PIC发送和接收数据，运行良好。 到目前为止，我已经将ESP8266连接到Pic微控制器，ESP使用ESP-LINK固件并连接到我的家庭网络。pic将从ESP8266接收到的内容中继到RealTerm，以便我可以进行监控。我已经创建了一个测试应用程序，它正在创建一个套接字，并向PIC发送一个字节，该程序工作正常，收到的字节正常，代码如下

package com.example.carl.sockets;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;
import android.widget.Toast;

import java.io.DataOutputStream;
import java.io.IOException;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

public class MainActivity extends AppCompatActivity {

    private Socket socket;
    private static final int SERVERPORT = 23;
    private static final String SERVER_IP = "00.00.00.00"; // enter IP of ESP8266 here

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        new Thread(new ClientThread()).start();
    }

    public void onClick(View view) {
        try {
            EditText et = (EditText) findViewById(R.id.EditText01);
            Integer i = Integer.parseInt(et.getText().toString());

            DataOutputStream out = new DataOutputStream(socket.getOutputStream());
            if(i > 0 && i < 255){
                out.write(i);
            }else{
                Toast.makeText(this,"Number out of Range !",Toast.LENGTH_SHORT).show();
            }
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    class ClientThread implements Runnable {
        @Override
        public void run() {
            try {
                InetAddress serverAddr = InetAddress.getByName(SERVER_IP);
                socket = new Socket(serverAddr, SERVERPORT);
            } catch (UnknownHostException e1) {
                e1.printStackTrace();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
    }
}

package com.example.carl.sockets；
导入android.support.v7.app.AppActivity；
导入android.os.Bundle；
导入android.view.view；
导入android.widget.EditText；
导入android.widget.Toast；
导入java.io.DataOutputStream；
导入java.io.IOException；
导入java.net.InetAddress；
导入java.net.Socket；
导入java.net.UnknownHostException；
公共类MainActivity扩展了AppCompatActivity{
专用插座；
专用静态最终int服务器端口=23；
私有静态最终字符串服务器\u IP=“00.00.00.00”；//在此处输入ESP8266的IP
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
新线程（新ClientThread（））.start（）；
}
公共void onClick（视图）{
试一试{
EditText et=（EditText）findViewById（R.id.EditText01）；
整数i=Integer.parseInt（et.getText（）.toString（））；
DataOutputStream out=新的DataOutputStream（socket.getOutputStream（））；
如果（i>0&&i<255）{
写出（i）；
}否则{
Toast.makeText（这个“数字超出范围！”，Toast.LENGTH_SHORT.show（）；
}
}捕获（未知后异常e）{
e、 printStackTrace（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
类ClientThread实现Runnable{
@凌驾
公开募捐{
试一试{
inetAddressServerAddr=InetAddress.getByName（服务器IP）；
套接字=新套接字（serverAddr、SERVERPORT）；
}捕获（未知后异常e1）{
e1.printStackTrace（）；
}捕获（IOE1异常）{
e1.printStackTrace（）；
}
}
}
}

一旦字节发送到PIC，它将发送一个或多个字节作为响应返回。我现在需要读取PIC返回的一个或多个字节，并在文本视图中显示它们。我将知道多少字节将发送的PIC和接收的应用程序提前

我看过大量的代码，但似乎都是针对不同的服务器和客户机的，我不希望（或者我希望），也无法理解这一点

---

这可能以前有人问过，但我已经花了很长时间寻找，任何帮助或建议都将不胜感激。

我现在可以通过WiFi将一个字节发送到我的PIC，也可以通过android应用程序接收一个或多个字节。 我已经创建了一个新线程来等待输入流上的数据。我的主要问题是确保在启动这个线程之前连接好套接字，一旦我确信它工作正常。 当接收到数据时，它将通过处理程序发送回主代码。我的处理程序正在向我的应用程序输出文本，这取决于接收到的内容，七个字节是临时读数以及时间和日期。仅显示单个字节。 我的代码是附加的，可能不好看！！欢迎任何建设性的批评

package com.example.carl.sockets;

import android.os.Handler;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "Main Activity - Sockets";
    private Handler h;
    private Socket socket;
    private static final int SERVERPORT = 23;
    private static final String SERVER_IP = "192.168.1.78"; // enter IP of ESP8266 here
    private receiveData rd;
    protected static final int SUCCESS_CONNECT = 0;
    protected static final int NOW_DATA_RECEIVED = 1;
    protected static final int ONE_BYTE_RECEIVED = 2;
    private boolean connectedSocket = false;

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

        new Thread(new ClientThread()).start();

        while(!connectedSocket){}

        rd = new receiveData(socket);
        rd.start();

    h = new Handler() {
            public void handleMessage(android.os.Message msg) {
                switch (msg.what) {
                    case SUCCESS_CONNECT:
                        break;
                    case NOW_DATA_RECEIVED:
                        Log.d(TAG,"Handler - In 7 bytes received");
                        byte[] nowData = (byte[]) msg.obj;
                        // process data
                        int tempFrac = 0;
                        int tempUnits = 0;
                        // construct time and date string, pad to 2 figures, unsigned values
                        String hourStr = Integer.toString(nowData[2]&0xFF);
                        hourStr = "00".substring(hourStr.length()) + hourStr;
                        String minStr = Integer.toString(nowData[3]&0xFF);
                        minStr = "00".substring(minStr.length()) + minStr;
                        String dayStr = Integer.toString(nowData[4]&0xFF);
                        dayStr = "00".substring(dayStr.length()) + dayStr;
                        String monthStr = Integer.toString(nowData[5]&0xFF);
                        monthStr = "00".substring(monthStr.length()) + monthStr;
                        String yearStr = Integer.toString(nowData[6]&0xFF);
                        yearStr = "00".substring(yearStr.length()) + yearStr;
                        String nowDataString = new String(hourStr +":" + minStr + " " + dayStr + "/" + monthStr + "/" + yearStr);
                        // get unsigned values
                        int tempMSB = nowData[0] & 0xFF;
                        int tempLSB = nowData[1] & 0xFF;
                        // add LSB and MSB
                        int tempVar = tempLSB + (tempMSB<<8);
                        // if Zero
                        if(tempVar == 0){
                            // result zero so display zero degrees
                            // put in text view
                            TextView txtData = (TextView) findViewById(R.id.textView);
                            txtData.setText(nowDataString + " Temp = 0.0c");
                        }else if(tempMSB >= 0x80){
                            // result negative
                            tempVar = (~tempVar) + 1;
                            tempFrac = tempVar & 0x0F;
                            tempFrac = tempFrac*625/1000;
                            tempUnits = (tempVar>>4)&0x7F;
                            String tempString = new String("-"+Integer.toString(tempUnits)+"."+Integer.toString(tempFrac));
                            // put in text view
                            TextView txtData = (TextView) findViewById(R.id.textView);
                            txtData.setText(nowDataString + " Temp = " + tempString + "c");
                        }else{
                            // result positive
                            tempFrac = tempVar & 0x0F;
                            tempFrac = tempFrac*625/1000;
                            tempVar = tempVar>>4;
                            tempUnits = tempVar & 0x7F;
                            String tempString = new String(Integer.toString(tempUnits)+"."+Integer.toString(tempFrac));
                            // put in text view
                            TextView txtData = (TextView) findViewById(R.id.textView);
                            txtData.setText(nowDataString + " Temp = " + tempString + "c");
                        }
                        break;
                    case ONE_BYTE_RECEIVED:
                        Log.d(TAG,"Handler - In 1 byte received");
                        byte[] recByte = (byte[]) msg.obj;
                        int receivedByte = (int)recByte[0];
                        TextView txtData = (TextView) findViewById(R.id.textView);
                        txtData.setText( "One Byte Received = " + Integer.toString(receivedByte));
                        Log.d(TAG, "In handler, one byte received = "+ Integer.toString(receivedByte));
                        break;
                }
            }
        };
    }

    @Override
    public void onPause(){
        super.onPause();

        try{
            socket.close();
        }catch(IOException e){
            Log.d(TAG,"Error closing socket in on pause");
        }
        rd.stopRdThread();
    }

    public void onClick(View view) {
        try {
            EditText et = (EditText) findViewById(R.id.EditText01);
            Integer i = Integer.parseInt(et.getText().toString());

            DataOutputStream out = new DataOutputStream(socket.getOutputStream());
            if (i > 0 && i < 255) {
                out.write(i);
                Log.d(TAG,"Byte Sending - "+ i.toString());
            } else {
                Toast.makeText(this, "Number out of Range !", Toast.LENGTH_SHORT).show();
            }
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    class ClientThread implements Runnable {
        @Override
        public void run() {

            try {
                InetAddress serverAddr = InetAddress.getByName(SERVER_IP);
                socket = new Socket(serverAddr, SERVERPORT);
                if(socket.isConnected()){
                    Log.d(TAG, "in ClientThread - socket connected");
                    connectedSocket = true;
                }else{
                    Log.d(TAG, "in ClientThread - socket not connected");
                    connectedSocket = false;
                }
            } catch (UnknownHostException e1) {
                e1.printStackTrace();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
    }

    class receiveData extends Thread {
        private Socket socketLocal;
        private volatile boolean exit = false;
        DataInputStream in;
        byte[] fullBuffer = new byte[7];
        byte[] buffer = new byte[100];
        int bytes; // bytes returned from read()
        int bytesCount = 0;

        // constructor
        receiveData(Socket socket){
            this.socketLocal = socket;
        }

        public void run(){
            try {
                if (socketLocal.isConnected()) {
                    Log.d(TAG, "In receiveData, Socket connected");
                    in = new DataInputStream(socketLocal.getInputStream());
                }
            }catch(Exception e){
                    Log.d(TAG, "in receiveData - run exception - " + e.toString());
            }

            while(!exit){
                try {
                    if (socketLocal.isConnected()) {
                        if (in.available() > 0) {
                            //input = in.readByte();     // Get number of bytes and message in "buffer"
                            bytes = in.read(buffer);
                            Log.d(TAG,"Bytes Read = "+Integer.toString(bytes));
                            System.arraycopy(buffer,0,fullBuffer,bytesCount,bytes);
                            bytesCount = bytesCount + bytes;
                            if(bytesCount >= 7){
                                h.obtainMessage(NOW_DATA_RECEIVED, bytesCount, -1, fullBuffer).sendToTarget();     // Send to message queue Handler
                                Log.d(TAG,"In handler, 7 bytes Message sent");
                                bytesCount = 0;
                            }else if(bytesCount == 1){
                                h.obtainMessage(ONE_BYTE_RECEIVED, bytesCount, -1, fullBuffer).sendToTarget();
                                Log.d(TAG, "In handler, 1 byte message sent");
                                bytesCount = 0;
                            }
                        }
                    }else{
                        break;
                    }
                }catch(Exception e){
                    Log.d(TAG, "Read Error - " + e.toString());
                }
            }
        }

        public void stopRdThread(){
            exit = true;
            try {
                socketLocal.close();
            }catch(Exception e){
                Log.d(TAG, "error closing socket - " + e.toString());
            }
        }
    }
}

package com.example.carl.sockets；
导入android.os.Handler；
导入android.support.v7.app.AppActivity；
导入android.os.Bundle；
导入android.util.Log；
导入android.view.view；
导入android.widget.EditText；
导入android.widget.TextView；
导入android.widget.Toast；
导入java.io.DataInputStream；
导入java.io.DataOutputStream；
导入java.io.IOException；
导入java.net.InetAddress；
导入java.net.Socket；
导入java.net.UnknownHostException；
公共类MainActivity扩展了AppCompatActivity{
私有静态最终字符串TAG=“主活动-套接字”；
私有处理器h；
专用插座；
专用静态最终int服务器端口=23；
私有静态最终字符串服务器\u IP=“192.168.1.78”//在此处输入ESP8266的IP
私人接收数据rd；
受保护的静态最终int成功连接=0；
受保护的静态最终int NOW\u DATA\u RECEIVED=1；
受保护的静态最终整数1字节接收=2；
私有布尔连接套接字=false；
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
新线程（新ClientThread（））.start（）；
而（！connectedSocket）{}
rd=新接收数据（插座）；
rd.start（）；
h=新处理程序（）{
public void handleMessage（android.os.Message msg）{
开关（msg.what）{
成功案例(u CONNECT):
打破
目前收到的案例数据：
d（标记“Handler-In-7字节接收”）；
字节[]nowData=（字节[]）msg.obj；
//过程数据
int-tempFrac=0；
int tempUnits=0；
//构造时间和日期字符串，填充为2位数，无符号值
字符串hourStr=Integer.toString（nowData[2]&0xFF）；
hourStr=“00”。子字符串（hourStr.length（））+hourStr；
字符串minStr=Integer.toString（nowData[3]&0xFF）；