通过android DLL实现统一android wifi套接字通信

我们能够在两个本地android应用程序和两个基于Unity的android应用程序之间建立socket wifi聊天。现在，根据新的要求，我们需要开发两个unity应用程序，这两个应用程序都有android dll和客户端和服务器代码

我们需要通过这些DLL连接两个基于unity的android应用程序，然后，我们需要开始它们之间的通信

Android服务器DLL

public class Server {
    Activity activity;
    ServerSocket serverSocket;
    String message = "";
    static final int socketServerPORT = 8082;

    private static volatile Server sSoleInstance;

    //private constructor.
    private Server(Activity activity) {

        //Prevent form the reflection api.
        if (sSoleInstance != null) {
            throw new RuntimeException("Use getInstance() method to get the single instance of this class.");
        } else {
            this.activity = activity;
            Thread socketServerThread = new Thread(new SocketServerThread());
            socketServerThread.start();
        }
    }

    public static Server getInstance(Activity activity) {
        if (sSoleInstance == null) { //if there is no instance available... create new one
            synchronized (Client.class) {
                if (sSoleInstance == null) sSoleInstance = new Server(activity);
            }
        }

        return sSoleInstance;
    }

/*  public Server(Activity activity) {
        this.activity = activity;
        Thread socketServerThread = new Thread(new SocketServerThread());
        socketServerThread.start();
    }*/

    public int getPort() {
        return socketServerPORT;
    }

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

    private class SocketServerThread extends Thread {

        int count = 0;

        @Override
        public void run() {
            try {
                serverSocket = new ServerSocket(socketServerPORT);

                while (true) {
                    Socket socket = serverSocket.accept();
                    count++;
                    message += "#" + count + " from "
                            + socket.getInetAddress() + ":"
                            + socket.getPort() + "\n";

                    activity.runOnUiThread(new Runnable() {

                        @Override
                        public void run() {
                            //activity.msg.setText(message);
                            Log.e("server message", message);
                        }
                    });

                    SocketServerReplyThread socketServerReplyThread = new SocketServerReplyThread(
                            socket, count);
                    socketServerReplyThread.run();

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

    }

    private class SocketServerReplyThread extends Thread {

        private Socket hostThreadSocket;
        int cnt;

        SocketServerReplyThread(Socket socket, int c) {
            hostThreadSocket = socket;
            cnt = c;
        }

        @Override
        public void run() {
            OutputStream outputStream;
            String msgReply = "Hello from Server, you are #" + cnt;

            try {
                outputStream = hostThreadSocket.getOutputStream();
                PrintStream printStream = new PrintStream(outputStream);
                printStream.print(msgReply);
                printStream.close();

                message += "replayed: " + msgReply + "\n";

                activity.runOnUiThread(new Runnable() {

                    @Override
                    public void run() {
                    //  activity.msg.setText(message);
                        Log.e("server message", message);
                    }
                });

            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                message += "Something wrong! " + e.toString() + "\n";
            }

            activity.runOnUiThread(new Runnable() {

                @Override
                public void run() {
                    Log.e("server message", message);
                    //activity.msg.setText(message);
                }
            });
        }

    }

    public 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 += "Server running at : "
                                + inetAddress.getHostAddress();
                    }
                }
            }

        } catch (SocketException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            ip += "Something Wrong! " + e.toString() + "\n";
        }
        return ip;
    }
}

公共类服务器{
活动；
服务器套接字服务器套接字；
字符串消息=”；
静态最终int socketServerPORT=8082；
私有静态易失性服务器ssolenstance；
//私有构造函数。
专用服务器（活动）{
//防止反射api。
if（sSoleInstance！=null）{
抛出新的RuntimeException（“使用getInstance（）方法获取该类的单个实例。”）；
}否则{
这个。活动=活动；
Thread socketServerThread=新线程（新的socketServerThread（））；
socketServerThread.start（）；
}
}
公共静态服务器getInstance（活动）{
如果（sSoleInstance==null）{//如果没有可用的实例…创建一个新实例
已同步（Client.class）{
if（sSoleInstance==null）sSoleInstance=新服务器（活动）；
}
}
返回信度；
}
/*公共服务器（活动）{
这个。活动=活动；
Thread socketServerThread=新线程（新的socketServerThread（））；
socketServerThread.start（）；
}*/
公共int getPort（）{
返回socketServerPORT；
}
公共空间{
if（serverSocket！=null）{
试一试{
serverSocket.close（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
}
私有类SocketServerThread扩展线程{
整数计数=0；
@凌驾
公开募捐{
试一试{
serverSocket=新的serverSocket（socketServerPORT）；
while（true）{
Socket=serverSocket.accept（）；
计数++；
消息+=“#”+计数+“来自”
+socket.getInetAddress（）+“：”
+socket.getPort（）+“\n”；
activity.runOnUiThread（新的Runnable（）{
@凌驾
公开募捐{
//activity.msg.setText（消息）；
Log.e（“服务器消息”，消息）；
}
});
SocketServerReplyThread SocketServerReplyThread=新的SocketServerReplyThread(
插座，计数）；
socketServerReplyThread.run（）；
}
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
}
私有类SocketServerReplyThread扩展线程{
私有套接字hostThreadSocket；
int-cnt；
SocketServerReplyThread（Socket-Socket，int-c）{
hostThreadSocket=套接字；
cnt=c；
}
@凌驾
公开募捐{
输出流输出流；
String msgReply=“你好，来自服务器，您是#”+cnt；
试一试{
outputStream=hostThreadSocket.getOutputStream（）；
PrintStream PrintStream=新的PrintStream（outputStream）；
printStream.print（msgReply）；
printStream.close（）；
消息+=“重播：”+msgReply+“\n”；
activity.runOnUiThread（新的Runnable（）{
@凌驾
公开募捐{
//activity.msg.setText（消息）；
Log.e（“服务器消息”，消息）；
}
});
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
消息+=“有问题！”+e.toString（）+“\n”；
}
activity.runOnUiThread（新的Runnable（）{
@凌驾
公开募捐{
Log.e（“服务器消息”，消息）；
//activity.msg.setText（消息）；
}
});
}
}
公共字符串getIpAddress（）{
字符串ip=“”；
试一试{
枚举enumNetworkInterfaces=网络接口
.getNetworkInterfaces（）；
while（enumNetworkInterfaces.hasMoreElements（））{
NetworkInterface NetworkInterface=EnumNetworkInterface
.nextElement（）；
枚举enumInetAddress=网络接口
.getInetAddresses（）；
while（enumInetAddress.hasMoreElements（））{
InetAddress InetAddress=enumInetAddress
.nextElement（）；
if（inetAddress.isSiteLocalAddress（））{
ip+=“运行在以下位置的服务器：”
+inetAddress.getHostAddress（）；
}
}
}
}捕获（SocketException e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
ip++=“有问题！”+e.toString（）+“\n”；
}
返回ip；
}
}

Android客户端DLL代码

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

    String dstAddress;
    int dstPort = 8082;
    String response = "";
    String textResponse;

    private static volatile Client sSoleInstance;

    //private constructor.
    private Client(String addr, String textRespons) {

        //Prevent form the reflection api.
        if (sSoleInstance != null) {
            throw new RuntimeException("Use getInstance() method to get the single instance of this class.");
        } else {
           dstAddress = addr;
           this.textResponse = textRespons;
           execute();
        }
    }

    public static Client getInstance(String addr, String textRespons) {
        if (sSoleInstance == null) { //if there is no instance available... create new one
            synchronized (Client.class) {
                if (sSoleInstance == null) sSoleInstance = new Client(addr, textRespons);
            }
        }

        return sSoleInstance;
    }

    //Make singleton from serialize and deserialize operation.
   /* protected Client readResolve() {
        return getInstance();
    }*/

    /*Client(String addr,  String textResponse) {
        dstAddress = addr;
        //dstPort = port;
        this.textResponse = textResponse;
    }
*/
    @Override
    protected Void doInBackground(Void... arg0) {

        Socket socket = null;

        try {
            socket = new Socket(dstAddress, dstPort);

            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(
                    1024);
            byte[] buffer = new byte[1024];

            int bytesRead;
            InputStream inputStream = socket.getInputStream();

            /*
             * notice: inputStream.read() will block if no data return
             */
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                byteArrayOutputStream.write(buffer, 0, bytesRead);
                response += byteArrayOutputStream.toString("UTF-8");
            }

        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            response = "UnknownHostException: " + e.toString();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            response = "IOException: " + e.toString();
        } finally {
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        return null;
    }

    @Override
    protected void onPostExecute(Void result) {
        Log.e("Client response",response);
        //textResponse.setText(response);
        super.onPostExecute(result);
    }

}

公共类客户端扩展异步任务{
字符串地址；
int dstPort=8082；
字符串响应=”；
字符串文本响应；
私有静态易失性客户端；
//私有构造函数。
专用客户端（字符串地址、字符串文本响应）{
 string ipAddress = inputFieldMacAddress.text.ToString();
        string response = "message";

        AndroidJavaClass myAndroidClass = new AndroidJavaClass("com.braintech.commoncommunicationport.socket_client.ClientMainClass");
        AndroidJavaClass unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
        AndroidJavaObject activity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity");
        AndroidJavaObject myAndroidPlugin = myAndroidClass.CallStatic<AndroidJavaObject>("getInstance", ipAddress, response);

        myAndroidPlugin.Call("startClient", ipAddress, response); 

   AndroidJavaClass myAndroidClass = new AndroidJavaClass("com.braintech.commoncommunicationport.socket_server.Server");
        AndroidJavaClass unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
        AndroidJavaObject activity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity");
        AndroidJavaObject myAndroidPlugin = myAndroidClass.CallStatic<AndroidJavaObject>("getInstance", activity);
      int port=  myAndroidPlugin.Call<int>("getPort");