POSIX Socket API

Socket 通信分为三种：

1、面向连接的通信TCP；

2、无连接的通信UDP；

3、本地通信Local

将 Android Emulator 上的 <port number> 与主机上的 <port number> 映射。任何输入到主机上端口号所指定端口的连接都会通过 adb 转发到 Android Emulator 的指定端口上。

adb -s emulator-5556 forward tcp:57102 tcp:57102

 本地 socket 族既支持基于流的 socket 协议，也支持基于数据报的 socket 协议。

AbstractEchoActivity.java

package com.apress.echo;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ScrollView;
import android.widget.TextView;

/**
 * Abstract echo activity object.
 * 
 * @author Onur Cinar
 */
public abstract class AbstractEchoActivity extends Activity implements  OnClickListener {
    /** Port number. 端口号 */
    protected EditText portEdit;

    /** Server button. 服务按钮 */
    protected Button startButton;

    /** Log scroll. 日志滚动 */
    protected ScrollView logScroll;

    /** Log view. 日志视图 */
    protected TextView logView;

    /** Layout ID. 布局ID */
    private final int layoutID;

    /**
     * Constructor. 构造函数
     * 
     * @param layoutID
     *            layout ID.
     */
    public AbstractEchoActivity(int layoutID) {
        // 绑定用户界面组件
        this.layoutID = layoutID;
    }

    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(layoutID);

        portEdit = (EditText) findViewById(R.id.port_edit);
        startButton = (Button) findViewById(R.id.start_button);
        logScroll = (ScrollView) findViewById(R.id.log_scroll);
        logView = (TextView) findViewById(R.id.log_view);

        startButton.setOnClickListener(this);
    }

    public void onClick(View view) {
        if (view == startButton) {
            onStartButtonClicked();
        }
    }

    /**
     * On start button clicked.
     */
    protected abstract void onStartButtonClicked();

    /**
     * Gets the port number as an integer.以整型获取端口号
     * 
     * @return port number or null.
     */
    protected Integer getPort() {
        Integer port;

        try {
            port = Integer.valueOf(portEdit.getText().toString());
        } catch (NumberFormatException e) {
            port = null;
        }

        return port;
    }

    /**
     * Logs the given message. 记录给定的消息
     * 
     * @param message
     *            log message. 日志消息
     */
    protected void logMessage(final String message) {
        runOnUiThread(new Runnable() {
            public void run() {
                logMessageDirect(message);
            }
        });
    }

    /**
     * Logs given message directly. 直接记录给定的消息
     * 
     * @param message
     *            log message. 日志消息
     */
    protected void logMessageDirect(final String message) {
        logView.append(message);
        logView.append("\n");
        logScroll.fullScroll(View.FOCUS_DOWN);
    }
    
    /**
     * Abstract async echo task. 抽象异步 echo 任务
     * 应用在一个单独的线程而不是UI线程中执行网络操作
     */
    protected abstract class AbstractEchoTask extends Thread {
        /** Handler object. 对象 */
        private final Handler handler;
        
        /**
         * Constructor. 构造函数
         */
        public AbstractEchoTask() {
            handler = new Handler();
        }
        
        /**
         * On pre execute callback in calling thread. 
         * 在调用线程中先执行回调
         */
        protected void onPreExecute() {
            startButton.setEnabled(false);
            logView.setText("");
        }

        public synchronized void start() {
            onPreExecute();            
            super.start();
        }

        public void run() {
            onBackground();
            
            handler.post(new Runnable() {
                public void run() {
                    onPostExecute();
                }
            });
        }

        /**
         * On background callback in new thread.
         * 在新线程中的背景回调
         */
        protected abstract void onBackground();

        /**
         * On post execute callback in calling thread.
         * 在调用线程中后执行回调
         */
        protected void onPostExecute() {
            startButton.setEnabled(true);
        }
    }

    static {
        System.loadLibrary("Echo");
    }
}

EchoClientActivity.java

package com.apress.echo;

import android.os.Bundle;
import android.widget.EditText;

/**
 * Echo client.
 * 
 * @author Onur Cinar
 */
public class EchoClientActivity extends AbstractEchoActivity {    
    /** IP address. */
    private EditText ipEdit;

    /** Message edit. 消息编辑 */
    private EditText messageEdit;

    /**
     * Constructor. 构造函数
     */
    public EchoClientActivity() {
        super(R.layout.activity_echo_client);
    }

    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        ipEdit = (EditText) findViewById(R.id.ip_edit);
        messageEdit = (EditText) findViewById(R.id.message_edit);
    }

    protected void onStartButtonClicked() {
        String ip = ipEdit.getText().toString();
        Integer port = getPort();
        String message = messageEdit.getText().toString();

        if ((0 != ip.length()) && (port != null) && (0 != message.length())) {
            ClientTask clientTask = new ClientTask(ip, port, message);
            clientTask.start();
        }
    }

    /**
     * Starts the TCP client with the given server IP address and port number,
     * and sends the given message.
     * 根据给定服务器IP 地址和端口号启动TCP客户端，并且发送给定消息
     * 
     * @param ip
     *            IP address.
     * @param port
     *            port number.
     * @param message
     *            message text.
     * @throws Exception
     */
    private native void nativeStartTcpClient(String ip, int port, String message)
            throws Exception;

    /**
     * Starts the UDP client with the given server IP address and port number.
     * 
     * @param ip
     *            IP address.
     * @param port
     *            port number.
     * @param message
     *            message text.
     * @throws Exception
     */
    private native void nativeStartUdpClient(String ip, int port, String message)
            throws Exception;

    /**
     * Client task. 客户端任务
     */
    private class ClientTask extends AbstractEchoTask {
        /** IP address to connect. 连接的IP地址 */
        private final String ip;

        /** Port number. 端口号 */
        private final int port;

        /** Message text to send. 发送的消息文本 */
        private final String message;

        /**
         * Constructor. 构造函数
         * 
         * @param ip
         *            IP address to connect.
         * @param port
         *            port number to connect.
         * @param message
         *            message text to send.
         */
        public ClientTask(String ip, int port, String message) {
            this.ip = ip;
            this.port = port;
            this.message = message;
        }

        protected void onBackground() {
            logMessage("Starting client.");

            try {
                nativeStartTcpClient(ip, port, message);
                //nativeStartUdpClient(ip, port, message);
            } catch (Throwable e) {
                logMessage(e.getMessage());
            }

            logMessage("Client terminated.");
        }
    }
}

EchoServerActivity .java

package com.apress.echo;

/**
 * Echo server.
 * 
 * @author Onur Cinar
 */
public class EchoServerActivity extends AbstractEchoActivity {
    /**
     * Constructor. 构造函数
     */
    public EchoServerActivity() {
        super(R.layout.activity_echo_server);
    }

    protected void onStartButtonClicked() {
        Integer port = getPort();
        if (port != null) {
            ServerTask serverTask = new ServerTask(port);
            serverTask.start();
        }
    }

    /**
     * Starts the TCP server on the given port.
     * 根据给定端口启动 TCP 服务
     * 
     * @param port
     * 端口号          port number.
     * @throws Exception
     */
    private native void nativeStartTcpServer(int port) throws Exception;

    /**
     * Starts the UDP server on the given port.
     * 根据给定端口启动 UDP 服务
     * 
     * @param port
     * 端口号           port number.
     * @throws Exception
     */
    private native void nativeStartUdpServer(int port) throws Exception;

    /**
     * Server task. 服务端任务
     */
    private class ServerTask extends AbstractEchoTask {
        /** 端口号  Port number. */
        private final int port;
        
        /**
         * Constructor.构造函数
         * 
         * @param port
         * 端口号           port number.
         */
        public ServerTask(int port) {
            this.port = port;
        }

        protected void onBackground() {
            logMessage("Starting server.");

            try {
                nativeStartTcpServer(port);
                //nativeStartUdpServer(port);
            } catch (Exception e) {
                logMessage(e.getMessage());
            }

            logMessage("Server terminated.");
        }
    }
}

LocalEchoActivity.java

package com.apress.echo;

import java.io.File;
import java.io.InputStream;
import java.io.OutputStream;

import android.net.LocalSocket;
import android.net.LocalSocketAddress;
import android.os.Bundle;
import android.widget.EditText;

/**
 * Echo local socket server and client.
 * Echo 本地 socket 服务器和客户端
 * 
 * @author Onur Cinar
 */
public class LocalEchoActivity extends AbstractEchoActivity {
    /** Message edit. 消息编辑 */
    private EditText messageEdit;

    /**
     * Constructor. 构造函数
     */
    public LocalEchoActivity() {
        super(R.layout.activity_local_echo);
    }

    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        messageEdit = (EditText) findViewById(R.id.message_edit);
    }

    protected void onStartButtonClicked() {
        String name = portEdit.getText().toString();
        String message = messageEdit.getText().toString();

        if ((name.length() > 0) && (message.length() > 0)) {
            String socketName;

            // If it is a filesystem socket, prepend the application files directory
            // 如果是 filesystem socket，预先准备应用程序的文件目录
            if (isFilesystemSocket(name)) {
                File file = new File(getFilesDir(), name);
                socketName = file.getAbsolutePath();
            } else {
                socketName = name;
            }

            ServerTask serverTask = new ServerTask(socketName);
            serverTask.start();

            ClientTask clientTask = new ClientTask(socketName, message);
            clientTask.start();
        }
    }

    /**
     * Check if name is a filesystem socket.
     * 检查名称是否是 filesystem socket
     * 
     * @param name
     *            socket name.
     * @return filesystem socket.
     */
    private boolean isFilesystemSocket(String name) {
        return name.startsWith("/");
    }

    /**
     * Starts the Local UNIX socket server binded to given name.
     * 启动绑定到给定名称的本地 UNIX socket 服务器
     * 
     * @param name
     *            socket name.
     * @throws Exception
     */
    private native void nativeStartLocalServer(String name) throws Exception;

    /**
     * Starts the local UNIX socket client.
     * 启动本地 UNXI socket 客户端
     * 
     * @param port
     *            port number.
     * @param message
     *            message text.
     * @throws Exception
     */
    private void startLocalClient(String name, String message) throws Exception {
        // Construct a local socket 构造一个本地 socket
        LocalSocket clientSocket = new LocalSocket();
        try {
            // Set the socket namespace 设置 socket 名称空间
            LocalSocketAddress.Namespace namespace;
            if (isFilesystemSocket(name)) {
                namespace = LocalSocketAddress.Namespace.FILESYSTEM;
            } else {
                namespace = LocalSocketAddress.Namespace.ABSTRACT;
            }
    
            // Construct local socket address 构造本地 socket 地址
            LocalSocketAddress address = new LocalSocketAddress(name, namespace);
    
            // Connect to local socket 连接到本地 socket
            logMessage("Connecting to " + name);        
            clientSocket.connect(address);
            logMessage("Connected.");
            
            // Get message as bytes 以字节形式获取消息
            byte[] messageBytes = message.getBytes();
            
            // Send message bytes to the socket 发送消息字节到 socket 
            logMessage("Sending to the socket...");
            OutputStream outputStream = clientSocket.getOutputStream();
            outputStream.write(messageBytes);
            logMessage(String.format("Sent %d bytes: %s", messageBytes.length, message));
                        
            // Receive the message back from the socket 从 socket 中接收消息返回
            logMessage("Receiving from the socket...");
            InputStream inputStream = clientSocket.getInputStream();
            int readSize = inputStream.read(messageBytes);
            
            String receivedMessage = new String(messageBytes, 0, readSize);
            logMessage(String.format("Received %d bytes: %s", readSize, receivedMessage));
            
            // Close streams 关闭流
            outputStream.close();
            inputStream.close();
            
        } finally { 
            // Close the local socket 关闭本地 socket
            clientSocket.close();
        }
    }

    /**
     * Server task. 服务器任务
     */
    private class ServerTask extends AbstractEchoTask {
        /** Socket name. */
        private final String name;

        /**
         * Constructor. 构造函数
         * 
         * @param name
         *            socket name.
         */
        public ServerTask(String name) {
            this.name = name;
        }

        protected void onBackground() {
            logMessage("Starting server.");

            try {
                nativeStartLocalServer(name);
            } catch (Exception e) {
                logMessage(e.getMessage());
            }

            logMessage("Server terminated.");
        }
    }

    /**
     * Client task. 客户端任务
     */
    private class ClientTask extends Thread {
        /** Socket name. */
        private final String name;

        /** Message text to send. 发送的消息文本 */
        private final String message;

        /**
         * Constructor. 构造函数
         * 
         * @parma name socket name.
         * @param message
         *            message text to send.
         */
        public ClientTask(String name, String message) {
            this.name = name;
            this.message = message;
        }

        public void run() {
            logMessage("Starting client.");

            try {
                startLocalClient(name, message);
            } catch (Exception e) {
                logMessage(e.getMessage());
            }

            logMessage("Client terminated.");
        }
    }
}

原生代码 Echo.cpp

#include "com_apress_echo_EchoClientActivity.h"
#include "com_apress_echo_EchoServerActivity.h"
#include "com_apress_echo_LocalEchoActivity.h"

// JNI
#include <jni.h>

// NULL
#include <stdio.h>

// va_list, vsnprintf
#include <stdarg.h>

// errno
#include <errno.h>

// strerror_r, memset
#include <string.h>

// socket, bind, getsockname, listen, accept, recv, send, connect
#include <sys/types.h>
#include <sys/socket.h>

// sockaddr_un
#include <sys/un.h>

// htons, sockaddr_in
#include <netinet/in.h>

// inet_ntop
#include <arpa/inet.h>

// close, unlink
#include <unistd.h>

// offsetof
#include <stddef.h>

// Max log message length 最大日志消息长度
#define MAX_LOG_MESSAGE_LENGTH 256

// Max data buffer size 最大数据缓冲区大小
#define MAX_BUFFER_SIZE 80

/**
 * Logs the given message to the application.
 * 将给定的消息记录到应用程序
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param format message format and arguments.
 */
static void LogMessage(
        JNIEnv* env,
        jobject obj,
        const char* format,
        ...)
{
    // Cached log method ID 缓存日志方法 ID
    static jmethodID methodID = NULL;

    // If method ID is not cached 如果方法ID未缓存
    if (NULL == methodID)
    {
        // Get class from object 从对象获取类
        jclass clazz = env->GetObjectClass(obj);

        // Get the method ID for the given method 从给定的方法中获取方法ID
        methodID = env->GetMethodID(clazz, "logMessage", "(Ljava/lang/String;)V");

        // Release the class reference 释放类引用
        env->DeleteLocalRef(clazz);
    }

    // If method is found 如果找到方法
    if (NULL != methodID)
    {
        // Format the log message 格式化日志消息
        char buffer[MAX_LOG_MESSAGE_LENGTH];

        va_list ap;
        va_start(ap, format);
        vsnprintf(buffer, MAX_LOG_MESSAGE_LENGTH, format, ap);
        va_end(ap);

        // Convert the buffer to a Java string 将缓冲区转换为 Java 字符串
        jstring message = env->NewStringUTF(buffer);

        // If string is properly constructed 如果字符串构造正确
        if (NULL != message)
        {
            // Log message 记录消息
            env->CallVoidMethod(obj, methodID, message);

            // Release the message reference 释放消息引用
            env->DeleteLocalRef(message);
        }
    }
}

/**
 * Throws a new exception using the given exception class
 * and exception message.
 * 用给定的异常类和异常消息抛出新的异常
 *
 * @param env JNIEnv interface.
 * @param className class name.
 * @param message exception message.
 */
static void ThrowException(
        JNIEnv* env,
        const char* className,
        const char* message)
{
    // Get the exception class 获取异常类
    jclass clazz = env->FindClass(className);

    // If exception class is found 如果异常类未找到
    if (NULL != clazz)
    {
        // Throw exception 抛出异常
        env->ThrowNew(clazz, message);

        // Release local class reference 释放原生类引用
        env->DeleteLocalRef(clazz);
    }
}

/**
 * Throws a new exception using the given exception class
 * and error message based on the error number.
 * 用给定异常类和基于错误号的错误消息抛出新异常
 *
 * @param env JNIEnv interface.
 * @param className class name.
 * @param errnum error number.
 */
static void ThrowErrnoException(
        JNIEnv* env,
        const char* className,
        int errnum)
{
    char buffer[MAX_LOG_MESSAGE_LENGTH];

    // Get message for the error number 获取错误号消息
    if (-1 == strerror_r(errnum, buffer, MAX_LOG_MESSAGE_LENGTH))
    {
        strerror_r(errno, buffer, MAX_LOG_MESSAGE_LENGTH);
    }

    // Throw exception 抛出异常
    ThrowException(env, className, buffer);
}

/**
 * Constructs a new TCP socket.
 * 构造新的 TCP socket
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @return socket descriptor.
 * @throws IOException
 */
static int NewTcpSocket(JNIEnv* env, jobject obj)
{
    // Construct 构造 socket
    LogMessage(env, obj, "Constructing a new TCP socket...");
    int tcpSocket = socket(PF_INET, SOCK_STREAM, 0);

    // Check if socket is properly constructed 检查 socket 构造是否正确
    if (-1 == tcpSocket)
    {
        // Throw an exception with error number 抛出带错误符号的异常
        ThrowErrnoException(env, "java/io/IOException", errno);
    }

    return tcpSocket;
}

/**
 * Binds socket to a port number.
 * 将 socket 绑定到某一端口号
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param sd socket descriptor.
 * @param port port number or zero for random port.
 * @throws IOException
 */
static void BindSocketToPort(
        JNIEnv* env,
        jobject obj,
        int sd,
        unsigned short port)
{
    struct sockaddr_in address;

    // Address to bind socket 绑定 socket 地址
    memset(&address, 0, sizeof(address));
    address.sin_family = PF_INET;

    // Bind to all addresses 绑定到所有的 IP 地址
    address.sin_addr.s_addr = htonl(INADDR_ANY);

    // Convert port to network byte order 将端口转换为网络字节顺序
    address.sin_port = htons(port);

    // Bind 绑定 socket
    LogMessage(env, obj, "Binding to port %hu.", port);
    if (-1 == bind(sd, (struct sockaddr*) &address, sizeof(address)))
    {
        // Throw an exception with error number 抛出带错误号的异常
        ThrowErrnoException(env, "java/io/IOException", errno);
    }
}

/**
 * Gets the port number socket is currently binded.
 * 获取当前绑定的端口号 socket
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param sd socket descriptor.
 * @return port number.
 * @throws IOException
 */
static unsigned short GetSocketPort(
        JNIEnv* env,
        jobject obj,
        int sd)
{
    unsigned short port = 0;

    struct sockaddr_in address;
    socklen_t addressLength = sizeof(address);

    // Get the socket address 获取 socket 地址
    if (-1 == getsockname(sd, (struct sockaddr*) &address, &addressLength))
    {
        // Throw an exception with error number 抛出带错误号的异常
        ThrowErrnoException(env, "java/io/IOException", errno);
    }
    else
    {
        // Convert port to host byte order 将端口转换为主机字节顺序
        port = ntohs(address.sin_port);

        LogMessage(env, obj, "Binded to random port %hu.", port);
    }

    return port;
}

/**
 * Listens on given socket with the given backlog for
 * pending connections. When the backlog is full, the
 * new connections will be rejected.
 * 监听指定的待处理连接的 backlog 的 socket，当 backlog 已满时拒绝新的连接
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param sd socket descriptor.
 * @param backlog backlog size.
 * @throws IOException
 */
static void ListenOnSocket(
        JNIEnv* env,
        jobject obj,
        int sd,
        int backlog)
{
    // Listen on socket with the given backlog 监听给定 backlog 的 socket
    LogMessage(env, obj,
            "Listening on socket with a backlog of %d pending connections.",
            backlog);

    if (-1 == listen(sd, backlog))
    {
        // Throw an exception with error number 抛出带错误符号的异常
        ThrowErrnoException(env, "java/io/IOException", errno);
    }
}

/**
 * Logs the IP address and the port number from the given address.
 * 记录给定地址的 IP 地址和端口号
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param message message text.
 * @param address adress instance.
 * @throws IOException
 */
static void LogAddress(
        JNIEnv* env,
        jobject obj,
        const char* message,
        const struct sockaddr_in* address)
{
    char ip[INET_ADDRSTRLEN];

    // Convert the IP address to string 将 IP 地址转换为字符串
    if (NULL == inet_ntop(PF_INET,
            &(address->sin_addr),
            ip,
            INET_ADDRSTRLEN))
    {
        // Throw an exception with error number 抛出带错误符号的异常
        ThrowErrnoException(env, "java/io/IOException", errno);
    }
    else
    {
        // Convert port to host byte order 将端口转换为主机字节顺序
        unsigned short port = ntohs(address->sin_port);

        // Log address 记录地址
        LogMessage(env, obj, "%s %s:%hu.", message, ip, port);
    }
}

/**
 * Blocks and waits for incoming client connections on the given socket.
 * 在给定的 socket 上阻塞和等待进来的客户连接
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param sd socket descriptor.
 * @return client socket.
 * @throws IOException
 */
static int AcceptOnSocket(
        JNIEnv* env,
        jobject obj,
        int sd)
{
    struct sockaddr_in address;
    socklen_t addressLength = sizeof(address);

    // Blocks and waits for an incoming client connection and accepts it
    // 阻塞和等待进来的客户连接并且接受它
    LogMessage(env, obj, "Waiting for a client connection...");

    int clientSocket = accept(sd,
            (struct sockaddr*) &address,
            &addressLength);

    // If client socket is not valid 如果客户 socket 无效
    if (-1 == clientSocket)
    {
        // Throw an exception with error number 抛出带错误符号的异常
        ThrowErrnoException(env, "java/io/IOException", errno);
    }
    else
    {
        // Log address 记录地址
        LogAddress(env, obj, "Client connection from ", &address);
    }

    return clientSocket;
}

/**
 * Block and receive data from the socket into the buffer.
 * 阻塞并接收来自 socket 的数据放到缓冲区
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param sd socket descriptor.
 * @param buffer data buffer.
 * @param bufferSize buffer size.
 * @return receive size.
 * @throws IOException
 */
static ssize_t ReceiveFromSocket(
        JNIEnv* env,
        jobject obj,
        int sd,
        char* buffer,
        size_t bufferSize)
{
    // Block and receive data from the socket into the buffer
    // 阻塞并接收来自 socket 的数据放到缓冲区
    LogMessage(env, obj, "Receiving from the socket...");
    ssize_t recvSize = recv(sd, buffer, bufferSize - 1, 0);

    // If receive is failed 如果接收失败
    if (-1 == recvSize)
    {
        // Throw an exception with error number 抛出带错误号的异常
        ThrowErrnoException(env, "java/io/IOException", errno);
    }
    else
    {
        // NULL terminate the buffer to make it a string 以空结尾缓冲区形成一个字符串
        buffer[recvSize] = NULL;

        // If data is received 如果数据接收成功
        if (recvSize > 0)
        {
            LogMessage(env, obj, "Received %d bytes: %s", recvSize, buffer);
        }
        else
        {
            LogMessage(env, obj, "Client disconnected.");
        }
    }

    return recvSize;
}

/**
 * Send data buffer to the socket.
 * 将数据缓冲区发送到 socket
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param sd socket descriptor.
 * @param buffer data buffer.
 * @param bufferSize buffer size.
 * @return sent size.
 * @throws IOException
 */
static ssize_t SendToSocket(
        JNIEnv* env,
        jobject obj,
        int sd,
        const char* buffer,
        size_t bufferSize)
{
    // Send data buffer to the socket 将数据缓冲区发送到 socket
    LogMessage(env, obj, "Sending to the socket...");
    ssize_t sentSize = send(sd, buffer, bufferSize, 0);

    // If send is failed 如果发送失败
    if (-1 == sentSize)
    {
        // Throw an exception with error number 抛出带错误符号的异常
        ThrowErrnoException(env, "java/io/IOException", errno);
    }
    else
    {
        if (sentSize > 0)
        {
            LogMessage(env, obj, "Sent %d bytes: %s", sentSize, buffer);
        }
        else
        {
            LogMessage(env, obj, "Client disconnected.");
        }
    }

    return sentSize;
}

/**
 * Connects to given IP address and given port.
 * 连接到给定的 IP 地址和给定的端口号
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param sd socket descriptor.
 * @param ip IP address.
 * @param port port number.
 * @throws IOException
 */
static void ConnectToAddress(
        JNIEnv* env,
        jobject obj,
        int sd,
        const char* ip,
        unsigned short port)
{
    // Connecting to given IP address and given port 连接到给定的 IP 地址和给定的端口号
    LogMessage(env, obj, "Connecting to %s:%uh...", ip, port);

    struct sockaddr_in address;

    memset(&address, 0, sizeof(address));
    address.sin_family = PF_INET;

    // Convert IP address string to Internet address 将 IP 地址字符串转换为网络地址
    if (0 == inet_aton(ip, &(address.sin_addr)))
    {
        // Throw an exception with error number 抛出带错误号的异常
        ThrowErrnoException(env, "java/io/IOException", errno);
    }
    else
    {
        // Convert port to network byte order 将端口号转换为网络字节顺序
        address.sin_port = htons(port);

        // Connect to address 转换为地址
        if (-1 == connect(sd, (const sockaddr*) &address, sizeof(address)))
        {
            // Throw an exception with error number 抛出带错误号的异常
            ThrowErrnoException(env, "java/io/IOException", errno);
        }
        else
        {
            LogMessage(env, obj, "Connected.");
        }
    }
}

// 原生 TCP 客户端
void Java_com_apress_echo_EchoClientActivity_nativeStartTcpClient(
        JNIEnv* env,
        jobject obj,
        jstring ip,
        jint port,
        jstring message)
{
    // Construct a new TCP socket. 构造新的 TCP socket
    int clientSocket = NewTcpSocket(env, obj);
    if (NULL == env->ExceptionOccurred())
    {
        // Get IP address as C string 以 C 字符串形式获取 IP 地址
        const char* ipAddress = env->GetStringUTFChars(ip, NULL);
        if (NULL == ipAddress)
            goto exit;

        // Connect to IP address and port 连接到 IP 地址和端口
        ConnectToAddress(env, obj, clientSocket, ipAddress,    (unsigned short) port);

        // Release the IP address 释放 IP 地址
        env->ReleaseStringUTFChars(ip, ipAddress);

        // If connection was successful 如果连接成功
        if (NULL != env->ExceptionOccurred())
            goto exit;

        // Get message as C string 以 C 字符串形式获取消息
        const char* messageText = env->GetStringUTFChars(message, NULL);
        if (NULL == messageText)
            goto exit;

        // Get the message size 获取消息大小
        jsize messageSize = env->GetStringUTFLength(message);

        // Send message to socket 发送消息给 socket
        SendToSocket(env, obj, clientSocket, messageText, messageSize);

        // Release the message text 释放消息文本
        env->ReleaseStringUTFChars(message, messageText);

        // If send was not successful 如果发送未成功
        if (NULL != env->ExceptionOccurred())
            goto exit;

        char buffer[MAX_BUFFER_SIZE];

        // Receive from the socket 从 socket 接收
        ReceiveFromSocket(env, obj, clientSocket, buffer, MAX_BUFFER_SIZE);
    }

exit:
    if (clientSocket > 0)
    {
        close(clientSocket);
    }
}

// 原生 TCP 服务器方法
void Java_com_apress_echo_EchoServerActivity_nativeStartTcpServer(
        JNIEnv* env,
        jobject obj,
        jint port)
{
    // Construct a new TCP socket. 构造新的 TCP socket
    int serverSocket = NewTcpSocket(env, obj);
    if (NULL == env->ExceptionOccurred())
    {
        // Bind socket to a port number 将 socket 绑定到某端口号
        BindSocketToPort(env, obj, serverSocket, (unsigned short) port);
        if (NULL != env->ExceptionOccurred())
            goto exit;

        // If random port number is requested 如果请求了随机端口号
        if (0 == port)
        {
            // Get the port number socket is currently binded 获取当前绑定的端口号 socket
            GetSocketPort(env, obj, serverSocket);
            if (NULL != env->ExceptionOccurred())
                goto exit;
        }

        // Listen on socket with a backlog of 4 pending connections 监听有4 个等待连接的 backlog 的 socket
        ListenOnSocket(env, obj, serverSocket, 4);
        if (NULL != env->ExceptionOccurred())
            goto exit;

        // Accept a client connection on socket 接受 socket 的一个客户连接
        int clientSocket = AcceptOnSocket(env, obj, serverSocket);
        if (NULL != env->ExceptionOccurred())
            goto exit;

        char buffer[MAX_BUFFER_SIZE];
        ssize_t recvSize;
        ssize_t sentSize;

        // Receive and send back the data 接收并发送回数据
        while (1)
        {
            // Receive from the socket 从 socket 中接收
            recvSize = ReceiveFromSocket(env, obj, clientSocket,
                    buffer, MAX_BUFFER_SIZE);

            if ((0 == recvSize) || (NULL != env->ExceptionOccurred()))
                break;

            // Send to the socket 发送给 socket
            sentSize = SendToSocket(env, obj, clientSocket,
                    buffer, (size_t) recvSize);

            if ((0 == sentSize) || (NULL != env->ExceptionOccurred()))
                break;
        }

        // Close the client socket 关闭客户端 socket
        close(clientSocket);
    }

exit:
    if (serverSocket > 0)
    {
        close(serverSocket);
    }
}

/**
 * Constructs a new UDP socket.
 * 构造新的 UDP socket
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @return socket descriptor.
 * @throws IOException
 */
static int NewUdpSocket(JNIEnv* env, jobject obj)
{
    // Construct socket 构造 socket
    LogMessage(env, obj, "Constructing a new UDP socket...");
    int udpSocket = socket(PF_INET, SOCK_DGRAM, 0);

    // Check if socket is properly constructed
    // 检查 socket 构造是否正确
    if (-1 == udpSocket)
    {
        // Throw an exception with error number 抛出带错误号的异常
        ThrowErrnoException(env, "java/io/IOException", errno);
    }

    return udpSocket;
}

/**
 * Block and receive datagram from the socket into
 * the buffer, and populate the client address.
 * 从 socket 中阻塞并接收数据报保存到缓冲区，填充客户端地址
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param sd socket descriptor.
 * @param address client address.
 * @param buffer data buffer.
 * @param bufferSize buffer size.
 * @return receive size.
 * @throws IOException
 */
static ssize_t ReceiveDatagramFromSocket(
        JNIEnv* env,
        jobject obj,
        int sd,
        struct sockaddr_in* address,
        char* buffer,
        size_t bufferSize)
{
    socklen_t addressLength = sizeof(struct sockaddr_in);

    // Receive datagram from socket 从 socket 中接收数据报
    LogMessage(env, obj, "Receiving from the socket...");
    ssize_t recvSize = recvfrom(sd, buffer, bufferSize, 0,
            (struct sockaddr*) address,    &addressLength);

    // If receive is failed 如果接收失败
    if (-1 == recvSize)
    {
        // Throw an exception with error number 抛出带错误号的异常
        ThrowErrnoException(env, "java/io/IOException", errno);
    }
    else
    {
        // Log address 记录地址
        LogAddress(env, obj, "Received from", address);

        // NULL terminate the buffer to make it a string
        // 以空终止缓冲区使其为一个字符串
        buffer[recvSize] = NULL;

        // If data is received 如果数据已经接收
        if (recvSize > 0)
        {
            LogMessage(env, obj, "Received %d bytes: %s", recvSize, buffer);
        }
    }

    return recvSize;
}

/**
 * Sends datagram to the given address using the given socket.
 * 用给定的 socket 发送数据到给定的地址
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param sd socket descriptor.
 * @param address remote address.
 * @param buffer data buffer.
 * @param bufferSize buffer size.
 * @return sent size.
 * @throws IOException
 */
static ssize_t SendDatagramToSocket(
        JNIEnv* env,
        jobject obj,
        int sd,
        const struct sockaddr_in* address,
        const char* buffer,
        size_t bufferSize)
{
    // Send data buffer to the socket 向 socket 发送数据缓冲区
    LogAddress(env, obj, "Sending to", address);
    ssize_t sentSize = sendto(sd, buffer, bufferSize, 0,
            (const sockaddr*) address,    sizeof(struct sockaddr_in));

    // If send is failed 如果发送失败
    if (-1 == sentSize)
    {
        // Throw an exception with error number 抛出带错误号的异常
        ThrowErrnoException(env, "java/io/IOException", errno);
    }
    else if (sentSize > 0)
    {
        LogMessage(env, obj, "Sent %d bytes: %s", sentSize, buffer);
    }

    return sentSize;
}

void Java_com_apress_echo_EchoClientActivity_nativeStartUdpClient(
        JNIEnv* env,
        jobject obj,
        jstring ip,
        jint port,
        jstring message)
{
    // Construct a new UDP socket. 构造一个新的 UDP socket
    int clientSocket = NewUdpSocket(env, obj);
    if (NULL == env->ExceptionOccurred())
    {
        struct sockaddr_in address;

        memset(&address, 0, sizeof(address));
        address.sin_family = PF_INET;

        // Get IP address as C string 以 C 字符串形式获取 IP 地址
        const char* ipAddress = env->GetStringUTFChars(ip, NULL);
        if (NULL == ipAddress)
            goto exit;

        // Convert IP address string to Internet address
        // 将 IP 地址字符串转换为网络地址
        int result = inet_aton(ipAddress, &(address.sin_addr));

        // Release the IP address 释放 IP 地址
        env->ReleaseStringUTFChars(ip, ipAddress);

        // If conversion is failed 如果转换失败
        if (0 == result)
        {
            // Throw an exception with error number 抛出带错误符号的异常
            ThrowErrnoException(env, "java/io/IOException", errno);
            goto exit;
        }

        // Convert port to network byte order 将端口转换为网络字节顺序
        address.sin_port = htons(port);

        // Get message as C string 以 C 字符串形式获取消息
        const char* messageText = env->GetStringUTFChars(message, NULL);
        if (NULL == messageText)
            goto exit;

        // Get the message size 获取消息大小
        jsize messageSize = env->GetStringUTFLength(message);

        // Send message to socket 发送消息给 socket
        SendDatagramToSocket(env, obj, clientSocket, &address,    messageText, messageSize);

        // Release the message text 释放消息文本
        env->ReleaseStringUTFChars(message, messageText);

        // If send was not successful 如果发送未成功
        if (NULL != env->ExceptionOccurred())
            goto exit;

        char buffer[MAX_BUFFER_SIZE];

        // Clear address 清除地址
        memset(&address, 0, sizeof(address));

        // Receive from the socket 从 socket 接收
        ReceiveDatagramFromSocket(env, obj, clientSocket, &address,    buffer, MAX_BUFFER_SIZE);
    }

exit:
    if (clientSocket > 0)
    {
        close(clientSocket);
    }
}

void Java_com_apress_echo_EchoServerActivity_nativeStartUdpServer(
        JNIEnv* env,
        jobject obj,
        jint port)
{
    // Construct a new UDP socket. 构造一个新的 UDP socket
    int serverSocket = NewUdpSocket(env, obj);
    if (NULL == env->ExceptionOccurred())
    {
        // Bind socket to a port number 将 socket 绑定到某一端口号
        BindSocketToPort(env, obj, serverSocket, (unsigned short) port);
        if (NULL != env->ExceptionOccurred())
            goto exit;

        // If random port number is requested 如果请求随机端口号
        if (0 == port)
        {
            // Get the port number socket is currently binded 获取当前绑定的端口号 socket
            GetSocketPort(env, obj, serverSocket);
            if (NULL != env->ExceptionOccurred())
                goto exit;
        }

        // Client address 客户端地址
        struct sockaddr_in address;
        memset(&address, 0, sizeof(address));

        char buffer[MAX_BUFFER_SIZE];
        ssize_t recvSize;
        ssize_t sentSize;

        // Receive from the socket 从 socket 中接收
        recvSize = ReceiveDatagramFromSocket(env, obj, serverSocket, &address, buffer, MAX_BUFFER_SIZE);

        if ((0 == recvSize) || (NULL != env->ExceptionOccurred()))
            goto exit;

        // Send to the socket 发送给 socket
        sentSize = SendDatagramToSocket(env, obj, serverSocket,    &address, buffer, (size_t) recvSize);
    }

exit:
    if (serverSocket > 0)
    {
        close(serverSocket);
    }
}

/**
 * Constructs a new Local UNIX socket.
 * 构造一个新的原生 UNIX socket
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @return socket descriptor.
 * @throws IOException
 */
static int NewLocalSocket(JNIEnv* env, jobject obj)
{
    // Construct socket 构造 socket
    LogMessage(env, obj, "Constructing a new Local UNIX socket...");
    int localSocket = socket(PF_LOCAL, SOCK_STREAM, 0);

    // Check if socket is properly constructed
    // 检查 socket 构造是否正确
    if (-1 == localSocket)
    {
        // Throw an exception with error number 抛出带错误号的异常
        ThrowErrnoException(env, "java/io/IOException", errno);
    }

    return localSocket;
}

/**
 * Binds a local UNIX socket to a name.
 * 将本地 UNIX socket 与某一名称绑定
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param sd socket descriptor.
 * @param name socket name.
 * @throws IOException
 */
static void BindLocalSocketToName(
        JNIEnv* env,
        jobject obj,
        int sd,
        const char* name)
{
    struct sockaddr_un address;

    // Name length 名称长度
    const size_t nameLength = strlen(name);

    // Path length is initiall equal to name length
    // 路径长度初始化与名称长度相等
    size_t pathLength = nameLength;

    // If name is not starting with a slash it is in the abstract namespace
    // 如果名称不是以 '/' 开头，即它在抽象命名空间里
    bool abstractNamespace = ('/' != name[0]);

    // Abstract namespace requires having the first byte of the path to be the zero byte,
    //  update the path length to include the zero byte
    // 抽象命名空间要求目录的第一个字节是 0 字节，更新路径长度包括 0 字节。
    if (abstractNamespace)
    {
        pathLength++;
    }

    // Check the path length 检查路径长度
    if (pathLength > sizeof(address.sun_path))
    {
        // Throw an exception with error number 抛出带错误号的异常
        ThrowException(env, "java/io/IOException", "Name is too big.");
    }
    else
    {
        // Clear the address bytes 清除地址字节
        memset(&address, 0, sizeof(address));
        address.sun_family = PF_LOCAL;

        // Socket path
        char* sunPath = address.sun_path;

        // First byte must be zero to use the abstract namespace
        // 第一字节必须是 0 以使用抽象命名空间
        if (abstractNamespace)
        {
            *sunPath++ = NULL;
        }

        // Append the local name 追加本地名字
        strcpy(sunPath, name);

        // Address length 地址长度
        socklen_t addressLength = (offsetof(struct sockaddr_un, sun_path)) + pathLength;

        // Unlink if the socket name is already binded
        // 如果 socket 名称已绑定，取消连接
        unlink(address.sun_path);

        // Bind socket
        LogMessage(env, obj, "Binding to local name %s%s.",
                (abstractNamespace) ? "(null)" : "", name);

        if (-1 == bind(sd, (struct sockaddr*) &address, addressLength))
        {
            // Throw an exception with error number 抛出带错误号的异常
            ThrowErrnoException(env, "java/io/IOException", errno);
        }
    }
}

/**
 * Blocks and waits for incoming client connections on the given socket.
 * 阻塞并等待给定 socket 上即将到来的客户端连接
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param sd socket descriptor.
 * @return client socket.
 * @throws IOException
 */
static int AcceptOnLocalSocket(
        JNIEnv* env,
        jobject obj,
        int sd)
{
    // Blocks and waits for an incoming client connection and accepts it
    // 阻塞并等待即将到来的客户端连接并且接收它
    LogMessage(env, obj, "Waiting for a client connection...");
    int clientSocket = accept(sd, NULL, NULL);

    // If client socket is not valid 如果客户端 socket 无效
    if (-1 == clientSocket)
    {
        // Throw an exception with error number 抛出带错误号的异常
        ThrowErrnoException(env, "java/io/IOException", errno);
    }

    return clientSocket;
}

void Java_com_apress_echo_LocalEchoActivity_nativeStartLocalServer(
        JNIEnv* env,
        jobject obj,
        jstring name)
{
    // Construct a new local UNIX socket. 构造一个新的本地 UNIX socket
    int serverSocket = NewLocalSocket(env, obj);
    if (NULL == env->ExceptionOccurred())
    {
        // Get name as C string 以 C 字符串形式获取名称
        const char* nameText = env->GetStringUTFChars(name, NULL);
        if (NULL == nameText)
            goto exit;

        // Bind socket to a port number 绑定 socket 到某一端口号
        BindLocalSocketToName(env, obj, serverSocket, nameText);

        // Release the name text 释放名称文本
        env->ReleaseStringUTFChars(name, nameText);

        // If bind is failed 如果绑定失败
        if (NULL != env->ExceptionOccurred())
            goto exit;

        // Listen on socket with a backlog of 4 pending connections
        // 监听有 4 个挂起连接的带 socket 的 socket
        ListenOnSocket(env, obj, serverSocket, 4);
        if (NULL != env->ExceptionOccurred())
            goto exit;

        // Accept a client connection on socket 接受 socket 的一个客户连接
        int clientSocket = AcceptOnLocalSocket(env, obj, serverSocket);
        if (NULL != env->ExceptionOccurred())
            goto exit;

        char buffer[MAX_BUFFER_SIZE];
        ssize_t recvSize;
        ssize_t sentSize;

        // Receive and send back the data 接收并发送回数据
        while (1)
        {
            // Receive from the socket 从 socket 中接收
            recvSize = ReceiveFromSocket(env, obj, clientSocket,
                    buffer, MAX_BUFFER_SIZE);

            if ((0 == recvSize) || (NULL != env->ExceptionOccurred()))
                break;

            // Send to the socket 发送给 socket
            sentSize = SendToSocket(env, obj, clientSocket,
                    buffer, (size_t) recvSize);

            if ((0 == sentSize) || (NULL != env->ExceptionOccurred()))
                break;
        }

        // Close the client socket 关闭客户端 socket
        close(clientSocket);
    }

exit:
    if (serverSocket > 0)
    {
        close(serverSocket);
    }
}

activity_echo_client.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <EditText
        android:id="@+id/ip_edit"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="@string/ip_edit" >

        <requestFocus />

    </EditText>

    <EditText
        android:id="@+id/port_edit"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="@string/port_edit"
        android:inputType="number" />
    
    <EditText
        android:id="@+id/message_edit"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="@string/message_edit" />
   
    <Button
        android:id="@+id/start_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/start_client_button" />

    <ScrollView
        android:id="@+id/log_scroll"
        android:layout_width="match_parent"
        android:layout_height="0dip"
        android:layout_weight="1.0" >

        <TextView
            android:id="@+id/log_view"
            android:layout_width="match_parent"
            android:layout_height="wrap_content" />
    </ScrollView>

</LinearLayout>

activity_echo_server.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal">
        
        <EditText
            android:id="@+id/port_edit"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:hint="@string/port_edit"
            android:inputType="number" >

            <requestFocus />
        </EditText>

        <Button
            android:id="@+id/start_button"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="@string/start_server_button" />

    </LinearLayout>

    <ScrollView
        android:id="@+id/log_scroll"
        android:layout_width="match_parent"
        android:layout_height="match_parent" >

        <TextView
            android:id="@+id/log_view"
            android:layout_width="match_parent"
            android:layout_height="wrap_content" />
    </ScrollView>

</LinearLayout>

activity_local_echo.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <EditText
        android:id="@+id/port_edit"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="@string/local_port_edit" >

        <requestFocus />

    </EditText>

    <EditText
        android:id="@+id/message_edit"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="@string/message_edit" />
   
    <Button
        android:id="@+id/start_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/start_client_button" />

    <ScrollView
        android:id="@+id/log_scroll"
        android:layout_width="match_parent"
        android:layout_height="0dip"
        android:layout_weight="1.0" >

        <TextView
            android:id="@+id/log_view"
            android:layout_width="match_parent"
            android:layout_height="wrap_content" />
    </ScrollView>

</LinearLayout>

Echo Manifest.xml

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.apress.echo"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="15" />

    <uses-permission android:name="android.permission.INTERNET" />

    <application
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        
        <activity
            android:name=".EchoServerActivity"
            android:label="@string/title_activity_echo_server"
            android:launchMode="singleTop" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        
        <activity
            android:name=".EchoClientActivity"
            android:label="@string/title_activity_echo_client"
            android:launchMode="singleTop" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity
            android:name=".LocalEchoActivity"
            android:label="@string/title_activity_local_echo" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>