Android 在客户端上搜索服务器IP而不是输入

服务器：PC

客户：安卓

因此，我的客户端/服务器应用程序包括打开网页和执行bot，如果我只用于路由器，一切都很好，但我希望能够连接到不同的地方（不同的路由器/电脑）。 我正在搜索“Wi-fi IP搜索”，但什么也没有得到。 是否可以向服务器端提供修复IP？总是192.168.1.68

客户端代码

public class AndroidClient extends Activity 
{
    EditText episode;
    Spinner spinner1;
    String result;
    Button buttonConnect, buttonClear;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        episode = (EditText) findViewById(R.id.episode);
        buttonConnect = (Button) findViewById(R.id.connect);
        buttonClear = (Button) findViewById(R.id.clear);


        spinner1 = (Spinner) findViewById(R.id.Animes);
        ArrayAdapter<CharSequence> adapter = ArrayAdapter.createFromResource(this,
                R.array.Anime, android.R.layout.simple_spinner_item);
        adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
        spinner1.setAdapter(adapter);

        addListenerOnSpinnerItemSelection();


        addListenerOnButton();
    }

    public void addListenerOnSpinnerItemSelection() {

        spinner1.setOnItemSelectedListener(new CustomOnItemSelectedListener());
    }


    public void addListenerOnButton() {

        spinner1 = (Spinner) findViewById(R.id.Animes);

        buttonConnect = (Button) findViewById(R.id.connect);

        buttonConnect.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {

                MyClientTask myClientTask = new MyClientTask();

                myClientTask.execute();
            }

        });

    }


    public class MyClientTask extends AsyncTask<Void, Void, Void> {

        @Override
        protected Void doInBackground(Void... arg0) {

            Socket socket = null;
            DataOutputStream dataOutputStream = null;
            DataInputStream dataInputStream = null;

            try {
                socket = new Socket("10.1.3.68", 8080);
                dataOutputStream = new DataOutputStream(
                        socket.getOutputStream());
                dataInputStream = new DataInputStream(socket.getInputStream());
                dataOutputStream.writeUTF(episode.getText() + "-" + String.valueOf(spinner1.getSelectedItem()));

            } catch (UnknownHostException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();

            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();

            } finally {
                if (socket != null) {
                    try {
                        socket.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }

                if (dataOutputStream != null) {
                    try {
                        dataOutputStream.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }

                if (dataInputStream != null) {
                    try {
                        dataInputStream.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
            return null;
        }

        @Override
        protected void onPostExecute(Void result) {

        }

    }

}

公共类AndroidClient扩展活动
{
编辑文本插曲；
喷丝器喷丝器1；
字符串结果；
按钮连接，按钮滑动；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.main）；
插曲=（编辑文本）findViewById（R.id.Spidence）；
buttonConnect=（按钮）findViewById（R.id.connect）；
buttonClear=（按钮）findViewById（R.id.clear）；
spinner1=（Spinner）findViewById（R.id.Animes）；
ArrayAdapter=ArrayAdapter.createFromResource（此，
R.array.Anime，android.R.layout.simple\u spinner\u item）；
setDropDownViewResource（android.R.layout.simple\u微调器\u下拉菜单\u项）；
喷丝头1.设置适配器（适配器）；
addListenerOnSpinnerItemSelection（）；
addListenerOnButton（）；
}
public void addListenerOnSpinnerItemSelection（）{
spinner1.setOnItemSelectedListener（新CustomOnItemSelectedListener（））；
}
public void addListenerOnButton（）{
spinner1=（Spinner）findViewById（R.id.Animes）；
buttonConnect=（按钮）findViewById（R.id.connect）；
buttonConnect.setOnClickListener（新的OnClickListener（）{
@凌驾
公共void onClick（视图v）{
MyClientTask MyClientTask=新建MyClientTask（）；
myClientTask.execute（）；
}
});
}
公共类MyClientTask扩展了AsyncTask{
@凌驾
受保护的Void doInBackground（Void…arg0）{
套接字=空；
DataOutputStream DataOutputStream=null；
DataInputStream DataInputStream=null；
试一试{
插座=新插座（“10.1.3.68”，8080）；
dataOutputStream=新的dataOutputStream(
getOutputStream（））；
dataInputStream=新的dataInputStream（socket.getInputStream（））；
dataOutputStream.writeUTF（spinner1.getSelectedItem（））；
}捕获（未知后异常e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}最后{
if（套接字！=null）{
试一试{
socket.close（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
如果（dataOutputStream！=null）{
试一试{
dataOutputStream.close（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
如果（dataInputStream！=null）{
试一试{
dataInputStream.close（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
}
返回null；
}
@凌驾
受保护的void onPostExecute（void结果）{
}
}
}

服务器代码

public class ServerSide extends Application 
{
    TextField textTitle;
    Label labelSys, labelPort, labelIp;
    Label labelMsg;
    CheckBox optWelcome;

    ServerSocket serverSocket;

    String message = "";
    String result;

    @Override
    public void start(Stage primaryStage) {

        textTitle = new TextField();
        labelSys = new Label();
        labelPort = new Label();
        labelIp = new Label();
        labelMsg = new Label();




        labelIp.setText(getIpAddress());

        VBox mainLayout = new VBox();
        mainLayout.setPadding(new Insets(5, 5, 5, 5));
        mainLayout.setSpacing(5);
        mainLayout.getChildren().addAll(textTitle,
            labelSys, labelPort, labelIp,
             labelMsg);

        StackPane root = new StackPane();
        root.getChildren().add(mainLayout);

        Scene scene = new Scene(root, 300, 400);

        primaryStage.setTitle("One Piece");
        primaryStage.setScene(scene);
        primaryStage.show();

        Thread socketServerThread = new Thread(new SocketServerThread());
        socketServerThread.setDaemon(true); 
        socketServerThread.start();
    }

    public static void main(String[] args) {
        launch(args);
    }

    private class SocketServerThread extends Thread {

        static final int SocketServerPORT = 8080;
        int count = 0;

        @Override
        public void run() {
            try {
                Socket socket = null;

                serverSocket = new ServerSocket(SocketServerPORT);
                Platform.runLater(new Runnable() {

                    @Override
                    public void run() {
                        labelPort.setText("I'm waiting here: "
                            + serverSocket.getLocalPort());
                    }
                });

                while (true) {
                    socket = serverSocket.accept();
                    count++;

                    //Start another thread 
                    //to prevent blocked by empty dataInputStream
                    Thread acceptedThread = new Thread(
                        new ServerSocketAcceptedThread(socket, count));
                    acceptedThread.setDaemon(true); //terminate the thread when program end
                    acceptedThread.start();

                }
            } catch (IOException ex) {
                Logger.getLogger(ServerSide.class.getName()).log(Level.SEVERE, null, ex);
            }

        }

    }

    private class ServerSocketAcceptedThread extends Thread {

        Socket socket = null;
        DataInputStream dataInputStream = null;
        DataOutputStream dataOutputStream = null;
        int count;

        ServerSocketAcceptedThread(Socket s, int c) {
            socket = s;
            count = c;
        }

        @Override
        public void run() {
            try {

                dataInputStream = new DataInputStream(
                    socket.getInputStream());
                dataOutputStream = new DataOutputStream(
                    socket.getOutputStream());


                //If dataInputStream empty, 
                //this thread will be blocked by readUTF(),
                //but not the others
                String messageFromClient = dataInputStream.readUTF();


                message += "#" + count + " from " + socket.getInetAddress()
                        + ":" + socket.getPort() + "\n"
                        + "Msg from client: " + messageFromClient + "\n";

                    Platform.runLater(new Runnable() {

                        @Override
                        public void run() {
                            labelMsg.setText(message);
                        }
                    });
                    String string = messageFromClient;
                    String[] parts = string.split("-");
                    String episode = parts[0]; 
                    String anime = parts[1]; 
                    String OneP = new String("One Piece");
                    String Naruto = new String ("Naruto");
                    String Bleach = new String ("Bleach");





                    int EPnumb = Integer.parseInt(episode);

                    if (EPnumb < 10) { 
                        result = "00" + episode; 
                    }
                    else if (EPnumb < 100 && EPnumb >= 10) { 
                        result = "0" + episode; 
                    }
                    else { result = episode; }



                 if (anime.equals(OneP)){
                    try {
                      Desktop desktop = java.awt.Desktop.getDesktop();
                      URI oURL = new URI("http://kissanime.com/Anime/One-Piece/Episode-"+ result);
                      desktop.browse(oURL);
                    } catch (Exception e) {
                      e.printStackTrace();
                    }}


                    else {
                        try {
                              Desktop desktop = java.awt.Desktop.getDesktop();
                              URI oURL = new URI("http://kissanime.com/Anime/Naruto-Shippuuden/Episode-"+result);
                              desktop.browse(oURL);
                            } catch (Exception e) {
                              e.printStackTrace();
                            }

                    }





            } catch (IOException ex) {
                Logger.getLogger(ServerSide.class.getName()).log(Level.SEVERE, null, ex);
            } finally {




                if (socket != null) {
                    try {
                        socket.close();
                    } catch (IOException ex) {
                        Logger.getLogger(ServerSide.class.getName()).log(Level.SEVERE, null, ex);
                    }
                }

                if (dataInputStream != null) {
                    try {
                        dataInputStream.close();
                    } catch (IOException ex) {
                        Logger.getLogger(ServerSide.class.getName()).log(Level.SEVERE, null, ex);
                    }
                }

                if (dataOutputStream != null) {
                    try {
                        dataOutputStream.close();
                    } catch (IOException ex) {
                        Logger.getLogger(ServerSide.class.getName()).log(Level.SEVERE, null, ex);
                    }
                }
            }
        }

    }

    private java.lang.String parseInt(java.lang.String episode) {
            // TODO Auto-generated method stub
            return null;
        }

    private String getIpAddress() {
        String ip = "";
        try {
            Enumeration<NetworkInterface> enumNetworkInterfaces = NetworkInterface
                .getNetworkInterfaces();
            while (enumNetworkInterfaces.hasMoreElements()) {
                NetworkInterface networkInterface = enumNetworkInterfaces
                    .nextElement();
                Enumeration<InetAddress> enumInetAddress = networkInterface
                    .getInetAddresses();
                while (enumInetAddress.hasMoreElements()) {
                    InetAddress inetAddress = enumInetAddress.nextElement();

                    if (inetAddress.isSiteLocalAddress()) {
                        ip += "SiteLocalAddress: "
                            + inetAddress.getHostAddress() + "\n";
                    }
                }
            }
        } catch (SocketException ex) {
            Logger.getLogger(ServerSide.class.getName()).log(Level.SEVERE, null, ex);
        } 

        return ip;
    }

    public DataInputStream String(String string) {



        return null;
    }

}

公共类服务器端扩展应用程序
{
TextField textTitle；
标签标签，标签端口，标签标签；
标签labelMsg；
复选框optWelcome；
服务器套接字服务器套接字；
字符串消息=”；
字符串结果；
@凌驾
公共无效开始（阶段primaryStage）{
textTitle=新的TextField（）；
labelSys=新标签（）；
labelPort=新标签（）；
labelIp=新标签（）；
labelMsg=新标签（）；
setText（getIpAddress（））；
VBox mainLayout=新的VBox（）；
主布局。设置填充（新插图（5,5,5,5））；
主布局。设置间距（5）；
mainLayout.getChildren（）.addAll（textTitle，
labelSys，labelPort，labelIp，
labelMsg）；
StackPane root=新的StackPane（）；
root.getChildren（）.add（mainLayout）；
场景=新场景（根，300，400）；
初级阶段。片名（“一片”）；
初级阶段。场景（场景）；
primaryStage.show（）；
Thread socketServerThread=新线程（新的socketServerThread（））；
setDaemon（true）；
socketServerThread.start（）；
}
公共静态void main（字符串[]args）{
发射（args）；
}
私有类SocketServerThread扩展线程{
静态最终int SocketServerPORT=8080；
整数计数=0；
@凌驾
公开募捐{
试一试{
套接字=空；
serverSocket=新的serverSocket（SocketServerPORT）；
Platform.runLater（新的Runnable（）{
@凌驾
公开募捐{
setText（“我在这里等待：”
+serverSocket.getLocalPort（））；
}
});
while（true）{
socket=serverSocket.accept（）；
计数++；
//开始另一个线程
//防止被空dataInputStream阻塞
线程接受线程=新线程