Java 与服务器建立TCP连接后，为什么'；我看不到从服务器发送的消息吗？

我制作了一个应用程序，应该通过WiFi直接连接到传感器，然后连接到传感器上的端口5001以获取传感器数据

我使用“Simple Socket Tester”在另一部手机上启动了一个服务器，以查看我的应用程序是否成功连接到该服务器上的端口5001。连接后，我可以向服务器发送消息，并显示在另一部手机上。但是，当我从另一部手机向客户端发送消息时，我的应用程序中没有收到消息

为什么呢？我的代码中是否缺少某些内容

public class TCPClient {

    public static final String SERVER_IP = "192.168.1.52"; //your computer IP address
    public static final int SERVER_PORT = 5001;

    // message to send to the server
    private String mServerMessage;

    // sends message received notifications
    private OnMessageReceived mMessageListener = null;

    // while this is true, the server will continue running
    private boolean mRun = false;

    // used to send messages
    private PrintWriter mBufferOut;

    // used to read messages from the server
    private BufferedReader mBufferIn;

    /**
     * Constructor of the class. OnMessagedReceived listens for the messages received from server
     */
    public TCPClient(OnMessageReceived listener) {
        mMessageListener = listener;
    }

    /**
     * Sends the message entered by client to the server
     *
     * @param message text entered by client
     */
    public void sendMessage(String message) {
        if (mBufferOut != null && !mBufferOut.checkError()) {
            mBufferOut.println(message);
            mBufferOut.flush();
        }
    }

    /**
     * Close the connection and release the members
     */
    public void stopClient() {

        // send mesage that we are closing the connection
        /*sendMessage(Constants.CLOSED_CONNECTION+"Kazy");*/

        mRun = false;

        if (mBufferOut != null) {
            mBufferOut.flush();
            mBufferOut.close();
        }

        mMessageListener = null;
        mBufferIn = null;
        mBufferOut = null;
        mServerMessage = null;
    }

    public void run() {

        mRun = true;

        try {
            //here you must put your computer's IP address.
            InetAddress serverAddr = InetAddress.getByName(SERVER_IP);

            Log.e("TCP Client", "C: Connecting...");

            //create a socket to make the connection with the server
            Socket socket = new Socket(serverAddr, SERVER_PORT);

            try {

                //sends the message to the server
                mBufferOut = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);

                //receives the message which the server sends back
                mBufferIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                // send login name
                sendMessage("hi");

                //in this while the client listens for the messages sent by the server
                while (mRun) {

                    mServerMessage = mBufferIn.readLine();

                    if (mServerMessage != null && mMessageListener != null) {
                        //call the method messageReceived from MyActivity class
                        mMessageListener.messageReceived(mServerMessage);
                    }

                }

                Log.e("RESPONSE FROM SERVER", "S: Received Message: '" + mServerMessage + "'");

            } catch (Exception e) {

                Log.e("TCP", "S: Error", e);

            } finally {
                //the socket must be closed. It is not possible to reconnect to this socket
                // after it is closed, which means a new socket instance has to be created.
                socket.close();
            }

        } catch (Exception e) {

            Log.e("TCP", "C: Error", e);

        }
    }

    //Declare the interface. The method messageReceived(String message) will must be implemented in the MyActivity
    //class at on asynckTask doInBackground
    public interface OnMessageReceived {
        public void messageReceived(String message);
   }
}

我的ConnectTask类所在的类

public class DeviceDetailFragment extends Fragment implements ConnectionInfoListener {

    protected static final int CHOOSE_FILE_RESULT_CODE = 20;
    private View mContentView = null;
    private WifiP2pDevice device;
    private WifiP2pInfo info;
    ProgressDialog progressDialog = null;
    TCPClient mTCPClient;

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {

        mContentView = inflater.inflate(R.layout.device_detail, null);
        mContentView.findViewById(R.id.btn_connect).setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View v) {
                WifiP2pConfig config = new WifiP2pConfig();
                config.deviceAddress = device.deviceAddress;
                config.wps.setup = WpsInfo.PBC;
                if (progressDialog != null && progressDialog.isShowing()) {
                    progressDialog.dismiss();
                }
                progressDialog = ProgressDialog.show(getActivity(), "Press back to cancel",
                    "Connecting to :" + device.deviceAddress, true, true
    //                        new DialogInterface.OnCancelListener() {
    //
    //                            @Override
    //                            public void onCancel(DialogInterface dialog) {
    //                                ((DeviceActionListener) 
    getActivity()).cancelDisconnect();
    //                            }
    //                        }
                );
                ((DeviceListFragment.DeviceActionListener) getActivity()).connect(config);

            }
        });

        mContentView.findViewById(R.id.btn_disconnect).setOnClickListener(
            new View.OnClickListener() {

                @Override
                public void onClick(View v) {
                    ((DeviceListFragment.DeviceActionListener) getActivity()).disconnect();
                }
            });

        /*
        mContentView.findViewById(R.id.btn_start_client).setOnClickListener(
            new View.OnClickListener() {

                @Override
                public void onClick(View v) {
                    // Allow user to pick an image from Gallery or other
                    // registered apps
                    Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
                    intent.setType("image/*");
                    startActivityForResult(intent, CHOOSE_FILE_RESULT_CODE);
                }
            });
        */

        return mContentView;
    }

    @Override
    public void onConnectionInfoAvailable(final WifiP2pInfo info) {
        if (progressDialog != null && progressDialog.isShowing()) {
            progressDialog.dismiss();
        }
        this.info = info;
        this.getView().setVisibility(View.VISIBLE);

        // The owner IP is now known.
        TextView view = (TextView) mContentView.findViewById(R.id.group_owner);
        view.setText(getResources().getString(R.string.group_owner_text)
            + ((info.isGroupOwner == true) ? getResources().getString(R.string.yes)
            : getResources().getString(R.string.no)));

        // InetAddress from WifiP2pInfo struct.
        view = (TextView) mContentView.findViewById(R.id.device_info);
        view.setText("Group Owner IP - " + info.groupOwnerAddress.getHostAddress());
        if(info.groupFormed) {
            new ConnectTask().execute("");
            if (mTCPClient != null) {
                 mTCPClient.sendMessage("testing");
            }
            //sends the message to the server
        }

        // After the group negotiation, we assign the group owner as the file
        // server. The file server is single threaded, single connection server
        // socket.
        /*
        if (info.groupFormed && info.isGroupOwner) {
            new FileServerAsyncTask(getActivity(), mContentView.findViewById(R.id.status_text))
                .execute();
        }
        */

        // hide the connect button
        mContentView.findViewById(R.id.btn_connect).setVisibility(View.GONE);
    }

    /**
     * Updates the UI with device data
     *
     * @param device the device to be displayed
     */
    public void showDetails(WifiP2pDevice device) {
        this.device = device;
        this.getView().setVisibility(View.VISIBLE);
        TextView view = (TextView) mContentView.findViewById(R.id.device_address);
        view.setText(device.deviceAddress);
        view = (TextView) mContentView.findViewById(R.id.device_info);
        view.setText(device.toString());
    }

    /**
     * Clears the UI fields after a disconnect or direct mode disable operation.
     */
    public void resetViews() {
        mContentView.findViewById(R.id.btn_connect).setVisibility(View.VISIBLE);
        TextView view = (TextView) mContentView.findViewById(R.id.device_address);
        view.setText(R.string.empty);
        view = (TextView) mContentView.findViewById(R.id.device_info);
        view.setText(R.string.empty);
        view = (TextView) mContentView.findViewById(R.id.group_owner);
        view.setText(R.string.empty);
        /*
        view = (TextView) mContentView.findViewById(R.id.status_text);
        view.setText(R.string.empty);
        this.getView().setVisibility(View.GONE);
        */
    }

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


        }
    }
}

公共类DeviceDetailFragment扩展片段实现ConnectionInfo Listener{
受保护的静态最终整数选择文件结果代码=20；
私有视图mContentView=null；
专用wifip2p设备；
私人WifiP2pInfo信息；
ProgressDialog=null；
TCPClient mTCPClient；
@凌驾
已创建ActivityState上的公共无效（Bundle savedInstanceState）{
super.onActivityCreated（savedInstanceState）；
}
@凌驾
CreateView上的公共视图（布局、充气机、视图组容器、捆绑包保存状态）{
mContentView=充气机。充气（R.layout.device\u详细信息，空）；
mContentView.findViewById（R.id.btn_connect）.setOnClickListener（新视图.OnClickListener（）{
@凌驾
公共void onClick（视图v）{
WifiP2pConfig config=新的WifiP2pConfig（）；
config.deviceAddress=device.deviceAddress；
config.wps.setup=WpsInfo.PBC；
if（progressDialog！=null&&progressDialog.isShowing（））{
progressDialog.disclose（）；
}
progressDialog=progressDialog.show（getActivity（），“按返回键取消”，
连接到：“+device.deviceAddress，true，true”
//新的DialogInterface.OnCancelListener（）{
//
//@覆盖
//public void onCancel（对话框接口对话框）{
//（（DeviceActionListener）
getActivity（））.cancelDisconnect（）；
//                            }
//                        }
);
（（DeviceListFragment.DeviceActionListener）getActivity（））.connect（配置）；
}
});
mContentView.findViewById（R.id.btn\u disconnect）.setOnClickListener(
新建视图。OnClickListener（）{
@凌驾
公共void onClick（视图v）{
（（DeviceListFragment.DeviceActionListener）getActivity（））.disconnect（）；
}
});
/*
mContentView.findviewbyd（R.id.btn\u start\u client）.setOnClickListener(
新建视图。OnClickListener（）{
@凌驾
公共void onClick（视图v）{
//允许用户从图库或其他图库中选择图像
//注册应用程序
意向意向=新意向（意向.行动\u获取\u内容）；
intent.setType（“image/*”）；
startActivityForResult（意图，选择文件\结果\代码）；
}
});
*/
返回mContentView；
}
@凌驾
连接信息可用的公共无效（最终WifiP2pInfo信息）{
if（progressDialog！=null&&progressDialog.isShowing（））{
progressDialog.disclose（）；
}
this.info=info；
this.getView（）.setVisibility（View.VISIBLE）；
//现在已知所有者IP。
TextView=（TextView）mContentView.findViewById（R.id.group\u所有者）；
view.setText（getResources（）.getString（R.string.group\u owner\u text）
+（（info.isGroupOwner==true）？getResources（）.getString（R.string.yes）
：getResources（）.getString（R.string.no））；
//WifiP2pInfo结构中的InetAddress。
视图=（TextView）mContentView.findViewById（R.id.device\u info）；
view.setText（“组所有者IP-”+info.groupOwnerAddress.getHostAddress（））；
if（info.groupFormed）{
新建ConnectTask（）。执行（“”）；
if（mTCPClient！=null）{
mTCPClient.sendMessage（“测试”）；
}
//将消息发送到服务器
}
//在组协商之后，我们指定组所有者作为文件
//文件服务器是单线程、单连接服务器
//插座。
/*
if（info.groupFormed&&info.isGroupOwner）{
新的FileServerAsyncTask（getActivity（），mContentView.findViewById（R.id.status_text））
.execute（）；
}
*/
//隐藏“连接”按钮
mContentView.findviewbyd（R.id.btn_connect）.setVisibility（View.GONE）；
}
/**
*使用设备数据更新UI
*
*@param device要显示的设备
*/
公共无效显示详细信息（WifiP2pDevice设备）{
这个装置=装置；
this.getView（）.setVisibility（View.VISIBLE）；
TextView=（TextView）mContentView.findViewById（R.id.device\u地址）；
view.setText（设备.设备地址）；
视图=（TextView）mContentView.findViewById（R.id.device\u info）；
view.setText（device.toString（））；
}
/**
*在断开连接或直接模式禁用操作后清除UI字段。
*/
公共视图（）{
mContentView.findviewbyd（R.id.btn_connect）.setVisibility（View.VISIBLE）；
TextView=（TextView）mContentView.findViewById（R.id.device\u地址）；
view.setText（R.string.empty）；
视图=（TextView）mContentView.findViewById（R.id.device\u info）；
view.setText（R.string.empty）；
view=（TextView）mContentView.findViewById（R.id.group\u所有者）；
view.setText（R.string.empty）；
/*
视图=（文本）