Java Android聊天客户端：套接字连接

我是Android新手。首先，我用Java编写了一个聊天室客户端和服务器。它工作得很好

然后我尝试将其转换为一个正常工作的Android应用程序，我总是收到消息“无法连接到服务器！再试一次！”因此，套接字连接尝试显然有问题，但我不知道它是什么

背景知识：
-我已连接到我的根服务器，并查看聊天室服务器进程。它在跑
-我试图从PC上的另一个聊天室客户端连接到聊天室服务器。它起作用了
-主机和端口是正确的。检查了几次。
-权限已设置

-我可以在Nexus 5上运行应用程序
-LogCat或控制台中没有列出任何错误，看起来运行正常

我的聊天室客户端代码：

package de.Voldemord.chatter;
import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.*;
import java.io.*;
import java.net.*;
import java.util.*;

public class MainActivity extends Activity implements OnClickListener{
    private Button btn;
    private EditText et_send;
    private EditText et_chat;
    private String s_username = "Voldemord", s_host = "www.example.com";         // !Example host!
    private int s_port = 2222;                                                   // !Example port!
    private Socket socket = null;
    private BufferedReader in;
    private PrintWriter out;
    @SuppressWarnings({ "unchecked", "rawtypes" })
    ArrayList<String> users = new ArrayList();
    boolean isConnected = false;

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

    et_send = (EditText) findViewById(R.id.sendTextView);
    et_chat = (EditText) findViewById(R.id.chatTextView);

    btn = (Button) findViewById(R.id.btn);
    btn.setOnClickListener(this);


    if (isConnected == false){
        try{
            socket = new Socket(InetAddress.getByName(s_host), s_port);
            InputStreamReader streamreader = new InputStreamReader(socket.getInputStream());
            in = new BufferedReader(streamreader);
            out = new PrintWriter(socket.getOutputStream());
            out.println(s_username + ":has connected.:Connect");
            out.flush(); 
            isConnected = true; 
        }catch (Exception ex){
            et_chat.append("Cannot Connect! Try Again. \n"+ socket);
        }

        ListenThread();

    }else if (isConnected == true){
        et_chat.append("You are already connected. \n");
    }

}

protected void onDestroy(){
    super.onDestroy();
    sendDisconnect();
    Disconnect();
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    // Inflate the menu; this adds items to the action bar if it is present.
    getMenuInflater().inflate(R.menu.main, menu);
    return true;
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    // Handle action bar item clicks here. The action bar will
    // automatically handle clicks on the Home/Up button, so long
    // as you specify a parent activity in AndroidManifest.xml.
    int id = item.getItemId();
    if (id == R.id.action_settings) {
        return true;
    }
    return super.onOptionsItemSelected(item);
}

@Override
public void onClick(View v) {   
    String nothing = "";
    if ((et_send.getText()).equals(nothing)) {
        et_send.setText("");
        et_send.requestFocus();
    } else {
        try {
           out.println(s_username + ":" + et_send.getText() + ":" + "Chat");
           out.flush(); // flushes the buffer
        } catch (Exception ex) {
            et_chat.append("Message was not sent. \n");
        }
        et_send.setText("");
        et_send.requestFocus();
    }

    et_send.setText("");
    et_send.requestFocus();
}

public void sendDisconnect(){
    String bye = (s_username + ": :Disconnect");
    try{
        out.println(bye);
        out.flush();
    }catch (Exception e){
        et_chat.append("Could not send Disconnect message.\n");
    }
}

public void Disconnect(){
    try{
        et_chat.append("Disconnected.\n");
        socket.close();
    }catch (Exception e){
        et_chat.append("Failed to disconnect.\n");
    }
    isConnected = false;
}

public void ListenThread(){
    Thread IncomingReader = new Thread(new IncomingReader());
    IncomingReader.start();
}

public void userAdd(String user){
    users.add(user);
}

public void userRemove(String user){
    et_chat.append(user + " is now Offline.\n");
}

public class IncomingReader implements Runnable{
    @Override
    public void run(){
        String[] data;
        String stream, done = "Done", connect = "Connect", disconnect = "Disconnect", chat = "Chat", shutdown = "Shutdown";

        try{
            while ((stream = in.readLine()) != null){
                 data = stream.split(":");

                 if(data[data.length-1].equals(shutdown)){ 
                    if(data[0].equals("Server")){
                        et_chat.append("Server: The Server is Shutting down!\n");
                    }
                    sendDisconnect();
                    Disconnect();
                 }else if (data[data.length-1].equals(chat)){
                    et_chat.append(data[0] + ": " + extract(stream) + "\n");
                   // et_chat.setCaretPosition(et_chat.getDocument().getLength());
                 }else if (data[data.length-1].equals(connect)){
                    userAdd(data[0]);
                 }else if (data[data.length-1].equals(disconnect)){
                     userRemove(data[0]);
                 }else if (data[data.length-1].equals(done)){
                    users.clear();
                 }
            }
       }catch(Exception ex){ 

       }
    }

    private String extract(String input) {
        for(int i=0;i<input.length();i++){
            if(input.charAt(i) == ':'){
                input =  input.substring(i+1,input.length()-5);
                break;
            }
        } 
        return input;
    }
}


}  

package de.Voldemord.chatter；
导入android.app.Activity；
导入android.os.Bundle；
导入android.view.Menu；
导入android.view.MenuItem；
导入android.view.view；
导入android.view.view.OnClickListener；
导入android.widget.*；
导入java.io.*；
导入java.net。*；
导入java.util.*；
公共类MainActivity扩展活动实现OnClickListener{
专用按钮btn；
私人编辑文本发送；
私人编辑文本聊天；
私有字符串s_username=“Voldemord”，s_host=“www.example.com”；/！example host！
专用int s_端口=2222；//！示例端口！
私有套接字=空；
中的私有缓冲区读取器；
私人打印输出；
@SuppressWarnings（{“unchecked”，“rawtypes”}）
ArrayList用户=新建ArrayList（）；
布尔值未连接=假；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
et_send=（EditText）findViewById（R.id.sendTextView）；
et_chat=（EditText）findViewById（R.id.chatTextView）；
btn=（按钮）findViewById（R.id.btn）；
btn.setOnClickListener（此）；
如果（断开连接==错误）{
试一试{
套接字=新套接字（InetAddress.getByName（s\u主机）、s\u端口）；
InputStreamReader streamreader=新的InputStreamReader（socket.getInputStream（））；
in=新的BufferedReader（streamreader）；
out=新的PrintWriter（socket.getOutputStream（））；
out.println（s_username+“：has connected.：Connect”）；
out.flush（）；
断开连接=正确；
}捕获（例外情况除外）{
et_chat.append（“无法连接！重试。\n”+套接字）；
}
ListenThread（）；
}else if（未连接==真）{
et_chat.append（“您已连接。\n”）；
}
}
受保护的空onDestroy（）{
super.ondestory（）；
sendDisconnect（）；
断开连接（）；
}
@凌驾
公共布尔onCreateOptions菜单（菜单）{
//为菜单充气；这会将项目添加到操作栏（如果存在）。
getMenuInflater（）.充气（R.menu.main，menu）；
返回true；
}
@凌驾
公共布尔值onOptionsItemSelected（菜单项项）{
//处理操作栏项目单击此处。操作栏将
//自动处理Home/Up按钮上的点击，只要
//在AndroidManifest.xml中指定父活动时。
int id=item.getItemId（）；
if（id==R.id.action\u设置）{
返回true；
}
返回super.onOptionsItemSelected（项目）；
}
@凌驾
公共void onClick（视图v）{
字符串nothing=“”；
如果（（et_send.getText（））.equals（nothing））{
et_send.setText（“”）；
et_send.requestFocus（）；
}否则{
试一试{
out.println（s_username+“：“+et_send.getText（）+”：“+”Chat”）；
out.flush（）；//刷新缓冲区
}捕获（例外情况除外）{
et_chat.append（“消息未发送。\n”）；
}
et_send.setText（“”）；
et_send.requestFocus（）；
}
et_send.setText（“”）；
et_send.requestFocus（）；
}
公共无效发送断开连接（）{
字符串bye=（s_username+“：：Disconnect”）；
试一试{
out.println（再见）；
out.flush（）；
}捕获（例外e）{
et_chat.append（“无法发送断开连接消息。\n”）；
}
}
公共空间断开连接（）{
试一试{
et_chat.append（“断开连接”。\n”）；
socket.close（）；
}捕获（例外e）{
et_chat.append（“断开连接失败。\n”）；
}
断开连接=错误；
}
public void ListenThread（）{
Thread IncomingReader=新线程（new IncomingReader（））；
IncomingReader.start（）；
}
公共void userAdd（字符串用户）{
用户。添加（用户）；
}
公共void userRemove（字符串用户）{
et_chat.append（user+“现在脱机。\n”）；
}
公共类IncomingReader实现Runnable{
@凌驾
公开募捐{
字符串[]数据；
字符串流，done=“done”，connect=“connect”，disconnect=“disconnect”，chat=“chat”，shutdown=“shutdown”；
试一试{
而（（stream=in.readLine（））！=null）{
数据=stream.split（“：”）；
如果（data[data.length-1].equals（shutdown））{
如果（数据[0]。等于（“服务器”））{
et_chat.append（“服务器：服务器正在关闭！\n”）；
}
sendDisconnect（）；
断开连接（）；
}else if（data[data.length-1].equals（chat））{
et_chat.append（数据[0]+“：”+提取（流）+“\n”）；
//et_chat.setCaretPosition（et_chat.getDocument（）.getLength（））；
}else if（data[data.length-1].equals（connect））{
userAdd（数据[0]）；
}else if（数据[data.length-1].equals（断开连接））{
userRemove（数据[0]）；
}else if（data[data.length-1].equals（done））{
user.clear（）；
}
}
}捕获（例外情况除外）{
}
}
私有字符串提取（字符串输入）{
对于
import java.awt.EventQueue;
import java.io.*;
import java.net.*;
import java.util.*;

public class root_Chat_Server{
    private ServerStart serverStart;
    private boolean isStarted = false;
    private Thread starter;

@SuppressWarnings("rawtypes")
ArrayList clientOutputStreams;
@SuppressWarnings("rawtypes")
ArrayList clientHandler;
ArrayList<String> users;
/**
 * Create the application.
 */

 public class ClientHandler implements Runnable{
       BufferedReader reader;
       Socket sock;
       PrintWriter client;

       public ClientHandler(Socket clientSocket, PrintWriter user){
            client = user;
            try{
                sock = clientSocket;
                InputStreamReader isReader = new InputStreamReader(sock.getInputStream());
                reader = new BufferedReader(isReader);
            }
            catch (Exception ex){
                System.out.print("Unexpected error... \n");
            }
       }

       @Override
       public void run(){
            String message, connect = "Connect", disconnect = "Disconnect", chat = "Chat" ;
            String[] data;

            try{
                while ((message = reader.readLine()) != null){
                    System.out.print("Received: " + message + "\n");
                    data = message.split(":");

                    for (String token:data){
                        System.out.print(token + "\n");
                    }

                    if (data[data.length-1].equals(connect)){
                        tellEveryone((data[0] + ":" + data[1] + ":" + chat));
                        userAdd(data[0]);
                    }else if (data[data.length-1].equals(disconnect)){
                        tellEveryone((data[0] + ":has disconnected." + ":" + chat));
                        userRemove(data[0]);
                    }else if (data[data.length-1].equals(chat)){
                        System.out.print("\n\n"+ message +"\n\n");
                        tellEveryone(message);
                    }else{
                        System.out.print("No Conditions were met. \n");
                    }
                } 
             }catch (Exception ex){
                System.out.print("Lost a connection. \n");
                ex.printStackTrace();
                clientOutputStreams.remove(client);
             } 
       }
       public void stop() throws IOException{
           sock.close();
       }
 }

public root_Chat_Server() {

}

private void start(){
    if(!isStarted){
        starter = new Thread(serverStart = new ServerStart());
        starter.start();

        System.out.print("Server started...\n");
        isStarted = true;
    }
}


private void stop(){
    try{
        tellEveryone("Server:Shutdown");
        Thread.sleep(2000);
        serverStart.stop();
        isStarted = false;
    }catch (InterruptedException | IOException ex){
        Thread.currentThread().interrupt();
    }
    System.out.print("Server is stopping...\n\n\n");
}

private void users(){
    System.out.print("\nOnline Users:\n");

    for(String current_users : users){
        System.out.print("-" + current_users + "\n");
    }
}

public class ServerStart implements Runnable{
    ServerSocket serverSock;
    Socket clientSock;
    @SuppressWarnings({ "rawtypes", "unchecked" })
    @Override
    public void run(){
        clientOutputStreams = new ArrayList();
        users = new ArrayList();  
        clientHandler = new ArrayList();
        ClientHandler clientHand;

        try{
            serverSock = new ServerSocket(2222);

            while (true){
                clientSock = serverSock.accept();
                PrintWriter writer = new PrintWriter(clientSock.getOutputStream());
                clientOutputStreams.add(writer);

                Thread listener = new Thread(clientHand = new ClientHandler(clientSock, writer));
                clientHandler.add(clientHand);
                listener.start();
                System.out.print("Got a connection. \n");
            }
        }catch (Exception ex){
            System.out.print("Error making a connection. \n");
        }
    }

    private void stop() throws IOException{
        if(serverSock != null && clientSock != null){
            serverSock.close();
            clientSock.close();
        }else if(serverSock != null){
            serverSock.close();
        }
    }
}

public void userAdd (String data){
    String message, add = ": :Connect", done = "Server: :Done", name = data;
    if(!users.contains(name)){
        System.out.print("Before " + name + " added. \n");
        users.add(name);
        System.out.print("After " + name + " added. \n");
        String[] tempList = new String[(users.size())];
        users.toArray(tempList);

        for (String token:tempList){
            message = (token + add);
            tellEveryone(message);
        }
        tellEveryone(done);
    }else{
        PrintWriter writer = (PrintWriter)clientOutputStreams.get(clientOutputStreams.size()-1);
        ClientHandler clientHand = (ClientHandler)clientHandler.get(clientHandler.size()-1);
        writer.println("Disconnect:Shutdown");
        writer.flush();
        try {
            clientHand.stop();
        } catch (IOException e) {
            e.printStackTrace();
        }
        clientHandler.remove(clientHandler.size()-1);
        clientOutputStreams.remove(clientOutputStreams.size()-1);
    }
}

public void userRemove (String data){
    String message, add = ": :Connect", done = "Server: :Done", name = data;
    users.remove(name);
    String[] tempList = new String[(users.size())];
    users.toArray(tempList);

    for (String token:tempList){
        message = (token + add);
        tellEveryone(message);
    }
    tellEveryone(done);
}

@SuppressWarnings("rawtypes")
public void tellEveryone(String message){
Iterator it = clientOutputStreams.iterator();

    while (it.hasNext()){
        try{
            PrintWriter writer = (PrintWriter) it.next();
            writer.println(message);
            System.out.print("Sending: " + message + "\n");
            writer.flush();
        }catch (Exception ex){
            System.out.print("Error telling everyone. \n");
        }
    } 
}

/**
 * Launch the application.
 */
public static void main(String[] args){
    EventQueue.invokeLater(new Runnable(){
        public void run(){
            if(args.length == 1){
                root_Chat_Server server = new root_Chat_Server();
                if(args[0].equals("start")){
                    server.start();
                }else if(args[0].equals("stop")){
                    server.stop();
                }else if(args[0].equals("users")){
                    server.users();
                }
            }else{
                System.out.println("java root_Chat_Server start|stop|users");
            }
        }
    });
}
}